Initial commit

src/agent/identifier.rs

@@ -0,0 +1,101 @@
+use std::fmt;
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum PublicIdentifier {
+    Static(String),
+    DynamicGlobal(String),
+    DynamicRoomLocal(String),
+}
+
+impl PublicIdentifier {
+    pub fn from_str(s: &str) -> Option<Self> {
+        if let Some(rest) = s.strip_prefix("static/") {
+            return Some(PublicIdentifier::Static(rest.to_string()));
+        } else if let Some(rest) = s.strip_prefix("global/") {
+            return Some(PublicIdentifier::DynamicGlobal(rest.to_string()));
+        } else if let Some(rest) = s.strip_prefix("room-local/") {
+            return Some(PublicIdentifier::DynamicRoomLocal(rest.to_string()));
+        }
+        None
+    }
+
+    pub fn as_string(&self) -> String {
+        match self {
+            PublicIdentifier::Static(s) => format!("static/{}", s),
+            PublicIdentifier::DynamicGlobal(s) => format!("global/{}", s),
+            PublicIdentifier::DynamicRoomLocal(s) => format!("room-local/{}", s),
+        }
+    }
+
+    pub fn prefixless(&self) -> String {
+        match self {
+            PublicIdentifier::Static(s) => s.to_owned(),
+            PublicIdentifier::DynamicGlobal(s) => s.to_owned(),
+            PublicIdentifier::DynamicRoomLocal(s) => s.to_owned(),
+        }
+    }
+
+    pub fn validate(&self) -> Result<(), String> {
+        let prefixless = self.prefixless();
+
+        if prefixless.is_empty() {
+            return Err("The agent ID must not be empty.".to_owned());
+        }
+
+        // We use a slash to separate the agent type from the agent ID.
+        if prefixless.contains("/") {
+            return Err("The agent ID must not contain the `/` character.".to_owned());
+        }
+
+        // Spaces are used for separating command arguments, etc.
+        if prefixless.contains(" ") {
+            return Err("The agent ID must not contain spaces.".to_owned());
+        }
+
+        Ok(())
+    }
+}
+
+impl fmt::Display for PublicIdentifier {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.as_string())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_public_identifier_from_str() {
+        assert_eq!(
+            PublicIdentifier::from_str("static/abc"),
+            Some(PublicIdentifier::Static("abc".to_string()))
+        );
+        assert_eq!(
+            PublicIdentifier::from_str("global/abc"),
+            Some(PublicIdentifier::DynamicGlobal("abc".to_string()))
+        );
+        assert_eq!(
+            PublicIdentifier::from_str("room-local/abc"),
+            Some(PublicIdentifier::DynamicRoomLocal("abc".to_string()))
+        );
+        assert_eq!(PublicIdentifier::from_str("abc"), None);
+    }
+
+    #[test]
+    fn test_public_identifier_as_string() {
+        assert_eq!(
+            PublicIdentifier::Static("abc".to_string()).as_string(),
+            "static/abc"
+        );
+        assert_eq!(
+            PublicIdentifier::DynamicGlobal("abc".to_string()).as_string(),
+            "global/abc"
+        );
+        assert_eq!(
+            PublicIdentifier::DynamicRoomLocal("abc".to_string()).as_string(),
+            "room-local/abc"
+        );
+    }
+}