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

Added existing to the calculations.
Some checks failed
Gitea Actions Demo / Explore-Gitea-Actions (push) Failing after 1s
Details

Browse Source
This commit is contained in:
Jeff Baskin 2025-10-28 15:23:40 -04:00
parent 09b4aad7bd
commit 6709a96285
1 changed files with 82 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

132
src/message.rs
View File

@ -1964,7 +1964,7 @@ impl FieldSetting {
} }
fn set_default(&mut self, value: Calculation) -> Result<(), MTTError> { fn set_default(&mut self, value: Calculation) -> Result<(), MTTError> {
let data = value.calculate(); let data = value.calculate(Field::None);
match self.validate(Some(data)) { match self.validate(Some(data)) {
Ok(_) => {} Ok(_) => {}
Err(err) => return Err(err), Err(err) => return Err(err),
@ -1986,7 +1986,7 @@ impl FieldSetting {
Ok(data.clone()) Ok(data.clone())
} }
None => match &self.default_value { None => match &self.default_value {
Some(calc) => Ok(calc.calculate()), Some(calc) => Ok(calc.calculate(Field::None)),
None => Err(MTTError::InvalidNone), None => Err(MTTError::InvalidNone),
}, },
} }
@ -2449,16 +2449,18 @@ mod operands {
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
enum CalcValue { enum CalcValue {
Calculate(Calculation), Calculate(Calculation),
Existing(FieldType),
FType(FieldType), FType(FieldType),
Value(Field), Value(Field),
} }
impl CalcValue { impl CalcValue {
fn get(&self) -> Field { fn get(&self, existing: Field) -> Field {
match self { match self {
Self::Calculate(calc) => calc.calculate(existing),
Self::Existing(_) => existing,
Self::FType(ftype) => ftype.get_default(), Self::FType(ftype) => ftype.get_default(),
Self::Value(field) => field.clone(), Self::Value(field) => field.clone(),
Self::Calculate(calc) => calc.calculate(),
} }
} }
} }
@ -2543,7 +2545,7 @@ mod calcvalues {
CalcValue::Value(data) => assert_eq!(data, expected), CalcValue::Value(data) => assert_eq!(data, expected),
_ => unreachable!("got {:?}, should have gotten a field", result), _ => unreachable!("got {:?}, should have gotten a field", result),
} }
assert_eq!(result.get(), expected); assert_eq!(result.get(Field::None), expected);
} }
#[test] #[test]
@ -2555,7 +2557,7 @@ mod calcvalues {
CalcValue::Value(data) => assert_eq!(data, expected), CalcValue::Value(data) => assert_eq!(data, expected),
_ => unreachable!("got {:?}, should have gotten a field", result), _ => unreachable!("got {:?}, should have gotten a field", result),
} }
assert_eq!(result.get(), expected); assert_eq!(result.get(Field::None), expected);
} }
#[test] #[test]
@ -2567,7 +2569,7 @@ mod calcvalues {
CalcValue::Value(data) => assert_eq!(data, expected), CalcValue::Value(data) => assert_eq!(data, expected),
_ => unreachable!("got {:?}, should have gotten a field", result), _ => unreachable!("got {:?}, should have gotten a field", result),
} }
assert_eq!(result.get(), expected); assert_eq!(result.get(Field::None), expected);
} }
#[test] #[test]
@ -2579,7 +2581,7 @@ mod calcvalues {
CalcValue::Value(data) => assert_eq!(data, expected), CalcValue::Value(data) => assert_eq!(data, expected),
_ => unreachable!("got {:?}, should have gotten a field", result), _ => unreachable!("got {:?}, should have gotten a field", result),
} }
assert_eq!(result.get(), expected); assert_eq!(result.get(Field::None), expected);
} }
#[test] #[test]
@ -2591,7 +2593,7 @@ mod calcvalues {
CalcValue::Value(data) => assert_eq!(data, expected), CalcValue::Value(data) => assert_eq!(data, expected),
_ => unreachable!("got {:?}, should have gotten a field", result), _ => unreachable!("got {:?}, should have gotten a field", result),
} }
assert_eq!(result.get(), expected); assert_eq!(result.get(Field::None), expected);
} }
#[test] #[test]
@ -2603,7 +2605,7 @@ mod calcvalues {
CalcValue::Value(data) => assert_eq!(data, expected), CalcValue::Value(data) => assert_eq!(data, expected),
_ => unreachable!("got {:?}, should have gotten a field", result), _ => unreachable!("got {:?}, should have gotten a field", result),
} }
assert_eq!(result.get(), expected); assert_eq!(result.get(Field::None), expected);
} }
#[test] #[test]
@ -2615,7 +2617,7 @@ mod calcvalues {
CalcValue::Value(data) => assert_eq!(data, expected), CalcValue::Value(data) => assert_eq!(data, expected),
_ => unreachable!("got {:?}, should have gotten a field", result), _ => unreachable!("got {:?}, should have gotten a field", result),
} }
assert_eq!(result.get(), expected); assert_eq!(result.get(Field::None), expected);
} }
#[test] #[test]
@ -2626,7 +2628,7 @@ mod calcvalues {
calc.add_value(FieldType::DateTime); calc.add_value(FieldType::DateTime);
calc.add_value(duration.clone()); calc.add_value(duration.clone());
let result: CalcValue = calc.into(); let result: CalcValue = calc.into();
let data = match result.get() { let data = match result.get(Field::None) {
Field::DateTime(data) => data, Field::DateTime(data) => data,
_ => unreachable!(), _ => unreachable!(),
}; };
@ -2656,10 +2658,10 @@ impl Calculation {
&self.operation &self.operation
} }
fn get_fields(&self) -> Vec<Field> { fn get_fields(&self, existing: Field) -> Vec<Field> {
let mut output = Vec::new(); let mut output = Vec::new();
for item in self.values.iter() { for item in self.values.iter() {
output.push(item.get()); output.push(item.get(existing.clone()));
} }
output output
} }
@ -2678,39 +2680,45 @@ impl Calculation {
Ok(()) Ok(())
} }
fn get_type(calc_value: CalcValue) -> FieldType {
match calc_value {
CalcValue::Existing(field_type) => field_type,
_ => calc_value.get(Field::None).get_type(),
}
}
fn add_value<CV>(&mut self, data: CV) -> Result<(), MTTError> fn add_value<CV>(&mut self, data: CV) -> Result<(), MTTError>
where where
CV: Into<CalcValue>, CV: Into<CalcValue>,
{ {
let holder: CalcValue = data.into(); let holder: CalcValue = data.into();
if self.values.len() == 0 { if self.values.is_empty() {
self.values.push(holder); self.values.push(holder);
Ok(()) return Ok(());
} else { }
let mut base = self.values[0].get().get_type(); let ftype = Self::get_type(holder.clone());
let ftype = holder.get().get_type(); let mut base = Self::get_type(self.values[0].clone());
match self.operation { match self.operation {
Operand::Add => { Operand::Add => {
if base == FieldType::DateTime { if base == FieldType::DateTime {
base = FieldType::Duration; base = FieldType::Duration;
}
match self.push_value(base, ftype, holder) {
Ok(_) => Ok(()),
Err(err) => Err(err),
}
} }
_ => match self.push_value(base, ftype, holder) { match self.push_value(base, ftype, holder) {
Ok(_) => Ok(()), Ok(_) => Ok(()),
Err(err) => Err(err), Err(err) => Err(err),
}, }
} }
_ => match self.push_value(base, ftype, holder) {
Ok(_) => Ok(()),
Err(err) => Err(err),
},
} }
} }
fn calculate(&self) -> Field { fn calculate(&self, existing: Field) -> Field {
match self.operation { match self.operation {
Operand::Add => { Operand::Add => {
let values = self.get_fields(); let values = self.get_fields(existing);
match values[0].get_type() { match values[0].get_type() {
FieldType::DateTime => { FieldType::DateTime => {
let mut output = Utc::now(); let mut output = Utc::now();
@ -2736,8 +2744,10 @@ impl Calculation {
_ => unreachable!("{:?} does not handle addition", values[0].get_type()), _ => unreachable!("{:?} does not handle addition", values[0].get_type()),
} }
} }
Operand::Assign => self.values[0].get(), Operand::Assign => self.values[0].get(Field::None),
Operand::Equal => { self.values[0].get() == self.values[1].get() }.into(), Operand::Equal => {
{ self.values[0].get(Field::None) == self.values[1].get(Field::None) }.into()
}
} }
} }
} }
@ -2782,7 +2792,7 @@ mod calculations {
let mut calc = Calculation::new(Operand::Assign); let mut calc = Calculation::new(Operand::Assign);
let data: Field = Uuid::new_v4().into(); let data: Field = Uuid::new_v4().into();
calc.add_value(data.clone()); calc.add_value(data.clone());
let result = calc.calculate(); let result = calc.calculate(Field::None);
assert_eq!(result, data); assert_eq!(result, data);
} }
@ -2790,8 +2800,8 @@ mod calculations {
fn can_assign_default_function() { fn can_assign_default_function() {
let mut calc = Calculation::new(Operand::Assign); let mut calc = Calculation::new(Operand::Assign);
calc.add_value(FieldType::Uuid); calc.add_value(FieldType::Uuid);
let result1 = calc.calculate(); let result1 = calc.calculate(Field::None);
let result2 = calc.calculate(); let result2 = calc.calculate(Field::None);
assert_ne!(result1, result2); assert_ne!(result1, result2);
} }
@ -2802,7 +2812,7 @@ mod calculations {
calc.add_value(data.clone()); calc.add_value(data.clone());
calc.add_value(data.clone()); calc.add_value(data.clone());
let expected: Field = true.into(); let expected: Field = true.into();
let result = calc.calculate(); let result = calc.calculate(Field::None);
assert_eq!(result, expected); assert_eq!(result, expected);
} }
@ -2814,7 +2824,7 @@ mod calculations {
calc.add_value(value1); calc.add_value(value1);
calc.add_value(value2); calc.add_value(value2);
let expected: Field = false.into(); let expected: Field = false.into();
let result = calc.calculate(); let result = calc.calculate(Field::None);
assert_eq!(result, expected); assert_eq!(result, expected);
} }
@ -2826,10 +2836,32 @@ mod calculations {
let expected: Field = { value1 + value2 }.into(); let expected: Field = { value1 + value2 }.into();
let value1: Field = value1.into(); let value1: Field = value1.into();
let value2: Field = value2.into(); let value2: Field = value2.into();
calc.add_value(value1); calc.add_value(value1.clone());
calc.add_value(value2); calc.add_value(value2.clone());
let result = calc.calculate(); let result = calc.calculate(Field::None);
assert_eq!(result, expected); assert_eq!(
result, expected,
"{:?} plus {:?} should equal {:?}",
value1, value2, expected
);
}
#[test]
fn can_use_existing_values() {
let mut calc = Calculation::new(Operand::Add);
let value1: i128 = random::<u8>().into();
let value2: i128 = random::<u8>().into();
let expected: Field = { value1 + value2 }.into();
let value1: Field = value1.into();
let value2: Field = value2.into();
calc.add_value(value1.clone());
calc.add_value(CalcValue::Existing(FieldType::Integer));
let result = calc.calculate(value2.clone());
assert_eq!(
result, expected,
"{:?} plus {:?} should equal {:?}",
value1, value2, expected
);
} }
#[test] #[test]
@ -2858,7 +2890,7 @@ mod calculations {
Ok(_) => {} Ok(_) => {}
Err(err) => unreachable!("got {:?}, should have returned normally", err), Err(err) => unreachable!("got {:?}, should have returned normally", err),
} }
let result = calc.calculate(); let result = calc.calculate(Field::None);
let stop = Utc::now() + duration; let stop = Utc::now() + duration;
match result { match result {
Field::DateTime(data) => { Field::DateTime(data) => {
@ -2964,7 +2996,7 @@ mod queries {
let expected: Field = true.into(); let expected: Field = true.into();
let mut holder = op.clone(); let mut holder = op.clone();
holder.add_value(data); holder.add_value(data);
assert_eq!(holder.calculate(), expected); assert_eq!(holder.calculate(Field::None), expected);
} }
None => unreachable!("should have returned a calculation"), None => unreachable!("should have returned a calculation"),
} }
@ -2973,7 +3005,7 @@ mod queries {
let expected: Field = false.into(); let expected: Field = false.into();
let mut holder = op.clone(); let mut holder = op.clone();
holder.add_value(bad_data); holder.add_value(bad_data);
assert_eq!(holder.calculate(), expected); assert_eq!(holder.calculate(Field::None), expected);
} }
None => unreachable!("should have returned a calculation"), None => unreachable!("should have returned a calculation"),
} }
@ -3392,7 +3424,7 @@ impl Document {
NT: Into<NameType>, NT: Into<NameType>,
{ {
match self.data.get(&name.into()) { match self.data.get(&name.into()) {
Some(data) => Some(data.get()), Some(data) => Some(data.get(Field::None)),
None => None, None => None,
} }
} }
@ -3400,7 +3432,7 @@ impl Document {
fn get_all(&self) -> Vec<(NameType, Field)> { fn get_all(&self) -> Vec<(NameType, Field)> {
let mut output = Vec::new(); let mut output = Vec::new();
for (key, value) in self.data.iter() { for (key, value) in self.data.iter() {
output.push((key.clone(), value.get())); output.push((key.clone(), value.get(Field::None)));
} }
output output
} }
@ -3612,7 +3644,7 @@ impl Index {
Ok(_) => {} Ok(_) => {}
Err(err) => return Err(err), Err(err) => return Err(err),
} }
if op.calculate() == true.into() { if op.calculate(Field::None) == true.into() {
output = output.union(&value).cloned().collect(); output = output.union(&value).cloned().collect();
} }
} }
@ -4070,7 +4102,7 @@ impl DocumentFile {
Ok(_) => {} Ok(_) => {}
Err(err) => return Err(err), Err(err) => return Err(err),
} }
if calc.calculate() == false.into() { if calc.calculate(Field::None) == false.into() {
oids.remove(oid); oids.remove(oid);
} }
} }