From 807b9ad45698da77bcee5d963ee4c38bb207ecf3 Mon Sep 17 00:00:00 2001 From: Jeff Baskin Date: Thu, 26 Mar 2026 13:12:17 -0400 Subject: [PATCH] Removed some dead code. --- src/document/clock.rs | 2 +- src/document/create.rs | 2 +- src/document/session.rs | 2 +- src/lib.rs | 2 +- src/message.rs | 311 ++++++++++++++++++++++++++++++++++++- src/message/wrapper.rs | 139 +---------------- src/queue/data_director.rs | 5 +- src/queue/router.rs | 2 +- 8 files changed, 313 insertions(+), 152 deletions(-) diff --git a/src/document/clock.rs b/src/document/clock.rs index 607c722..a132dd3 100644 --- a/src/document/clock.rs +++ b/src/document/clock.rs @@ -1,6 +1,6 @@ use crate::{ action::{Action, MsgAction, Records}, - message::wrapper::Message, + message::Message, name::{Name, NameType, Names}, queue::{ data_director::{Include, Path, RegMsg, Register}, diff --git a/src/document/create.rs b/src/document/create.rs index 9e9d441..f087fc5 100644 --- a/src/document/create.rs +++ b/src/document/create.rs @@ -6,7 +6,7 @@ use crate::{ definition::{DocDef, DocFuncType}, field::Field, }, - message::{wrapper::Message, MessageAction}, + message::{Message, MessageAction}, mtterror::{ErrorID, MTTError}, name::{NameID, NameType}, queue::{ diff --git a/src/document/session.rs b/src/document/session.rs index b03f350..a67f68c 100644 --- a/src/document/session.rs +++ b/src/document/session.rs @@ -5,7 +5,7 @@ use crate::{ create::IndexType, definition::{DocDef, DocFuncType}, }, - message::{wrapper::Message, MessageID}, + message::{Message, MessageID}, name::{Name, NameType}, queue::{ data_director::{Include, Path, RegMsg, Register}, diff --git a/src/lib.rs b/src/lib.rs index e8b2ca7..d61cc11 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -7,7 +7,7 @@ mod queue; use document::{Clock, CreateDoc, Session}; use isolang::Language; -use message::{wrapper::Message, MessageAction, MessageID}; +use message::{Message, MessageAction, MessageID}; use queue::{ data_director::{RegMsg, Register}, router::Queue, diff --git a/src/message.rs b/src/message.rs index 35327b0..3e59d38 100644 --- a/src/message.rs +++ b/src/message.rs @@ -1,11 +1,312 @@ -pub mod wrapper; - -use crate::name::NameType; - -pub use wrapper::MessageID; +use crate::{ + action::{Field, MsgAction}, + name::NameType, + queue::data_director::{Include, Path, Route}, +}; +use uuid::Uuid; pub trait MessageAction { fn doc_name(&self) -> &NameType { &NameType::None } } + +#[derive(Clone, Debug, Eq, Hash, PartialEq)] +pub struct MessageID { + data: Uuid, +} + +impl MessageID { + pub fn new() -> Self { + Self { + data: Uuid::new_v4(), + } + } +} + +#[cfg(test)] +mod message_ids { + use super::*; + + #[test] + fn are_message_ids_unique() { + let id1 = MessageID::new(); + let id2 = MessageID::new(); + assert!(id1 != id2); + } +} + +#[derive(Clone, Debug)] +pub struct Message { + msg_id: MessageID, + action: MsgAction, + route: Route, + session: Field, +} + +impl Message { + pub fn new(action: A) -> Self + where + A: Into, + { + Self { + msg_id: MessageID::new(), + action: action.into(), + route: Route::default(), + session: Field::None, + } + } + + pub fn set_id(&self, msg_id: MessageID) -> Self { + let mut output = self.clone(); + output.msg_id = msg_id; + output + } + + pub fn set_session(&self, session: Field) -> Self { + let mut output = self.clone(); + output.session = session; + output + } + + pub fn set_action(&self, action: A) -> Self + where + A: Into, + { + let mut output = self.clone(); + output.action = action.into(); + output + } + + pub fn get_message_id(&self) -> &MessageID { + &self.msg_id + } + + pub fn get_action(&self) -> &MsgAction { + &self.action + } + + pub fn get_path(&self) -> Path { + Path::new( + Include::Just(self.msg_id.clone()), + Include::Just(self.action.doc_name().clone()), + Include::Just(self.action.clone().into()), + ) + } + + pub fn get_route(&self) -> Route { + self.route.clone() + } + + pub fn set_route(&mut self, route: Route) { + self.route = route; + } +} + +impl Default for Message { + fn default() -> Self { + Self { + msg_id: MessageID::new(), + action: MsgAction::None, + route: Route::default(), + session: Field::None, + } + } +} + +impl MessageAction for Message { + fn doc_name(&self) -> &NameType { + self.get_action().doc_name() + } +} + +#[cfg(test)] +mod messages { + use super::*; + use crate::{ + action::{DocDef, Query, Reply}, + name::{name_id_support::test_name_id, Name}, + ErrorID, MTTError, + }; + + fn is_there_a_default_message() { + let msg = Message::default(); + match msg.action { + MsgAction::None => {} + _ => panic!("should have been no action"), + } + assert_eq!(msg.session, Field::None); + } + + #[test] + fn can_create_new_messsage() { + let doc_name = Name::english("something"); + let qry = Query::new(doc_name.clone()); + let msg = Message::new(qry); + let expected: NameType = doc_name.into(); + match msg.action { + MsgAction::Query(data) => assert_eq!(data.doc_name(), &expected), + _ => unreachable!("should have been a query"), + } + match msg.session { + Field::None => {} + _ => unreachable!("should have been none"), + } + } + + #[test] + fn can_id_be_set() { + let doc_name = Name::english("identification"); + let qry = Query::new(doc_name.clone()); + let msg_id = MessageID::new(); + let msg = Message::new(qry).set_id(msg_id.clone()); + assert_eq!(msg.msg_id, msg_id); + } + + #[test] + fn can_session_be_set() { + let doc_name = Name::english("identification"); + let qry = Query::new(doc_name.clone()); + let sess_id: Field = Uuid::new_v4().into(); + let msg = Message::new(qry).set_session(sess_id.clone()); + assert_eq!(msg.session, sess_id); + } + + #[test] + fn can_action_be_set() { + let doc_name = Name::english("action"); + let expected: NameType = doc_name.clone().into(); + let docdef = DocDef::new(doc_name.clone()); + let qry = Query::new(doc_name.clone()); + let msg = Message::new(docdef).set_action(qry); + match msg.action { + MsgAction::Query(data) => assert_eq!(data.doc_name(), &expected), + _ => unreachable!("should have been a query"), + } + } + + #[test] + fn can_the_document_be_a_named_reference() { + let dts = [Name::english("one"), Name::english("two")]; + for document in dts.into_iter() { + let msg = Message::new(MsgAction::Create(DocDef::new(document.clone()))); + match msg.get_action() { + MsgAction::Create(_) => {} + _ => unreachable!("should have been a create document"), + } + } + } + + #[test] + fn can_the_document_be_an_id() { + let document = test_name_id(); + let msg = Message::new(Query::new(document.clone())); + match msg.get_action() { + MsgAction::Query(_) => {} + _ => unreachable!("should have been an access query"), + } + } + + #[test] + fn do_messages_contain_routes() { + let name = Name::english("whatever"); + let mut msg = Message::new(Query::new(name.clone())); + let default_route = msg.get_route(); + match default_route.msg_id { + Include::Just(_) => unreachable!("should defalt to all"), + Include::All => {} + } + match default_route.doc_id { + Include::Just(_) => unreachable!("should defalt to all"), + Include::All => {} + } + match default_route.action { + Include::Just(_) => unreachable!("should defalt to all"), + Include::All => {} + } + let doc_id = test_name_id(); + let route = Route::new( + Include::Just(msg.get_message_id().clone()), + Include::Just(doc_id.clone()), + Include::Just(msg.get_action().into()), + ); + msg.set_route(route); + let result = msg.get_route(); + match result.msg_id { + Include::Just(data) => assert_eq!(&data, msg.get_message_id()), + Include::All => unreachable!("should have message id"), + } + match result.doc_id { + Include::Just(data) => assert_eq!(data, doc_id), + Include::All => unreachable!("should have document id"), + } + match result.action { + Include::Just(data) => assert_eq!(data, msg.get_action().into()), + Include::All => unreachable!("should have action"), + } + } + + #[test] + fn is_the_message_id_random() { + let mut ids: Vec = Vec::new(); + for _ in 0..5 { + let msg = Message::new(Query::new(Name::english("test"))); + let id = msg.get_message_id().clone(); + assert!(!ids.contains(&id), "{:?} containts {:?}", ids, id); + ids.push(id); + } + } + + #[test] + fn can_make_reply_message() { + let name = Name::english("testing"); + let msg = Message::new(Query::new(name.clone())); + let responce = Reply::new(Name::english("something")); + let reply = msg.set_action(responce); + assert_eq!(reply.get_message_id(), msg.get_message_id()); + match reply.get_action() { + MsgAction::Reply(_) => {} + _ => unreachable!("should have been a reply"), + } + } + + #[test] + fn can_make_error_message() { + let name = Name::english("testing"); + let msg = Message::new(Query::new(name.clone())); + let err_msg = Uuid::new_v4().to_string(); + let result = msg.set_action(MTTError::new(ErrorID::DocumentNotFound)); + assert_eq!(result.get_message_id(), msg.get_message_id()); + match result.get_action() { + MsgAction::Error(data) => match data.get_error_ids().back().unwrap() { + ErrorID::DocumentNotFound => {} + _ => unreachable!("got {:?}, should have received not found", data), + }, + _ => unreachable!("should have been a reply"), + } + } + + #[test] + fn can_make_a_response_message() { + let doc_id = test_name_id(); + let msg = Message::new(Query::new(doc_id.clone())); + let data = Uuid::new_v4().to_string(); + let result1 = msg.set_action(MTTError::new(ErrorID::DocumentNotFound)); + let result2 = msg.set_action(Reply::new(NameType::None)); + assert_eq!(result1.get_message_id(), msg.get_message_id()); + assert_eq!(result2.get_message_id(), msg.get_message_id()); + let action1 = result1.get_action(); + match action1 { + MsgAction::Error(err) => match err.get_error_ids().back().unwrap() { + ErrorID::DocumentNotFound => {} + _ => unreachable!("got {:?}: should have received document not found", err), + }, + _ => unreachable!("got {:?}: should have received error", action1), + } + let action2 = result2.get_action(); + match action2 { + MsgAction::Reply(data) => assert_eq!(data.len(), 0), + _ => unreachable!("got {:?}: should have received a reply", action2), + } + } +} diff --git a/src/message/wrapper.rs b/src/message/wrapper.rs index da02e66..8f05242 100644 --- a/src/message/wrapper.rs +++ b/src/message/wrapper.rs @@ -1,4 +1,4 @@ -use super::MessageAction; +use super::{MessageAction, MessageID}; use crate::{ action::{CalcValue, Field, FieldType, MsgAction, Operand, Query, Reply}, mtterror::{ErrorID, MTTError}, @@ -12,31 +12,6 @@ use std::{ }; use uuid::Uuid; -#[derive(Clone, Debug, Eq, Hash, PartialEq)] -pub struct MessageID { - data: Uuid, -} - -impl MessageID { - pub fn new() -> Self { - Self { - data: Uuid::new_v4(), - } - } -} - -#[cfg(test)] -mod message_ids { - use super::*; - - #[test] - fn are_message_ids_unique() { - let id1 = MessageID::new(); - let id2 = MessageID::new(); - assert!(id1 != id2); - } -} - #[derive(Clone, Debug)] pub struct Message { msg_id: MessageID, @@ -310,115 +285,3 @@ mod messages { } } } - -#[allow(dead_code)] -#[derive(Clone, Debug)] -pub struct Operation { - field_name: String, - operation: Operand, - value: Field, -} - -#[allow(dead_code)] -impl Operation { - pub fn new(name: String, op: Operand, value: F) -> Self - where - F: Into, - { - Self { - field_name: name, - operation: op, - value: value.into(), - } - } - - fn which_field(&self) -> String { - self.field_name.clone() - } - - pub fn validate(&self, field: &Field) -> bool { - self.operation.validate(field, &self.value) - } -} - -#[derive(Clone, Debug)] -pub struct Document { - data: HashMap, -} - -impl Document { - fn new() -> Self { - Self { - data: HashMap::new(), - } - } - - pub fn add_field(&mut self, name: NT, field: CV) - where - CV: Into, - NT: Into, - { - self.data.insert(name.into(), field.into()); - } - - fn get_field(&self, name: NT) -> &CalcValue - where - NT: Into, - { - match self.data.get(&name.into()) { - Some(data) => data, - None => &CalcValue::None, - } - } - - #[allow(dead_code)] - fn get_all(&self) -> Vec<(NameType, Field)> { - let mut output = Vec::new(); - for (key, value) in self.data.iter() { - output.push((key.clone(), value.get(&Field::None))); - } - output - } - - pub fn iter(&self) -> impl Iterator { - self.data.iter() - } -} - -#[cfg(test)] -mod documents { - use super::*; - use crate::name::Name; - - #[test] - fn can_add_static_string() { - let mut add = Document::new(); - let name = Name::english(Uuid::new_v4().to_string().as_str()); - let data = Uuid::new_v4().to_string(); - add.add_field(name.clone(), data.clone()); - let result = add.get_field(&name); - match result { - CalcValue::Value(holder) => match holder { - Field::StaticString(result) => assert_eq!(result, &data), - _ => unreachable!("got {:?}: should have received static string", holder), - }, - _ => unreachable!("got {:?}, should have been value", result), - } - } - - #[test] - fn can_add_uuid() { - let mut add = Document::new(); - let name = Name::english(Uuid::new_v4().to_string().as_str()); - let data = Uuid::new_v4(); - add.add_field(name.clone(), data.clone()); - let result = add.get_field(&name); - match result { - CalcValue::Value(holder) => match holder { - Field::Uuid(result) => assert_eq!(result, &data), - _ => unreachable!("got {:?}: should have received static string", holder), - }, - _ => unreachable!("got {:?}, should have been value", result), - } - } -} diff --git a/src/queue/data_director.rs b/src/queue/data_director.rs index 76c6d4d..6a27939 100644 --- a/src/queue/data_director.rs +++ b/src/queue/data_director.rs @@ -1,10 +1,7 @@ use super::SenderID; use crate::{ action::{Action, MsgAction}, - message::{ - wrapper::{Message, MessageID}, - MessageAction, - }, + message::{Message, MessageAction, MessageID}, mtterror::MTTError, name::{Name, NameID, NameType, Names}, queue::router::Queue, diff --git a/src/queue/router.rs b/src/queue/router.rs index 7aba442..f3b1a8a 100644 --- a/src/queue/router.rs +++ b/src/queue/router.rs @@ -1,5 +1,5 @@ use crate::{ - message::wrapper::Message, + message::Message, name::NameType, queue::data_director::{DocRegistry, RegMsg, Register}, };