rb-sys-build 0.9.129

Build system for rb-sys
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

/// 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);
    }
}