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

Relaced Calculation with CalcValue for FieldSettings.
Some checks failed
Gitea Actions Demo / Explore-Gitea-Actions (push) Failing after 2m50s
Details

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

131
src/message.rs
View File

@ -2107,24 +2107,38 @@ mod fields {
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
struct FieldSetting { struct FieldSetting {
fieldtype: FieldType, fieldtype: FieldType,
default_value: Option<Calculation>, default_value: CalcValue,
} }
impl FieldSetting { impl FieldSetting {
fn new(ftype: FieldType) -> Self { fn new(ftype: FieldType) -> Self {
Self { Self {
fieldtype: ftype, fieldtype: ftype,
default_value: None, default_value: CalcValue::None,
} }
} }
fn set_default(&mut self, value: Calculation) -> Result<(), MTTError> { fn set_default<CV>(&mut self, holder: CV) -> Result<(), MTTError> where CV: Into<CalcValue> {
let data = value.calculate(&Field::None); let value = holder.into();
match self.validate(Some(data)) { match &value {
Ok(_) => {} CalcValue::Calculate(calc) => {
Err(err) => return Err(err), if self.fieldtype != calc.get_type() {
return Err(MTTError::FieldInvalidType);
}
}
CalcValue::Existing(ftype) | CalcValue::FType(ftype) => {
if &self.fieldtype != ftype {
return Err(MTTError::FieldInvalidType);
}
}
CalcValue::Value(ref item) => {
if item.get_type() != self.fieldtype {
return Err(MTTError::FieldInvalidType);
}
}
CalcValue::None => {},
} }
self.default_value = Some(value); self.default_value = value;
Ok(()) Ok(())
} }
@ -2141,8 +2155,8 @@ impl FieldSetting {
Ok(data.clone()) Ok(data.clone())
} }
None => match &self.default_value { None => match &self.default_value {
Some(calc) => Ok(calc.calculate(&Field::None)), CalcValue::None => Err(MTTError::InvalidNone),
None => Err(MTTError::InvalidNone), _ => Ok(self.default_value.get(&Field::None)),
}, },
} }
} }
@ -2193,9 +2207,7 @@ mod fieldsettings {
#[test] #[test]
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);
let mut calc = Calculation::new(Operand::Assign); fset.set_default(FieldType::StaticString);
calc.add_value(FieldType::StaticString);
fset.set_default(calc);
match fset.validate(None) { match fset.validate(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),
@ -2206,9 +2218,7 @@ mod fieldsettings {
fn returns_default_value() { fn returns_default_value() {
let mut fset = FieldSetting::new(FieldType::StaticString); let mut fset = FieldSetting::new(FieldType::StaticString);
let input = "fred"; let input = "fred";
let mut calc = Calculation::new(Operand::Assign); fset.set_default(input);
calc.add_value(input);
fset.set_default(calc);
match fset.validate(None) { match fset.validate(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),
@ -2415,7 +2425,7 @@ impl DocDef {
self.fields.get(&id).unwrap().validate(value) self.fields.get(&id).unwrap().validate(value)
} }
fn set_default(&mut self, field_name: &Name, value: Calculation) -> Result<(), MTTError> { 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),
@ -2500,9 +2510,7 @@ mod docdefs {
let mut docdef = DocDef::new(docname); let mut docdef = DocDef::new(docname);
let name = Name::english("defaultfunction"); let name = Name::english("defaultfunction");
docdef.add_field(name.clone(), FieldType::StaticString); docdef.add_field(name.clone(), FieldType::StaticString);
let mut calc = Calculation::new(Operand::Assign); docdef.set_default(&name, FieldType::StaticString);
calc.add_value(FieldType::StaticString);
docdef.set_default(&name, calc);
match docdef.get_field(name).unwrap().validate(None) { match docdef.get_field(name).unwrap().validate(None) {
Ok(data) => match data { Ok(data) => match data {
Field::StaticString(result) => assert_eq!(result, ""), Field::StaticString(result) => assert_eq!(result, ""),
@ -2512,29 +2520,12 @@ mod docdefs {
} }
} }
#[test]
fn does_set_default_function_error_on_bad_field_name() {
let docname = Name::english("something");
let mut docdef = DocDef::new(docname);
let field_name = Name::english("wrong");
let calc = Calculation::new(Operand::Assign);
match docdef.set_default(&field_name, calc) {
Ok(_) => unreachable!("should be an error"),
Err(err) => match err {
MTTError::NameNotFound(data) => assert_eq!(data, field_name),
_ => unreachable!("got {:?}: should have been field not found", err),
},
}
}
#[test] #[test]
fn does_set_default_value_error_on_bad_field_name() { fn does_set_default_value_error_on_bad_field_name() {
let docname = Name::english("something"); let docname = Name::english("something");
let mut docdef = DocDef::new(docname); let mut docdef = DocDef::new(docname);
let field_name = Name::english(Uuid::new_v4().to_string().as_str()); let field_name = Name::english(Uuid::new_v4().to_string().as_str());
let mut calc = Calculation::new(Operand::Assign); match docdef.set_default(&field_name, FieldType::Uuid) {
calc.add_value(Uuid::new_v4());
match docdef.set_default(&field_name, calc) {
Ok(_) => unreachable!("should be an error"), Ok(_) => unreachable!("should be an error"),
Err(err) => match err { Err(err) => match err {
MTTError::NameNotFound(data) => assert_eq!(data, field_name), MTTError::NameNotFound(data) => assert_eq!(data, field_name),
@ -2549,15 +2540,10 @@ mod docdefs {
let mut docdef = DocDef::new(docname); let mut docdef = DocDef::new(docname);
let name = Name::english("defaultvalue"); let name = Name::english("defaultvalue");
docdef.add_field(name.clone(), FieldType::Uuid); docdef.add_field(name.clone(), FieldType::Uuid);
let mut calc = Calculation::new(Operand::Assign); match docdef.set_default(&name, "fred") {
calc.add_value("fred");
match docdef.set_default(&name, calc) {
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::DocumentFieldWrongDataType(expected, got) => { MTTError::FieldInvalidType => {},
assert_eq!(expected, FieldType::Uuid);
assert_eq!(got, FieldType::StaticString);
}
_ => unreachable!("got {:?}: should have been field not found", err), _ => unreachable!("got {:?}: should have been field not found", err),
}, },
} }
@ -2567,7 +2553,7 @@ mod docdefs {
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
enum Operand { enum Operand {
Add, Add,
Assign, //Assign,
Equal, Equal,
} }
@ -2606,6 +2592,7 @@ enum CalcValue {
Calculate(Calculation), Calculate(Calculation),
Existing(FieldType), Existing(FieldType),
FType(FieldType), FType(FieldType),
None,
Value(Field), Value(Field),
} }
@ -2615,6 +2602,7 @@ impl CalcValue {
Self::Calculate(calc) => calc.calculate(existing), Self::Calculate(calc) => calc.calculate(existing),
Self::Existing(_) => existing.clone(), Self::Existing(_) => existing.clone(),
Self::FType(ftype) => ftype.get_default(), Self::FType(ftype) => ftype.get_default(),
Self::None => Field::None,
Self::Value(field) => field.clone(), Self::Value(field) => field.clone(),
} }
} }
@ -2624,6 +2612,7 @@ impl CalcValue {
Self::Calculate(calc) => calc.get_type(), Self::Calculate(calc) => calc.get_type(),
Self::Existing(ftype) => ftype.clone(), Self::Existing(ftype) => ftype.clone(),
Self::FType(ftype) => ftype.clone(), Self::FType(ftype) => ftype.clone(),
Self::None => FieldType::None,
Self::Value(field) => field.into(), Self::Value(field) => field.into(),
} }
} }
@ -2926,7 +2915,7 @@ impl Calculation {
} }
} }
} }
Operand::Assign => result = self.values[0].get(existing), // 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]
@ -2962,9 +2951,9 @@ mod calculations {
#[test] #[test]
fn returns_reference_to_operand() { fn returns_reference_to_operand() {
let calc = Calculation::new(Operand::Assign); let calc = Calculation::new(Operand::Add);
match calc.operation() { match calc.operation() {
Operand::Assign => {} Operand::Add => {}
_ => unreachable!("got {:?}, shold have gotten assign", calc.operation()), _ => unreachable!("got {:?}, shold have gotten assign", calc.operation()),
} }
let calc = Calculation::new(Operand::Equal); let calc = Calculation::new(Operand::Equal);
@ -2974,24 +2963,6 @@ mod calculations {
} }
} }
#[test]
fn can_assign_value() {
let mut calc = Calculation::new(Operand::Assign);
let data: Field = Uuid::new_v4().into();
calc.add_value(data.clone());
let result = calc.calculate(&Field::None);
assert_eq!(result, data);
}
#[test]
fn can_assign_default_function() {
let mut calc = Calculation::new(Operand::Assign);
calc.add_value(FieldType::Uuid);
let result1 = calc.calculate(&Field::None);
let result2 = calc.calculate(&Field::None);
assert_ne!(result1, result2);
}
#[test] #[test]
fn can_equal_true() { fn can_equal_true() {
let mut calc = Calculation::new(Operand::Equal); let mut calc = Calculation::new(Operand::Equal);
@ -3196,20 +3167,6 @@ mod queries {
None => unreachable!("should have returned a calculation"), None => unreachable!("should have returned a calculation"),
} }
} }
#[test]
fn does_not_allow_data_changes() {
let mut calc = Calculation::new(Operand::Assign);
calc.add_value(Uuid::nil());
let mut query = Query::new();
match query.add(Name::english("name"), calc) {
Ok(_) => unreachable!("Should have received an error"),
Err(err) => match err {
MTTError::QueryCannotChangeData => {}
_ => unreachable!("got {:?}, should have gotten cannot change data", err),
},
}
}
} }
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
@ -5012,9 +4969,7 @@ mod document_files {
let mut docdef = DocDef::new(doc_name.clone()); let mut docdef = DocDef::new(doc_name.clone());
let field_name = Name::english("holder"); let field_name = Name::english("holder");
docdef.add_field(field_name.clone(), FieldType::StaticString); docdef.add_field(field_name.clone(), FieldType::StaticString);
let mut calc = Calculation::new(Operand::Assign); docdef.set_default(&field_name, FieldType::StaticString);
calc.add_value(FieldType::StaticString);
docdef.set_default(&field_name, calc);
let mut test_doc: TestDocument = docdef.into(); let mut test_doc: TestDocument = docdef.into();
test_doc.start(); test_doc.start();
let queue = test_doc.get_queue(); let queue = test_doc.get_queue();
@ -5042,9 +4997,7 @@ mod document_files {
let mut docdef = DocDef::new(doc_name.clone()); let mut docdef = DocDef::new(doc_name.clone());
let field_name = Name::english("id"); let field_name = Name::english("id");
docdef.add_field(field_name.clone(), FieldType::Uuid); docdef.add_field(field_name.clone(), FieldType::Uuid);
let mut calc = Calculation::new(Operand::Assign); docdef.set_default(&field_name, Uuid::nil());
calc.add_value(Uuid::nil());
docdef.set_default(&field_name, calc);
let mut test_doc: TestDocument = docdef.into(); let mut test_doc: TestDocument = docdef.into();
test_doc.start(); test_doc.start();
let queue = test_doc.get_queue(); let queue = test_doc.get_queue();
@ -5072,9 +5025,7 @@ mod document_files {
let mut docdef = DocDef::new(doc_name.clone()); let mut docdef = DocDef::new(doc_name.clone());
let field_name = Name::english("id"); let field_name = Name::english("id");
docdef.add_field(field_name.clone(), FieldType::Uuid); docdef.add_field(field_name.clone(), FieldType::Uuid);
let mut calc = Calculation::new(Operand::Assign); docdef.set_default(&field_name, FieldType::Uuid);
calc.add_value(FieldType::Uuid);
docdef.set_default(&field_name, calc);
let mut test_doc: TestDocument = docdef.into(); let mut test_doc: TestDocument = docdef.into();
test_doc.start(); test_doc.start();
let queue = test_doc.get_queue(); let queue = test_doc.get_queue();