Moved update into action module.

src/action.rs

@@ -7,6 +7,7 @@ mod query;
 mod reply;
 mod request_data;
 mod show;
+mod update;
 mod user;
 
 pub use crate::document::{DocDef, Field, FieldType, Records};
@@ -19,4 +20,5 @@ pub use query::Query;
 pub use reply::Reply;
 use request_data::RequestData;
 pub use show::Show;
+pub use update::Update;
 pub use user::UserAction;

src/action/delete.rs

@@ -1,8 +1,5 @@
-use crate::{
-    name::NameType,
-    message::MessageAction,
-};
 use super::Query;
+use crate::{message::MessageAction, name::NameType};
 
 #[derive(Clone, Debug)]
 pub struct Delete {
@@ -11,7 +8,10 @@ pub struct Delete {
 }
 
 impl Delete {
-    pub fn new<NT>(name: NT) -> Self where NT: Into<NameType> {
+    pub fn new<NT>(name: NT) -> Self
+    where
+        NT: Into<NameType>,
+    {
         Self {
             doc_name: name.into(),
             query: Query::internal(),
@@ -35,11 +35,11 @@ impl MessageAction for Delete {
 
 #[cfg(test)]
 mod deletes {
+    use super::*;
     use crate::{
         action::{Calculation, Operand},
-        name::test_support::random_name
+        name::test_support::random_name,
     };
-    use super::*;
 
     #[test]
     fn can_create_delete_request() {

src/action/message.rs

@@ -1,12 +1,6 @@
-use super::{Addition, Delete, DocDef, Query, Records, Reply, Show, UserAction};
+use super::{Addition, Delete, DocDef, Query, Records, Reply, Show, Update, UserAction};
 use crate::{
-    message::{
-        wrapper::Update,
-        MessageAction,
-    },
-    mtterror::MTTError,
-    name::NameType,
-    queue::data_director::Register,
+    message::MessageAction, mtterror::MTTError, name::NameType, queue::data_director::Register,
 };
 
 #[derive(Clone, Debug)]
@@ -43,7 +37,7 @@ impl MessageAction for MsgAction {
             Self::Register(data) => data.doc_name(),
             Self::Reply(data) => data.doc_name(),
             Self::Show(data) => data.doc_name(),
-            _ => &NameType::None,
+            Self::Update(data) => data.doc_name(),
         }
     }
 }

src/action/update.rs

@@ -0,0 +1,87 @@
+use super::{Query, RequestData};
+use crate::{message::MessageAction, name::NameType};
+
+#[derive(Clone, Debug)]
+pub struct Update {
+    doc_name: NameType,
+    query: Query,
+    values: RequestData,
+}
+
+impl Update {
+    pub fn new<NT>(name: NT) -> Self
+    where
+        NT: Into<NameType>,
+    {
+        Self {
+            doc_name: name.into(),
+            query: Query::internal(),
+            values: RequestData::new(),
+        }
+    }
+
+    pub fn get_query(&self) -> &Query {
+        &self.query
+    }
+
+    pub fn get_query_mut(&mut self) -> &mut Query {
+        &mut self.query
+    }
+
+    pub fn get_values(&self) -> &RequestData {
+        &self.values
+    }
+
+    pub fn get_values_mut(&mut self) -> &mut RequestData {
+        &mut self.values
+    }
+}
+
+impl MessageAction for Update {
+    fn doc_name(&self) -> &NameType {
+        &self.doc_name
+    }
+}
+
+#[cfg(test)]
+mod updates {
+    use super::*;
+    use crate::{
+        action::{Calculation, Operand},
+        name::test_support::random_name,
+    };
+
+    #[test]
+    fn is_default_update_empty() {
+        let name = random_name();
+        let expected: NameType = name.clone().into();
+        let update = Update::new(name);
+        assert_eq!(update.doc_name(), &expected);
+        assert_eq!(update.get_query().iter().count(), 0);
+        assert_eq!(update.get_values().iter().count(), 0);
+    }
+
+    #[test]
+    fn can_update_query_be_altered() {
+        let name = random_name();
+        let expected: NameType = name.clone().into();
+        let mut update = Update::new(name);
+        let query = update.get_query_mut();
+        let mut calc = Calculation::new(Operand::Equal);
+        calc.add_value("something").unwrap();
+        query.add(random_name(), calc);
+        assert_eq!(update.doc_name(), &expected);
+        assert_eq!(update.get_query().iter().count(), 1);
+    }
+
+    #[test]
+    fn can_update_data_be_altered() {
+        let name = random_name();
+        let expected: NameType = name.clone().into();
+        let mut update = Update::new(name);
+        let values = update.get_values_mut();
+        values.add_field(random_name(), "something");
+        assert_eq!(update.doc_name(), &expected);
+        assert_eq!(update.get_values().iter().count(), 1);
+    }
+}

src/document/create.rs

@@ -1,11 +1,11 @@
 use super::{InternalRecord, InternalRecords, Oid};
 use crate::{
-    action::{Action, CalcValue, Calculation, MsgAction, Query, Records, Reply},
+    action::{Action, CalcValue, Calculation, MsgAction, Query, Records, Reply, Update},
     document::{
         definition::{DocDef, DocFuncType},
         field::Field,
     },
-    message::wrapper::{Message, Update},
+    message::wrapper::Message,
     mtterror::{ErrorID, MTTError},
     name::NameType,
     queue::{
@@ -1005,7 +1005,7 @@ mod document_files {
             MsgAction::Delete(Delete::new(name.clone())),
             MsgAction::Query(Query::new(name.clone())),
             MsgAction::Show(Show::new(name.clone())),
-            MsgAction::Update(Update::new(Query::internal())),
+            MsgAction::Update(Update::new(name.clone())),
         ];
         for msg_action in msg_actions.iter() {
             let msg = Message::new(name.clone(), msg_action.clone());
@@ -1057,7 +1057,7 @@ mod document_files {
             MsgAction::Delete(Delete::new(name.clone())),
             MsgAction::Query(Query::internal().into()),
             MsgAction::Show(Show::new(name.clone())),
-            MsgAction::Update(Update::new(Query::internal())),
+            MsgAction::Update(Update::new(name.clone())),
         ];
         let mut msgs: HashMap<Uuid, MsgAction> = HashMap::new();
         for msg_action in msg_actions.iter() {
@@ -1224,7 +1224,7 @@ mod document_files {
         for item in data.iter() {
             test_doc.populate([item.clone()].to_vec());
         }
-        let mut update = Update::new(Query::internal());
+        let mut update = Update::new(doc_name.clone());
         update
             .get_values_mut()
             .add_field(field_name.clone(), Uuid::nil());
@@ -1813,9 +1813,9 @@ mod document_files {
         calc.add_value(CalcValue::Existing(FieldType::Uuid))
             .unwrap();
         calc.add_value(Uuid::nil()).unwrap();
-        let mut query = Query::internal();
+        let mut update = Update::new(doc.doc_name());
+        let query = update.get_query_mut();
         query.add(Name::english("field0"), calc);
-        let mut update = Update::new(query);
         update
             .get_values_mut()
             .add_field(Name::english("field0"), Uuid::nil());
@@ -1841,9 +1841,9 @@ mod document_files {
         calc.add_value(CalcValue::Existing(FieldType::Uuid))
             .unwrap();
         calc.add_value(id.clone()).unwrap();
-        let mut query = Query::internal();
+        let mut update = Update::new(doc_name.clone());
+        let query = update.get_query_mut();
         query.add(Name::english("field0"), calc);
-        let mut update = Update::new(query);
         update
             .get_values_mut()
             .add_field(Name::english("field1"), new);
@@ -1884,9 +1884,9 @@ mod document_files {
         calc.add_value(CalcValue::Existing(FieldType::Integer))
             .unwrap();
         calc.add_value(picked.clone()).unwrap();
-        let mut query = Query::internal();
+        let mut update = Update::new(doc_name.clone());
+        let query = update.get_query_mut();
         query.add(Name::english("field0"), calc);
-        let mut update = Update::new(query);
         update
             .get_values_mut()
             .add_field(Name::english("field1"), new);
@@ -1948,9 +1948,9 @@ mod document_files {
         calc.add_value(CalcValue::Existing(FieldType::Integer))
             .unwrap();
         calc.add_value(picked.clone()).unwrap();
-        let mut query = Query::internal();
+        let mut update = Update::new(doc_name.clone());
+        let query = update.get_query_mut();
         query.add(Name::english("field0"), calc);
-        let mut update = Update::new(query);
         update
             .get_values_mut()
             .add_field(Name::english("field1"), new);
@@ -1982,7 +1982,7 @@ mod document_files {
         let new = "new";
         let bad_name = Name::english("wrong");
         doc.populate([id.into(), old.into()].to_vec());
-        let mut update = Update::new(Query::internal());
+        let mut update = Update::new(doc.doc_name());
         update.get_values_mut().add_field(bad_name.clone(), new);
         doc.send(update);
         let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
@@ -2009,9 +2009,9 @@ mod document_files {
         calc.add_value(CalcValue::Existing(FieldType::Uuid))
             .unwrap();
         calc.add_value(id.clone()).unwrap();
-        let mut query = Query::internal();
+        let mut update = Update::new(doc.doc_name());
+        let query = update.get_query_mut();
         query.add(Name::english("field0"), calc);
-        let mut update = Update::new(query);
         update
             .get_values_mut()
             .add_field(Name::english("field1"), new);
@@ -2044,9 +2044,9 @@ mod document_files {
         calc.add_value(CalcValue::Existing(FieldType::Integer))
             .unwrap();
         calc.add_value(old.clone()).unwrap();
-        let mut query = Query::internal();
+        let mut update = Update::new(test_doc.doc_name());
+        let query = update.get_query_mut();
         query.add(Name::english("field0"), calc);
-        let mut update = Update::new(query);
         update.get_values_mut().add_field(&fname, new);
         test_doc.send(update);
         test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
@@ -2131,9 +2131,9 @@ mod document_files {
         calc.add_value(CalcValue::Existing(FieldType::StaticString))
             .unwrap();
         calc.add_value(old).unwrap();
-        let mut query = Query::internal();
+        let mut update = Update::new(doc.doc_name());
+        let query = update.get_query_mut();
         query.add(Name::english("field0"), calc);
-        let mut update = Update::new(query);
         update.get_values_mut().add_field(fname.clone(), new);
         doc.send(update);
         doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
@@ -2190,9 +2190,9 @@ mod document_files {
         calc.add_value(CalcValue::Existing(FieldType::StaticString))
             .unwrap();
         calc.add_value(data).unwrap();
-        let mut query = Query::internal();
+        let mut update = Update::new(doc.doc_name());
+        let query = update.get_query_mut();
         query.add(&f1name, calc);
-        let mut update = Update::new(query);
         update.get_values_mut().add_field(&f0name, holder.clone());
         doc.send(update);
         let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
@@ -2351,7 +2351,7 @@ mod document_files {
             Include::Just(doc_name.clone().into()),
             Include::Just(Action::OnQuery),
         );
-        let mut update = Update::new(Query::internal());
+        let mut update = Update::new(doc_name.clone());
         let mut calc = Calculation::new(Operand::Add);
         calc.add_value(CalcValue::Existing(FieldType::Integer))
             .unwrap();

src/document/definition.rs

@@ -377,7 +377,7 @@ impl MessageAction for DocDef {}
 #[cfg(test)]
 mod docdefs {
     use super::*;
-    use crate::{action::Query, message::wrapper::Update};
+    use crate::action::{Query, Update};
 
     #[test]
     fn message_doc_name_returns_none() {
@@ -548,7 +548,7 @@ mod docdefs {
                 Include::Just(docname.clone().into()),
                 Include::Just(Action::OnQuery),
             ),
-            DocFuncType::Trigger(Update::new(Query::new(docname.clone())).into()),
+            DocFuncType::Trigger(Update::new(docname.clone()).into()),
         );
         let path_action = docdef.iter_routes().last().unwrap();
         let path = path_action.path();

src/document/session.rs

@@ -1,11 +1,11 @@
 use crate::{
-    action::{Action, CalcValue, Calculation, Delete, FieldType, Operand, Query},
+    action::{Action, CalcValue, Calculation, Delete, FieldType, Operand, Query, Update},
     document::{
         clock::Clock,
         create::IndexType,
         definition::{DocDef, DocFuncType},
     },
-    message::wrapper::{Message, Update},
+    message::wrapper::Message,
     name::{Name, NameType},
     queue::{
         data_director::{Include, Path, RegMsg, Register},
@@ -40,7 +40,7 @@ impl Session {
         docdef.set_default(&name_expire, calc.clone()).unwrap();
         docdef.add_index(&name_expire, IndexType::Index).unwrap();
 
-        let mut update = Update::new(Query::internal());
+        let mut update = Update::new(Session::doc_names()[0].clone());
         update
             .get_values_mut()
             .add_field(name_expire.clone(), calc.clone());

src/message/wrapper.rs

@@ -347,31 +347,3 @@ mod documents {
         }
     }
 }
-
-
-#[derive(Clone, Debug)]
-pub struct Update {
-    query: Query,
-    values: Document,
-}
-
-impl Update {
-    pub fn new(query: Query) -> Self {
-        Self {
-            query: query.into(),
-            values: Document::new(),
-        }
-    }
-
-    pub fn get_query(&self) -> &Query {
-        &self.query
-    }
-
-    pub fn get_values(&self) -> &Document {
-        &self.values
-    }
-
-    pub fn get_values_mut(&mut self) -> &mut Document {
-        &mut self.values
-    }
-}