itsi-server 0.2.21 → 0.2.23

data/vendor/rb-sys-build/src/rb_config/flags.rs

@@ -0,0 +1,101 @@
+/// Some helper functionality around shell flags
+pub struct Flags<'a> {
+    inner: &'a str,
+}
+
+impl<'a> Flags<'a> {
+    /// Creates a new `Flags` instance
+    pub fn new(inner: &'a str) -> Self {
+        Self { inner }
+    }
+}
+
+/// Iterates over a string of flags
+impl<'a> Iterator for Flags<'a> {
+    type Item = &'a str;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let mut last_was_space = false;
+
+        let last_idx = self
+            .inner
+            .chars()
+            .by_ref()
+            .take_while(|c| match c {
+                '-' => {
+                    if last_was_space {
+                        false
+                    } else {
+                        last_was_space = false;
+                        true
+                    }
+                }
+                ' ' => {
+                    last_was_space = true;
+
+                    true
+                }
+                _ => {
+                    last_was_space = false;
+                    true
+                }
+            })
+            .count();
+
+        let buf = &self.inner[..last_idx].trim();
+
+        if buf.is_empty() {
+            None
+        } else {
+            self.inner = self.inner[last_idx..].trim();
+            Some(buf)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_basic_flags() {
+        let mut flags = Flags::new("--foo --bar -baz");
+
+        assert_eq!(flags.next(), Some("--foo"));
+        assert_eq!(flags.next(), Some("--bar"));
+        assert_eq!(flags.next(), Some("-baz"));
+        assert_eq!(flags.next(), None);
+    }
+
+    #[test]
+    fn test_flag_variations() {
+        let mut flags = Flags::new("-ltest     --library test");
+
+        assert_eq!(flags.next(), Some("-ltest"));
+        assert_eq!(flags.next(), Some("--library test"));
+        assert_eq!(flags.next(), None);
+    }
+
+    #[test]
+    fn test_real_ldflags() {
+        let mut flags = Flags::new("-L. -L/Users/ianks/.asdf/installs/ruby/3.1.1/lib -L/opt/homebrew/opt/openssl@1.1/lib -fstack-protector-strong");
+
+        assert_eq!(flags.next(), Some("-L."));
+        assert_eq!(
+            flags.next(),
+            Some("-L/Users/ianks/.asdf/installs/ruby/3.1.1/lib")
+        );
+        assert_eq!(flags.next(), Some("-L/opt/homebrew/opt/openssl@1.1/lib"));
+        assert_eq!(flags.next(), Some("-fstack-protector-strong"));
+        assert_eq!(flags.next(), None);
+    }
+
+    #[test]
+    fn test_dashed_flag_with_dashed_val() {
+        let mut flags = Flags::new("-ltest -fsomething-foo bar-val");
+
+        assert_eq!(flags.next(), Some("-ltest"));
+        assert_eq!(flags.next(), Some("-fsomething-foo bar-val"));
+        assert_eq!(flags.next(), None);
+    }
+}

data/vendor/rb-sys-build/src/rb_config/library.rs

@@ -0,0 +1,132 @@
+/// Represents the kind of library.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum LibraryKind {
+    Framework,
+    Dylib,
+    Static,
+    None,
+}
+
+/// Represents a search path that can be linked with Cargo.
+#[derive(Debug, PartialEq, Eq)]
+pub struct Library {
+    pub kind: LibraryKind,
+    pub name: String,
+}
+
+impl Library {
+    pub fn is_static(&self) -> bool {
+        self.kind == LibraryKind::Static
+    }
+}
+
+impl From<&str> for LibraryKind {
+    fn from(s: &str) -> Self {
+        match s {
+            "framework" => LibraryKind::Framework,
+            "dylib" => LibraryKind::Dylib,
+            "static" => LibraryKind::Static,
+            _ => LibraryKind::None,
+        }
+    }
+}
+
+impl From<&str> for Library {
+    fn from(s: &str) -> Self {
+        let parts: Vec<_> = s.splitn(2, '=').collect();
+
+        match parts.len() {
+            1 => (LibraryKind::None, parts[0]).into(),
+            2 => (parts[0], parts[1]).into(),
+            _ => panic!("Invalid library specification: {}", s),
+        }
+    }
+}
+
+impl From<String> for Library {
+    fn from(s: String) -> Self {
+        s.as_str().into()
+    }
+}
+
+fn sanitize_library_name(name: &str) -> &str {
+    name.trim_end_matches(".lib").trim_start_matches("-l")
+}
+
+impl<K, L> From<(K, L)> for Library
+where
+    K: Into<LibraryKind>,
+    L: Into<String>,
+{
+    fn from((kind, name): (K, L)) -> Self {
+        Self {
+            kind: kind.into(),
+            name: sanitize_library_name(&name.into()).into(),
+        }
+    }
+}
+
+impl std::fmt::Display for Library {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self.kind {
+            LibraryKind::Framework => write!(f, "framework={}", self.name),
+            LibraryKind::Dylib => write!(f, "dylib={}", self.name),
+            LibraryKind::Static => write!(f, "static={}", self.name),
+            LibraryKind::None => write!(f, "{}", self.name),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_trim_leading_link_flag() {
+        let result: Library = "-lfoo".to_string().into();
+
+        assert_eq!(result.name, "foo");
+    }
+
+    #[test]
+    fn test_trim_trailing_lib_extension() {
+        let result: Library = "foo.lib".to_string().into();
+
+        assert_eq!(result.name, "foo");
+    }
+
+    #[test]
+    fn test_trim_leading_link_flag_and_trailing_lib_extension() {
+        let result: Library = "-lfoo.lib".to_string().into();
+
+        assert_eq!(result.name, "foo");
+    }
+
+    #[test]
+    fn test_display_framework() {
+        let result: Library = "framework=foo".to_string().into();
+
+        assert_eq!(result.to_string(), "framework=foo");
+    }
+
+    #[test]
+    fn test_display_dylib() {
+        let result: Library = "dylib=foo".to_string().into();
+
+        assert_eq!(result.to_string(), "dylib=foo");
+    }
+
+    #[test]
+    fn test_display_static() {
+        let result: Library = "static=-lfoo".to_string().into();
+
+        assert_eq!(result.to_string(), "static=foo");
+    }
+
+    #[test]
+    fn test_display_none() {
+        let result: Library = "foo".to_string().into();
+
+        assert_eq!(result.to_string(), "foo");
+    }
+}

data/vendor/rb-sys-build/src/rb_config/search_path.rs

@@ -0,0 +1,57 @@
+/// Represents the kind of search path.
+#[derive(Debug, PartialEq, Eq)]
+pub enum SearchPathKind {
+    Native,
+    Framework,
+}
+
+/// Represents a library taht can be linked with Cargo.
+#[derive(Debug, PartialEq, Eq)]
+pub struct SearchPath {
+    pub kind: SearchPathKind,
+    pub name: String,
+}
+
+impl From<&str> for SearchPathKind {
+    fn from(s: &str) -> Self {
+        match s {
+            "framework" => SearchPathKind::Framework,
+            "native" => SearchPathKind::Native,
+            _ => panic!("Unknown lib kind: {}", s),
+        }
+    }
+}
+
+impl From<&str> for SearchPath {
+    fn from(s: &str) -> Self {
+        let parts: Vec<_> = s.split('=').collect();
+
+        match parts.len() {
+            1 => (SearchPathKind::Native, parts[0]).into(),
+            2 => (parts[0], parts[1]).into(),
+            _ => panic!("Invalid library specification: {}", s),
+        }
+    }
+}
+
+impl<K, T> From<(K, T)> for SearchPath
+where
+    K: Into<SearchPathKind>,
+    T: Into<String>,
+{
+    fn from((kind, name): (K, T)) -> Self {
+        Self {
+            kind: kind.into(),
+            name: name.into(),
+        }
+    }
+}
+
+impl std::fmt::Display for SearchPath {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self.kind {
+            SearchPathKind::Framework => write!(f, "framework={}", self.name),
+            SearchPathKind::Native => write!(f, "native={}", self.name),
+        }
+    }
+}