neva 0.3.2

MCP SDK for Rust
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
136
137

//! URI helpers and utilities

use crate::shared::MemChr;
use serde::{Deserialize, Serialize};
use std::fmt::{Display, Formatter};
use std::ops::{Deref, DerefMut};

const PATH_SEPARATOR: char = '/';
const SCHEME_SEPARATOR: [u8; 3] = [b':', b'/', b'/'];

/// Represents a resource URI
#[derive(Debug, Clone, Eq, Hash, PartialEq, Serialize, Deserialize)]
pub struct Uri(String);

impl Deref for Uri {
    type Target = str;

    #[inline]
    fn deref(&self) -> &str {
        &self.0
    }
}

impl DerefMut for Uri {
    #[inline]
    fn deref_mut(&mut self) -> &mut str {
        &mut self.0
    }
}

impl Display for Uri {
    #[inline]
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(f)
    }
}

impl From<String> for Uri {
    #[inline]
    fn from(s: String) -> Self {
        Uri(s)
    }
}

impl From<&str> for Uri {
    #[inline]
    fn from(s: &str) -> Self {
        Uri(s.to_owned())
    }
}

impl Uri {
    /// Returns the inner URL string
    #[inline]
    pub fn into_inner(self) -> String {
        self.0
    }

    /// Splits the URI into scheme and path parts
    ///
    /// # Example
    /// ```rust
    /// use neva::types::Uri;
    ///
    /// let uri = Uri::from("res://test1/test2");
    ///         
    /// assert_eq!(uri.parts().unwrap().collect::<Vec<_>>(), ["res", "test1", "test2"]);
    /// ```
    pub fn parts(&self) -> Option<impl Iterator<Item = &str>> {
        let scheme_end = memchr::memmem::find(self.as_bytes(), &SCHEME_SEPARATOR)?;
        let scheme = &self[..scheme_end];
        let mut rest = &self[scheme_end + 3..];

        rest = rest.trim_start_matches(PATH_SEPARATOR);

        Some(std::iter::once(scheme).chain(MemChr::split(rest, PATH_SEPARATOR as u8)))
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn it_converts_from_str() {
        let uri = Uri::from("res://test1");

        assert_eq!(uri.to_string(), "res://test1");
    }

    #[test]
    fn it_splits_scheme_and_path() {
        let uri = Uri::from("res://test1/test2");

        assert_eq!(
            uri.parts().unwrap().collect::<Vec<_>>(),
            ["res", "test1", "test2"]
        );
    }

    #[test]
    fn it_splits_empty() {
        let uri = Uri::from("");

        assert!(uri.parts().is_none());
    }

    #[test]
    fn it_splits_scheme_and_path_with_double_slash() {
        let uri = Uri::from("res://test1//test2");

        assert_eq!(
            uri.parts().unwrap().collect::<Vec<_>>(),
            ["res", "test1", "test2"]
        );
    }

    #[test]
    fn it_splits_scheme_and_path_with_trailing_slash() {
        let uri = Uri::from("res://test1/test2/");

        assert_eq!(
            uri.parts().unwrap().collect::<Vec<_>>(),
            ["res", "test1", "test2"]
        );
    }

    #[test]
    fn it_splits_scheme_and_path_with_leading_slash() {
        let uri = Uri::from("res:///test1/test2");

        assert_eq!(
            uri.parts().unwrap().collect::<Vec<_>>(),
            ["res", "test1", "test2"]
        );
    }
}