itsi 0.2.24 → 0.2.26

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

@@ -1,101 +0,0 @@
-/// 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/gems/scheduler/vendor/rb-sys-build/src/rb_config/library.rs

@@ -1,132 +0,0 @@
-/// 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/gems/scheduler/vendor/rb-sys-build/src/rb_config/search_path.rs

@@ -1,57 +0,0 @@
-/// 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),
-        }
-    }
-}