MoreThanText/morethantext
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

replace Option<Field> with Field::None.
Some checks failed
Gitea Actions Demo / Explore-Gitea-Actions (push) Failing after 1s
Details

Browse Source
This commit is contained in:
Jeff Baskin 2025-11-01 11:56:36 -04:00
parent 012984f6b7
commit f40d030d88
1 changed files with 88 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

132
src/message.rs
View File

@ -2118,7 +2118,10 @@ impl FieldSetting {
} }
} }
fn set_default<CV>(&mut self, holder: CV) -> Result<(), MTTError> where CV: Into<CalcValue> { fn set_default<CV>(&mut self, holder: CV) -> Result<(), MTTError>
where
CV: Into<CalcValue>,
{
let value = holder.into(); let value = holder.into();
match &value { match &value {
CalcValue::Calculate(calc) => { CalcValue::Calculate(calc) => {
@ -2136,28 +2139,28 @@ impl FieldSetting {
return Err(MTTError::FieldInvalidType); return Err(MTTError::FieldInvalidType);
} }
} }
CalcValue::None => {}, CalcValue::None => {}
} }
self.default_value = value; self.default_value = value;
Ok(()) Ok(())
} }
fn validate(&self, value: Option<Field>) -> Result<Field, MTTError> { fn validate(&self, value: &Field) -> Result<Field, MTTError> {
match value { match value {
Some(data) => { Field::None => match &self.default_value {
let vft: FieldType = (&data).into(); CalcValue::None => Err(MTTError::InvalidNone),
_ => Ok(self.default_value.get(&Field::None)),
},
_ => {
let vft: FieldType = value.into();
if vft != self.fieldtype { if vft != self.fieldtype {
return Err(MTTError::DocumentFieldWrongDataType( return Err(MTTError::DocumentFieldWrongDataType(
self.fieldtype.clone(), self.fieldtype.clone(),
vft, vft,
)); ));
} }
Ok(data.clone()) Ok(value.clone())
} }
None => match &self.default_value {
CalcValue::None => Err(MTTError::InvalidNone),
_ => Ok(self.default_value.get(&Field::None)),
},
} }
} }
} }
@ -2170,7 +2173,7 @@ mod fieldsettings {
fn validates_field_type() { fn validates_field_type() {
let fset = FieldSetting::new(FieldType::Uuid); let fset = FieldSetting::new(FieldType::Uuid);
let value: Field = Uuid::new_v4().into(); let value: Field = Uuid::new_v4().into();
match fset.validate(Some(value.clone())) { match fset.validate(&value) {
Ok(data) => assert_eq!(data, value), Ok(data) => assert_eq!(data, value),
Err(err) => unreachable!("got {:?}: should have gotten a value", err), Err(err) => unreachable!("got {:?}: should have gotten a value", err),
} }
@ -2180,7 +2183,7 @@ mod fieldsettings {
fn validates_for_bad_field_type() { fn validates_for_bad_field_type() {
let fset = FieldSetting::new(FieldType::Uuid); let fset = FieldSetting::new(FieldType::Uuid);
let value: Field = "text".into(); let value: Field = "text".into();
match fset.validate(Some(value)) { match fset.validate(&value) {
Ok(data) => unreachable!("got {:?}: should have gotten an error", data), Ok(data) => unreachable!("got {:?}: should have gotten an error", data),
Err(err) => match err { Err(err) => match err {
MTTError::DocumentFieldWrongDataType(expected, got) => { MTTError::DocumentFieldWrongDataType(expected, got) => {
@ -2195,7 +2198,7 @@ mod fieldsettings {
#[test] #[test]
fn no_default_returns_error() { fn no_default_returns_error() {
let fset = FieldSetting::new(FieldType::Uuid); let fset = FieldSetting::new(FieldType::Uuid);
match fset.validate(None) { match fset.validate(&Field::None) {
Ok(data) => unreachable!("got {:?}: should have gotten an error", data), Ok(data) => unreachable!("got {:?}: should have gotten an error", data),
Err(err) => match err { Err(err) => match err {
MTTError::InvalidNone => {} MTTError::InvalidNone => {}
@ -2208,7 +2211,7 @@ mod fieldsettings {
fn returns_value_if_default_is_set() { fn returns_value_if_default_is_set() {
let mut fset = FieldSetting::new(FieldType::StaticString); let mut fset = FieldSetting::new(FieldType::StaticString);
fset.set_default(FieldType::StaticString); fset.set_default(FieldType::StaticString);
match fset.validate(None) { match fset.validate(&Field::None) {
Ok(data) => assert_eq!(data, "".into()), Ok(data) => assert_eq!(data, "".into()),
Err(err) => unreachable!("got {:?}: should have gotten a value", err), Err(err) => unreachable!("got {:?}: should have gotten a value", err),
} }
@ -2219,7 +2222,7 @@ mod fieldsettings {
let mut fset = FieldSetting::new(FieldType::StaticString); let mut fset = FieldSetting::new(FieldType::StaticString);
let input = "fred"; let input = "fred";
fset.set_default(input); fset.set_default(input);
match fset.validate(None) { match fset.validate(&Field::None) {
Ok(data) => assert_eq!(data, input.into()), Ok(data) => assert_eq!(data, input.into()),
Err(err) => unreachable!("got {:?}: should have gotten a value", err), Err(err) => unreachable!("got {:?}: should have gotten a value", err),
} }
@ -2234,7 +2237,7 @@ mod fieldsettings {
calc.add_value(duration); calc.add_value(duration);
fset.set_default(calc); fset.set_default(calc);
let start = Utc::now() + duration; let start = Utc::now() + duration;
let result = match fset.validate(None).unwrap() { let result = match fset.validate(&Field::None).unwrap() {
Field::DateTime(data) => data, Field::DateTime(data) => data,
_ => unreachable!("should return datetime"), _ => unreachable!("should return datetime"),
}; };
@ -2274,7 +2277,7 @@ impl Addition {
self.data.add_field(name, field); self.data.add_field(name, field);
} }
fn get_field<NT>(&self, name: NT) -> Option<Field> fn get_field<NT>(&self, name: NT) -> &CalcValue
where where
NT: Into<NameType>, NT: Into<NameType>,
{ {
@ -2296,34 +2299,46 @@ mod additions {
let name = Name::english(Uuid::new_v4().to_string().as_str()); let name = Name::english(Uuid::new_v4().to_string().as_str());
let data = Uuid::new_v4().to_string(); let data = Uuid::new_v4().to_string();
add.add_field(name.clone(), data.clone()); add.add_field(name.clone(), data.clone());
let result = add.get_field(&name).unwrap(); let result = add.get_field(&name);
match result { match result {
Field::StaticString(result) => assert_eq!(result, data), CalcValue::Value(result) => match result {
_ => unreachable!("got {:?}: should have received static string", result), Field::StaticString(output) => assert_eq!(output, &data),
_ => unreachable!("got {:?}, should have been a string", result),
},
_ => unreachable!("got {:?}: should have received value", result),
} }
} }
#[test]
fn can_add_uuid() { fn can_add_uuid() {
let mut add = Addition::new(); let mut add = Addition::new();
let name = Name::english(Uuid::new_v4().to_string().as_str()); let name = Name::english(Uuid::new_v4().to_string().as_str());
let data = Uuid::new_v4(); let data = Uuid::new_v4();
add.add_field(name.clone(), data.clone()); add.add_field(name.clone(), data.clone());
let result = add.get_field(&name).unwrap(); let output = add.get_field(&name);
match result { match output {
Field::Uuid(result) => assert_eq!(result, data), CalcValue::Value(result) => match result {
Field::Uuid(result) => assert_eq!(result, &data),
_ => unreachable!("got {:?}: should have received uuid", result), _ => unreachable!("got {:?}: should have received uuid", result),
},
_ => unreachable!("got {:?}: should have received value", output),
} }
} }
#[test]
fn can_get_document() { fn can_get_document() {
let mut add = Addition::new(); let mut add = Addition::new();
let name = Name::english(Uuid::new_v4().to_string().as_str()); let name = Name::english(Uuid::new_v4().to_string().as_str());
let data = Uuid::new_v4(); let data = Uuid::new_v4();
add.add_field(name.clone(), data.clone()); add.add_field(name.clone(), data.clone());
let doc: Document = add.get_document(); let doc = add.get_document();
match doc.get_field(&name).unwrap() { let output = doc.get_field(&name);
Field::Uuid(result) => assert_eq!(result, data), match output {
CalcValue::Value(holder) => match holder {
Field::Uuid(result) => assert_eq!(result, &data),
_ => unreachable!("should have received uuid"), _ => unreachable!("should have received uuid"),
},
_ => unreachable!("got {:?}: should have received value", output),
} }
} }
} }
@ -2414,7 +2429,7 @@ impl DocDef {
self.fields.keys().cloned().collect() self.fields.keys().cloned().collect()
} }
fn validate<NT>(&self, field_name: NT, value: Option<Field>) -> Result<Field, MTTError> fn validate<NT>(&self, field_name: NT, value: &Field) -> Result<Field, MTTError>
where where
NT: Into<NameType>, NT: Into<NameType>,
{ {
@ -2425,7 +2440,10 @@ impl DocDef {
self.fields.get(&id).unwrap().validate(value) self.fields.get(&id).unwrap().validate(value)
} }
fn set_default<CV>(&mut self, field_name: &Name, value: CV) -> Result<(), MTTError> where CV: Into<CalcValue> { fn set_default<CV>(&mut self, field_name: &Name, value: CV) -> Result<(), MTTError>
where
CV: Into<CalcValue>,
{
let id = match self.field_names.get_id(field_name) { let id = match self.field_names.get_id(field_name) {
Ok(data) => data, Ok(data) => data,
Err(err) => return Err(err), Err(err) => return Err(err),
@ -2466,7 +2484,7 @@ mod docdefs {
let field_type = FieldType::Uuid; let field_type = FieldType::Uuid;
docdef.add_field(name.clone(), field_type.clone()); docdef.add_field(name.clone(), field_type.clone());
let result = docdef.get_field(name).unwrap(); let result = docdef.get_field(name).unwrap();
match result.validate(Some(Uuid::new_v4().into())) { match result.validate(&Uuid::new_v4().into()) {
Ok(_) => {} Ok(_) => {}
Err(err) => unreachable!("got {:?}: should have been a value", err), Err(err) => unreachable!("got {:?}: should have been a value", err),
} }
@ -2497,7 +2515,7 @@ mod docdefs {
} }
for name in names.iter() { for name in names.iter() {
let result = docdef.get_field(Name::english(name.clone())).unwrap(); let result = docdef.get_field(Name::english(name.clone())).unwrap();
match result.validate(Some("".into())) { match result.validate(&"".into()) {
Ok(_) => {} Ok(_) => {}
Err(err) => unreachable!("got {:?}: should have been a value", err), Err(err) => unreachable!("got {:?}: should have been a value", err),
} }
@ -2511,7 +2529,7 @@ mod docdefs {
let name = Name::english("defaultfunction"); let name = Name::english("defaultfunction");
docdef.add_field(name.clone(), FieldType::StaticString); docdef.add_field(name.clone(), FieldType::StaticString);
docdef.set_default(&name, FieldType::StaticString); docdef.set_default(&name, FieldType::StaticString);
match docdef.get_field(name).unwrap().validate(None) { match docdef.get_field(name).unwrap().validate(&Field::None) {
Ok(data) => match data { Ok(data) => match data {
Field::StaticString(result) => assert_eq!(result, ""), Field::StaticString(result) => assert_eq!(result, ""),
_ => unreachable!("got {:?}: should return a static string", data), _ => unreachable!("got {:?}: should return a static string", data),
@ -2543,7 +2561,7 @@ mod docdefs {
match docdef.set_default(&name, "fred") { match docdef.set_default(&name, "fred") {
Ok(data) => unreachable!("got {:?}, should be an error", data), Ok(data) => unreachable!("got {:?}, should be an error", data),
Err(err) => match err { Err(err) => match err {
MTTError::FieldInvalidType => {}, MTTError::FieldInvalidType => {}
_ => unreachable!("got {:?}: should have been field not found", err), _ => unreachable!("got {:?}: should have been field not found", err),
}, },
} }
@ -2915,7 +2933,6 @@ impl Calculation {
} }
} }
} }
// Operand::Assign => result = self.values[0].get(existing),
Operand::Equal => { Operand::Equal => {
if self.values.len() >= 2 { if self.values.len() >= 2 {
result = self.values[0] result = self.values[0]
@ -3224,14 +3241,20 @@ mod replies {
reply.add(doc2); reply.add(doc2);
let mut reply_iter = reply.iter(); let mut reply_iter = reply.iter();
let mut result1 = reply_iter.next().unwrap(); let mut result1 = reply_iter.next().unwrap();
match result1.get_field(&fieldname).unwrap() { match result1.get_field(&fieldname) {
CalcValue::Value(data) => match data {
Field::StaticString(output) => assert_eq!(output, "one"), Field::StaticString(output) => assert_eq!(output, "one"),
_ => unreachable!("got {:?}: should have been static string", result1), _ => unreachable!("got {:?}: should have been static string", result1),
},
_ => unreachable!("got {:?}, should have been value", result1),
} }
let result2 = reply_iter.next().unwrap(); let result2 = reply_iter.next().unwrap();
match result2.get_field(&fieldname).unwrap() { match result2.get_field(&fieldname) {
CalcValue::Value(data) => match data {
Field::StaticString(output) => assert_eq!(output, "two"), Field::StaticString(output) => assert_eq!(output, "two"),
_ => unreachable!("got {:?}: should have been static string", result2), _ => unreachable!("got {:?}: should have been static string", result2),
},
_ => unreachable!("got {:?}, should have been value", result2),
} }
match reply_iter.next() { match reply_iter.next() {
None => {} None => {}
@ -3252,11 +3275,14 @@ impl InternalRecord {
} }
} }
fn insert<F>(&mut self, id: Uuid, data: F) -> Option<Field> fn insert<F>(&mut self, id: Uuid, data: F) -> Field
where where
F: Into<Field>, F: Into<Field>,
{ {
self.data.insert(id, data.into()) match self.data.insert(id, data.into()) {
Some(data) => data.clone(),
None => Field::None,
}
} }
fn get(&self, id: &Uuid) -> Option<&Field> { fn get(&self, id: &Uuid) -> Option<&Field> {
@ -3562,13 +3588,13 @@ impl Document {
self.data.insert(name.into(), field.into()); self.data.insert(name.into(), field.into());
} }
fn get_field<NT>(&self, name: NT) -> Option<Field> fn get_field<NT>(&self, name: NT) -> &CalcValue
where where
NT: Into<NameType>, NT: Into<NameType>,
{ {
match self.data.get(&name.into()) { match self.data.get(&name.into()) {
Some(data) => Some(data.get(&Field::None)), Some(data) => data,
None => None, None => &CalcValue::None,
} }
} }
@ -3619,10 +3645,13 @@ mod documents {
let name = Name::english(Uuid::new_v4().to_string().as_str()); let name = Name::english(Uuid::new_v4().to_string().as_str());
let data = Uuid::new_v4().to_string(); let data = Uuid::new_v4().to_string();
add.add_field(name.clone(), data.clone()); add.add_field(name.clone(), data.clone());
let result = add.get_field(&name).unwrap(); let result = add.get_field(&name);
match result { match result {
Field::StaticString(result) => assert_eq!(result, data), CalcValue::Value(holder) => match holder {
_ => unreachable!("got {:?}: should have received static string", result), Field::StaticString(result) => assert_eq!(result, &data),
_ => unreachable!("got {:?}: should have received static string", holder),
},
_ => unreachable!("got {:?}, should have been value", result),
} }
} }
@ -3631,10 +3660,13 @@ mod documents {
let name = Name::english(Uuid::new_v4().to_string().as_str()); let name = Name::english(Uuid::new_v4().to_string().as_str());
let data = Uuid::new_v4(); let data = Uuid::new_v4();
add.add_field(name.clone(), data.clone()); add.add_field(name.clone(), data.clone());
let result = add.get_field(&name).unwrap(); let result = add.get_field(&name);
match result { match result {
Field::Uuid(result) => assert_eq!(result, data), CalcValue::Value(holder) => match holder {
_ => unreachable!("got {:?}: should have received uuid", result), Field::Uuid(result) => assert_eq!(result, &data),
_ => unreachable!("got {:?}: should have received static string", holder),
},
_ => unreachable!("got {:?}, should have been value", result),
} }
} }
} }
@ -4113,7 +4145,7 @@ impl DocumentFile {
&self.docdef &self.docdef
} }
fn validate<NT>(&self, field_name: NT, value: Option<Field>) -> Result<(Uuid, Field), MTTError> fn validate<NT>(&self, field_name: NT, value: &Field) -> Result<(Uuid, Field), MTTError>
where where
NT: Into<NameType>, NT: Into<NameType>,
{ {
@ -4159,7 +4191,7 @@ impl DocumentFile {
let mut holder = InternalRecord::new(); let mut holder = InternalRecord::new();
let doc = addition.get_document(); let doc = addition.get_document();
for (field, value) in doc.iter() { for (field, value) in doc.iter() {
match self.validate(field, Some(value)) { match self.validate(field, &value) {
Ok((id, data)) => { Ok((id, data)) => {
holder.insert(id, data); holder.insert(id, data);
} }
@ -4169,7 +4201,7 @@ impl DocumentFile {
let requested: HashSet<Uuid> = holder.keys().cloned().collect(); let requested: HashSet<Uuid> = holder.keys().cloned().collect();
let all_fields = self.docdef.field_ids(); let all_fields = self.docdef.field_ids();
for field in all_fields.difference(&requested).cloned() { for field in all_fields.difference(&requested).cloned() {
match self.validate(field, None) { match self.validate(field, &Field::None) {
Ok((id, data)) => { Ok((id, data)) => {
holder.insert(id, data); holder.insert(id, data);
} }
@ -4265,7 +4297,7 @@ impl DocumentFile {
fn update(&mut self, update: &Update) -> MsgAction { fn update(&mut self, update: &Update) -> MsgAction {
let mut changes: HashMap<Uuid, Field> = HashMap::new(); let mut changes: HashMap<Uuid, Field> = HashMap::new();
for (key, value) in update.get_values().iter() { for (key, value) in update.get_values().iter() {
let (id, field) = match self.validate(key, Some(value.clone())) { let (id, field) = match self.validate(key, &value) {
Ok(data) => data, Ok(data) => data,
Err(err) => return err.into(), Err(err) => return err.into(),
}; };