plexor-core 0.1.0-alpha.2

Core library for the rust implementation of the Plexo distributed system architecture, providing the fundamental Plexus, Neuron, Codec, and Axon abstractions.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

// Copyright 2025 Alecks Gates
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

use std::fmt;
use std::sync::Arc;

pub trait Namespace: fmt::Display + Send + Sync + 'static {
    fn path(&self) -> String;
    fn with_suffix(&self, suffix: Vec<&str>) -> String;
}

/// A static implementation of Namespace.
///
/// # Examples
///
/// ```rust
/// # use plexor_core::namespace::{Namespace, NamespaceImpl};
/// #
/// let ns = NamespaceImpl { delimiter: ".", parts: vec!["dev", "plexo"] };
/// assert_eq!(ns.path(), "dev.plexo");
/// assert_eq!(ns.with_suffix(vec!["test"]), "dev.plexo.test");
/// ```
#[derive(Debug, Clone)]
pub struct NamespaceImpl {
    pub delimiter: &'static str,
    pub parts: Vec<&'static str>,
}

impl NamespaceImpl {
    /// Create an Arc<NamespaceImpl> from this instance
    pub fn into_arc(self) -> Arc<NamespaceImpl> {
        Arc::new(self)
    }
}

impl Namespace for NamespaceImpl {
    fn path(&self) -> String {
        self.parts.join(self.delimiter)
    }

    fn with_suffix(&self, suffix: Vec<&str>) -> String {
        let parts_with_suffix: Vec<&str> = self.parts.clone().into_iter().chain(suffix).collect();

        parts_with_suffix.join(self.delimiter)
    }
}

impl fmt::Display for NamespaceImpl {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.path())
    }
}

/// A dynamic version of Namespace for cases where parts are only known at runtime (e.g. discovery).
#[derive(Debug, Clone)]
pub struct DynamicNamespace {
    pub delimiter: String,
    pub parts: Vec<String>,
}

impl DynamicNamespace {
    /// Create a DynamicNamespace from a string with a delimiter.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use plexor_core::namespace::{Namespace, DynamicNamespace};
    /// #
    /// let ns = DynamicNamespace::from_str("dev.plexo", ".");
    /// assert_eq!(ns.path(), "dev.plexo");
    /// assert_eq!(ns.with_suffix(vec!["test"]), "dev.plexo.test");
    /// ```
    pub fn from_str(path: &str, delimiter: &str) -> Self {
        Self {
            delimiter: delimiter.to_string(),
            parts: path.split(delimiter).map(|s| s.to_string()).collect(),
        }
    }

    /// Helper to create an Arc<DynamicNamespace>
    pub fn new_arc(path: &str, delimiter: &str) -> Arc<Self> {
        Arc::new(Self::from_str(path, delimiter))
    }
}

impl Namespace for DynamicNamespace {
    fn path(&self) -> String {
        self.parts.join(&self.delimiter)
    }

    fn with_suffix(&self, suffix: Vec<&str>) -> String {
        let mut p = self.parts.clone();
        p.extend(suffix.iter().map(|s| s.to_string()));
        p.join(&self.delimiter)
    }
}

impl fmt::Display for DynamicNamespace {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.path())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::test_utils::test_namespace;

    #[test]
    fn test_namespace_path() {
        let ns = test_namespace();
        assert_eq!("dev.plexo", ns.path());
    }

    #[test]
    fn test_namespace_with_suffix() {
        let ns = test_namespace();
        assert_eq!(
            "dev.plexo.test.foobar",
            ns.with_suffix(vec!["test", "foobar"])
        );
    }

    #[test]
    fn test_namespace_display() {
        let ns = NamespaceImpl {
            delimiter: ".",
            parts: vec!["dev", "plexo"],
        };
        assert_eq!("dev.plexo", format!("{ns}"));
    }
}