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

Got fields working with default values.
Some checks failed
Gitea Actions Demo / Explore-Gitea-Actions (push) Failing after 3m46s
Details

Browse Source
This commit is contained in:
Jeff Baskin 2025-09-02 16:44:29 -04:00
parent ad3ad3295f
commit 65b052eba6
1 changed files with 90 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

187
src/message.rs
View File

@ -948,6 +948,7 @@ impl CreateDoc {
#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
enum FieldType { enum FieldType {
None,
StaticString, StaticString,
Uuid, Uuid,
} }
@ -955,6 +956,7 @@ enum FieldType {
impl FieldType { impl FieldType {
fn get_default(&self) -> Field { fn get_default(&self) -> Field {
match self { match self {
FieldType::None => Field::None,
FieldType::StaticString => "".into(), FieldType::StaticString => "".into(),
FieldType::Uuid => Uuid::new_v4().into(), FieldType::Uuid => Uuid::new_v4().into(),
} }
@ -964,6 +966,7 @@ impl FieldType {
impl From<&Field> for FieldType { impl From<&Field> for FieldType {
fn from(value: &Field) -> Self { fn from(value: &Field) -> Self {
match value { match value {
Field::None => Self::None,
Field::StaticString(_) => Self::StaticString, Field::StaticString(_) => Self::StaticString,
Field::Uuid(_) => Self::Uuid, Field::Uuid(_) => Self::Uuid,
} }
@ -1008,6 +1011,7 @@ mod fieldtypes {
#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
enum Field { enum Field {
None,
StaticString(String), StaticString(String),
Uuid(Uuid), Uuid(Uuid),
} }
@ -1076,37 +1080,35 @@ mod fields {
} }
} }
#[derive(Clone, Debug)]
enum DefaultSetting {
Value(Field),
FieldType,
None,
}
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
struct FieldSetting { struct FieldSetting {
fieldtype: FieldType, fieldtype: FieldType,
default_setting: DefaultSetting, use_default: bool,
default_value: Field,
} }
impl FieldSetting { impl FieldSetting {
fn new(ftype: FieldType) -> Self { fn new(ftype: FieldType) -> Self {
Self { Self {
fieldtype: ftype, fieldtype: ftype,
default_setting: DefaultSetting::None, use_default: false,
default_value: Field::None,
} }
} }
fn get_type(&self) -> &FieldType { fn set_default(&mut self, value: Option<Field>) -> Result<(), MTTError> {
&self.fieldtype match value {
Some(data) => {
match self.check(Some(data.clone())) {
Ok(_) => {}
Err(err) => return Err(err),
} }
self.default_value = data.clone();
fn set_default(&mut self, value: DefaultSetting) {
self.default_setting = value;
} }
None => self.default_value = Field::None,
fn get_default(&self) -> &DefaultSetting { }
&self.default_setting self.use_default = true;
Ok(())
} }
fn check(&self, value: Option<Field>) -> Result<Field, MTTError> { fn check(&self, value: Option<Field>) -> Result<Field, MTTError> {
@ -1121,7 +1123,16 @@ impl FieldSetting {
} }
Ok(data.clone()) Ok(data.clone())
} }
None => Err(MTTError::DocumentFieldMissing("".to_string())), None => {
if self.use_default {
match self.default_value {
Field::None => Ok(self.fieldtype.get_default()),
_ => Ok(self.default_value.clone()),
}
} else {
Err(MTTError::DocumentFieldMissing("".to_string()))
}
}
} }
} }
} }
@ -1169,27 +1180,23 @@ mod fieldsettings {
} }
#[test] #[test]
fn can_field_type_be_assigned() { fn returns_value_if_default_is_set() {
let ftypes = [FieldType::StaticString, FieldType::Uuid]; let mut fset = FieldSetting::new(FieldType::StaticString);
for ftype in ftypes.into_iter() { fset.set_default(None);
let fieldinfo = FieldSetting::new(ftype.clone()); match fset.check(None) {
assert_eq!(fieldinfo.get_type(), &ftype); Ok(data) => assert_eq!(data, "".into()),
let dset = fieldinfo.get_default(); Err(err) => unreachable!("got {:?}: should have gotten a value", err),
match dset {
DefaultSetting::None => {}
_ => unreachable!("got {:?}: should have been none", dset),
}
} }
} }
#[test] #[test]
fn can_default_be_changed() { fn returns_default_value() {
let mut fieldinfo = FieldSetting::new(FieldType::Uuid); let mut fset = FieldSetting::new(FieldType::StaticString);
fieldinfo.set_default(DefaultSetting::FieldType); let input = "fred";
let dset = fieldinfo.get_default(); fset.set_default(Some(input.into()));
match dset { match fset.check(None) {
DefaultSetting::FieldType => {} Ok(data) => assert_eq!(data, input.into()),
_ => unreachable!("got {:?}: should have been none", dset), Err(err) => unreachable!("got {:?}: should have gotten a value", err),
} }
} }
} }
@ -1294,32 +1301,14 @@ impl DocDef {
} }
} }
fn use_default_function(&mut self, field_name: &str) -> Result<(), MTTError> { fn set_default(&mut self, field_name: &str, value: Option<Field>) -> Result<(), MTTError> {
let setting = match self.get_field_mut(field_name) { let setting = match self.get_field_mut(field_name) {
Ok(data) => data, Ok(data) => data,
Err(err) => return Err(err), Err(err) => return Err(err),
}; };
setting.set_default(DefaultSetting::FieldType); match setting.set_default(value) {
Ok(()) Ok(_) => Ok(()),
} Err(err) => Err(err),
fn set_default_value<F>(&mut self, field_name: &str, value: F) -> Result<(), MTTError>
where
F: Into<Field>,
{
let setting = match self.get_field_mut(field_name) {
Ok(data) => data,
Err(err) => return Err(err),
};
let data = value.into();
if setting.get_type() == &data.get_type() {
setting.set_default(DefaultSetting::Value(data));
Ok(())
} else {
Err(MTTError::DocumentFieldWrongDataType(
setting.get_type().clone(),
data.get_type(),
))
} }
} }
@ -1339,7 +1328,10 @@ 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.as_str()).unwrap(); let result = docdef.get_field(name.as_str()).unwrap();
assert_eq!(result.get_type(), &field_type); match result.check(Some(Uuid::new_v4().into())) {
Ok(_) => {}
Err(err) => unreachable!("got {:?}: should have been a value", err),
}
} }
#[test] #[test]
@ -1365,7 +1357,10 @@ mod docdefs {
} }
for name in names.iter() { for name in names.iter() {
let result = docdef.get_field(name).unwrap(); let result = docdef.get_field(name).unwrap();
assert_eq!(result.get_type(), &field_type); match result.check(Some("".into())) {
Ok(_) => {}
Err(err) => unreachable!("got {:?}: should have been a value", err),
}
} }
} }
@ -1374,11 +1369,13 @@ mod docdefs {
let mut docdef = DocDef::new(); let mut docdef = DocDef::new();
let name = "defaultfunction"; let name = "defaultfunction";
docdef.add_field(name.to_string(), FieldType::StaticString); docdef.add_field(name.to_string(), FieldType::StaticString);
docdef.use_default_function(name); docdef.set_default(name, None);
let dset = docdef.get_field(name).unwrap().get_default(); match docdef.get_field(name).unwrap().check(None) {
match dset { Ok(data) => match data {
DefaultSetting::FieldType => {} Field::StaticString(result) => assert_eq!(result, ""),
_ => unreachable!("got {:?}: should have been field type", dset), _ => unreachable!("got {:?}: should return a static string", data),
},
Err(err) => unreachable!("got {:?}: should return a value", err),
} }
} }
@ -1386,7 +1383,7 @@ mod docdefs {
fn does_set_default_function_error_on_bad_field_name() { fn does_set_default_function_error_on_bad_field_name() {
let mut docdef = DocDef::new(); let mut docdef = DocDef::new();
let field_name = Uuid::new_v4().to_string(); let field_name = Uuid::new_v4().to_string();
match docdef.use_default_function(field_name.as_str()) { match docdef.set_default(field_name.as_str(), None) {
Ok(_) => unreachable!("should be an error"), Ok(_) => unreachable!("should be an error"),
Err(err) => match err { Err(err) => match err {
MTTError::DocumentFieldNotFound(data) => assert_eq!(data, field_name), MTTError::DocumentFieldNotFound(data) => assert_eq!(data, field_name),
@ -1399,7 +1396,7 @@ mod docdefs {
fn does_set_default_value_error_on_bad_field_name() { fn does_set_default_value_error_on_bad_field_name() {
let mut docdef = DocDef::new(); let mut docdef = DocDef::new();
let field_name = Uuid::new_v4().to_string(); let field_name = Uuid::new_v4().to_string();
match docdef.set_default_value(field_name.as_str(), Uuid::nil()) { match docdef.set_default(field_name.as_str(), Some(Uuid::nil().into())) {
Ok(_) => unreachable!("should be an error"), Ok(_) => unreachable!("should be an error"),
Err(err) => match err { Err(err) => match err {
MTTError::DocumentFieldNotFound(data) => assert_eq!(data, field_name), MTTError::DocumentFieldNotFound(data) => assert_eq!(data, field_name),
@ -1413,8 +1410,8 @@ mod docdefs {
let mut docdef = DocDef::new(); let mut docdef = DocDef::new();
let name = "defaultvalue"; let name = "defaultvalue";
docdef.add_field(name.to_string(), FieldType::Uuid); docdef.add_field(name.to_string(), FieldType::Uuid);
match docdef.set_default_value(name, "") { match docdef.set_default(name, Some("".into())) {
Ok(_) => unreachable!("should be an error"), Ok(data) => unreachable!("got {:?}, should be an error", data),
Err(err) => match err { Err(err) => match err {
MTTError::DocumentFieldWrongDataType(expected, got) => { MTTError::DocumentFieldWrongDataType(expected, got) => {
assert_eq!(expected, FieldType::Uuid); assert_eq!(expected, FieldType::Uuid);
@ -1742,30 +1739,26 @@ impl DocumentFile {
let doc = addition.get_document(); let doc = addition.get_document();
for (key, value) in doc.iter() { for (key, value) in doc.iter() {
match self.docdef.get_field(&key) { match self.docdef.get_field(&key) {
Ok(field_info) => match field_info.check(Some(value.clone())) {
Ok(data) => holder.add_field(key.clone(), value.clone()),
Err(err) => return err.into(),
},
Err(err) => return err.into(), Err(err) => return err.into(),
Ok(field_info) => {
if field_info.get_type() == &value.get_type() {
holder.add_field(key.clone(), value.clone());
} else {
return MTTError::DocumentFieldWrongDataType(
value.get_type(),
field_info.get_type().clone(),
)
.into();
}
}
} }
} }
for (key, value) in self.docdef.iter() { for (key, value) in self.docdef.iter() {
match holder.get_field(key) { match holder.get_field(key) {
Some(_) => {} Some(_) => {}
None => match value.get_default() { None => match value.check(None) {
DefaultSetting::Value(data) => holder.add_field(key.clone(), data.clone()), Ok(data) => holder.add_field(key.clone(), data.clone()),
DefaultSetting::FieldType => { Err(err) => {
holder.add_field(key.clone(), value.get_type().get_default()) let error = match err {
MTTError::DocumentFieldMissing(_) => {
MTTError::DocumentFieldMissing(key.clone())
} }
DefaultSetting::None => { _ => err.clone(),
return MTTError::DocumentFieldMissing(key.clone()).into() };
return error.into();
} }
}, },
} }
@ -1784,16 +1777,10 @@ impl DocumentFile {
let mut reply = Reply::new(); let mut reply = Reply::new();
for specifier in query.iter() { for specifier in query.iter() {
match self.docdef.get_field(&specifier.field_name) { match self.docdef.get_field(&specifier.field_name) {
Ok(spec) => { Ok(spec) => match spec.check(Some(specifier.value.clone())) {
let value_type: FieldType = (&specifier.value).into(); Ok(_) => {}
let wanted_type = spec.get_type(); Err(err) => return Err(err),
if &value_type != wanted_type { },
return Err(MTTError::DocumentFieldWrongDataType(
wanted_type.clone(),
value_type.clone(),
));
}
}
Err(err) => return Err(err), Err(err) => return Err(err),
} }
} }
@ -2099,8 +2086,8 @@ mod document_files {
let result = rx.recv_timeout(TIMEOUT).unwrap(); let result = rx.recv_timeout(TIMEOUT).unwrap();
match result.get_action() { match result.get_action() {
MsgAction::Error(err) => match err { MsgAction::Error(err) => match err {
MTTError::DocumentFieldWrongDataType(found, expected) => { MTTError::DocumentFieldWrongDataType(expected, got) => {
assert_eq!(found, &FieldType::StaticString); assert_eq!(got, &FieldType::StaticString);
assert_eq!(expected, &FieldType::Uuid); assert_eq!(expected, &FieldType::Uuid);
} }
_ => unreachable!( _ => unreachable!(
@ -2303,7 +2290,7 @@ mod document_files {
#[test] #[test]
fn can_use_default_values() { fn can_use_default_values() {
let (mut docdef, doc_name) = create_docdef([FieldType::StaticString].to_vec()); let (mut docdef, doc_name) = create_docdef([FieldType::StaticString].to_vec());
docdef.use_default_function("field0"); docdef.set_default("field0", None);
let (queue, rx) = test_doc(doc_name.as_str(), docdef, standard_routes()); let (queue, rx) = test_doc(doc_name.as_str(), docdef, standard_routes());
let new_doc = Addition::new(); let new_doc = Addition::new();
let msg = Message::new(doc_name, new_doc); let msg = Message::new(doc_name, new_doc);
@ -2326,7 +2313,7 @@ mod document_files {
fn can_a_default_value_be_set() { fn can_a_default_value_be_set() {
let (mut docdef, doc_name) = create_docdef([FieldType::Uuid].to_vec()); let (mut docdef, doc_name) = create_docdef([FieldType::Uuid].to_vec());
let input = Uuid::nil(); let input = Uuid::nil();
docdef.set_default_value("field0", input.clone()); docdef.set_default("field0", Some(input.into()));
let (queue, rx) = test_doc(doc_name.as_str(), docdef, standard_routes()); let (queue, rx) = test_doc(doc_name.as_str(), docdef, standard_routes());
let new_doc = Addition::new(); let new_doc = Addition::new();
let msg = Message::new(doc_name, new_doc); let msg = Message::new(doc_name, new_doc);
@ -2348,7 +2335,7 @@ mod document_files {
#[test] #[test]
fn can_default_values_be_overridden() { fn can_default_values_be_overridden() {
let (mut docdef, doc_name) = create_docdef([FieldType::Uuid].to_vec()); let (mut docdef, doc_name) = create_docdef([FieldType::Uuid].to_vec());
docdef.use_default_function("field0"); docdef.set_default("field0", None);
let (queue, rx) = test_doc(doc_name.as_str(), docdef, standard_routes()); let (queue, rx) = test_doc(doc_name.as_str(), docdef, standard_routes());
let mut new_doc = Addition::new(); let mut new_doc = Addition::new();
new_doc.add_field("field0".to_string(), Uuid::nil()); new_doc.add_field("field0".to_string(), Uuid::nil());