Built new error module to hold document name.

src/action/addition.rs

@@ -33,8 +33,8 @@ impl Addition {
 }
 
 impl MessageAction for Addition {
-    fn doc_name(&self) -> NameType {
-        self.doc_name.clone()
+    fn doc_name(&self) -> &NameType {
+        &self.doc_name
     }
 }
 
@@ -46,8 +46,9 @@ mod additions {
     #[test]
     fn is_default_addition_empty() {
         let doc_name = Name::english(Uuid::new_v4().to_string().as_str());
+        let expected_name: NameType = doc_name.clone().into();
         let add = Addition::new(doc_name.clone());
-        assert_eq!(add.doc_name(), doc_name.into());
+        assert_eq!(add.doc_name(), &expected_name);
         assert_eq!(add.iter().count(), 0);
     }
 

src/action/message.rs

@@ -28,12 +28,12 @@ pub enum MsgAction {
 }
 
 impl MessageAction for MsgAction {
-    fn doc_name(&self) -> NameType {
+    fn doc_name(&self) -> &NameType {
         match self {
             Self::Addition(data) => data.doc_name(),
             Self::Query(data) => data.doc_name(),
             Self::Create(data) => data.doc_name(),
-            _ => NameType::None,
+            _ => &NameType::None,
         }
     }
 }
@@ -144,10 +144,11 @@ mod msgactions {
     #[test]
     fn turn_query_into_action() {
         let name = Name::english(Uuid::new_v4().to_string().as_str());
+        let expected_name: NameType = name.clone().into();
         let value = Query::new(name.clone());
         let result: MsgAction = value.into();
         match result {
-            MsgAction::Query(data) => assert_eq!(data.doc_name(), name.into()),
+            MsgAction::Query(data) => assert_eq!(data.doc_name(), &expected_name),
             _ => unreachable!("Got {:?}: dhould have been query", result),
         }
     }

src/action/query.rs

@@ -52,8 +52,8 @@ impl Query {
 }
 
 impl MessageAction for Query {
-    fn doc_name(&self) -> NameType {
-        self.doc_name.clone()
+    fn doc_name(&self) -> &NameType {
+        &self.doc_name
     }
 }
 
@@ -69,14 +69,13 @@ mod queries {
     #[test]
     fn is_default_query_empty() {
         let name = Name::english(Uuid::new_v4().to_string().as_str());
+        let expected_name: NameType = name.clone().into();
         let qry = Query::new(name.clone());
         let result = qry.doc_name();
         assert_eq!(
-            result,
-            name.clone().into(),
+            result, &expected_name,
             "got {:?} should be {:?}",
-            result,
-            name
+            result, name
         );
         assert_eq!(qry.iter().count(), 0, "query should be empty");
     }
@@ -85,7 +84,7 @@ mod queries {
     fn does_internal_queries_return_none() {
         let qry = Query::internal();
         let result = qry.doc_name();
-        assert_eq!(result, NameType::None, "got {:?} should be none", result);
+        assert_eq!(result, &NameType::None, "got {:?} should be none", result);
         assert_eq!(qry.iter().count(), 0, "query should be empty");
     }
 

src/document/definition.rs

@@ -201,6 +201,7 @@ impl PathAction {
 
 #[derive(Clone, Debug)]
 pub struct DocDef {
+    doc_name: NameType,
     doc_names: Vec<Name>,
     field_names: Names,
     fields: HashMap<Uuid, FieldSetting>,
@@ -258,6 +259,7 @@ impl DocDef {
             ),
         ];
         Self {
+            doc_name: NameType::None,
             doc_names: names,
             field_names: Names::new(),
             fields: HashMap::new(),
@@ -375,8 +377,8 @@ impl DocDef {
 }
 
 impl MessageAction for DocDef {
-    fn doc_name(&self) -> NameType {
-        NameType::None
+    fn doc_name(&self) -> &NameType {
+        &self.doc_name
     }
 }
 
@@ -389,7 +391,7 @@ mod docdefs {
     fn message_doc_name_returns_none() {
         let docname = Name::english("tester");
         let mut docdef = DocDef::new(docname);
-        assert_eq!(docdef.doc_name(), NameType::None);
+        assert_eq!(docdef.doc_name(), &NameType::None);
     }
 
     #[test]

src/message.rs

@@ -3,5 +3,5 @@ pub mod wrapper;
 use crate::name::NameType;
 
 pub trait MessageAction {
-    fn doc_name(&self) -> NameType;
+    fn doc_name(&self) -> &NameType;
 }

src/mtterror.rs

@@ -1,8 +1,10 @@
 use crate::{
     document::field::{Field, FieldType},
-    name::Name,
+    message::MessageAction,
+    name::{Name, NameType},
 };
 use isolang::Language;
+use std::{error::Error, fmt};
 use uuid::Uuid;
 
 #[derive(Clone, Debug)]
@@ -28,3 +30,87 @@ pub enum MTTError {
     QueryCannotChangeData,
     RouteRequiresDocumentID,
 }
+
+#[derive(Clone, Debug)]
+pub enum ErrorID {
+    InvalidDocumentName,
+    InvalidFieldName(Name),
+}
+
+#[derive(Clone, Debug)]
+struct MTTError2 {
+    doc_name: NameType,
+    error_id: ErrorID,
+}
+
+impl MTTError2 {
+    pub fn new<NT>(doc_name: NT, error: ErrorID) -> MTTError2
+    where
+        NT: Into<NameType>,
+    {
+        Self {
+            doc_name: doc_name.into(),
+            error_id: error,
+        }
+    }
+
+    pub fn error_id(&self) -> &ErrorID {
+        &self.error_id
+    }
+}
+
+impl fmt::Display for MTTError2 {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?} error: {:?}", self.doc_name, self.error_id)
+    }
+}
+
+impl Error for MTTError2 {}
+
+impl MessageAction for MTTError2 {
+    fn doc_name(&self) -> &NameType {
+        &self.doc_name
+    }
+}
+
+#[cfg(test)]
+mod errors {
+    use super::*;
+
+    #[test]
+    fn can_create_error() {
+        let doc_name = Name::english(Uuid::new_v4().to_string().as_str());
+        let expected_name: NameType = doc_name.clone().into();
+        let error = ErrorID::InvalidDocumentName;
+        let err = MTTError2::new(doc_name.clone(), error.clone());
+        assert_eq!(err.doc_name(), &expected_name);
+        let err_id = err.error_id();
+        match err_id {
+            ErrorID::InvalidDocumentName => {}
+            _ => unreachable!("got {:?}, should have been invalid document name", err_id),
+        }
+        assert_eq!(
+            err.to_string(),
+            format!("{:?} error: {:?}", NameType::Name(doc_name), error)
+        );
+    }
+
+    #[test]
+    fn does_error_ids_contain_data() {
+        let doc_name = Name::english(Uuid::new_v4().to_string().as_str());
+        let expected_name: NameType = doc_name.clone().into();
+        let field_name = Name::english(Uuid::new_v4().to_string().as_str());
+        let error = ErrorID::InvalidFieldName(field_name.clone());
+        let err = MTTError2::new(doc_name.clone(), error.clone());
+        assert_eq!(err.doc_name(), &expected_name);
+        let err_id = err.error_id();
+        match err_id {
+            ErrorID::InvalidFieldName(data) => assert_eq!(data, &field_name),
+            _ => unreachable!("got {:?}, should have been invalid field name", err_id),
+        }
+        assert_eq!(
+            err.to_string(),
+            format!("{:?} error: {:?}", NameType::Name(doc_name), error)
+        );
+    }
+}

src/name.rs

@@ -1,6 +1,6 @@
 use crate::mtterror::MTTError;
 use isolang::Language;
-use std::collections::HashMap;
+use std::{collections::HashMap, fmt};
 use uuid::Uuid;
 
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
@@ -69,9 +69,9 @@ impl Name {
     }
 }
 
-impl ToString for Name {
-    fn to_string(&self) -> String {
-        self.name.clone()
+impl fmt::Display for Name {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.name)
     }
 }