perl-corpus 0.13.3

Test corpus management and generators for Perl parsers
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
138
139
140

use proptest::prelude::*;
use std::collections::BTreeSet;

/// Paired and symmetric delimiters for qw
pub fn delim() -> impl Strategy<Value = (char, char)> {
    prop_oneof![
        // Paired delimiters
        Just(('(', ')')),
        Just(('[', ']')),
        Just(('{', '}')),
        Just(('<', '>')),
        // Symmetric delimiters
        Just(('|', '|')),
        Just(('!', '!')),
        Just(('#', '#')),
        Just(('/', '/')),
        Just(('~', '~')),
        Just((',', ',')),
        Just(('.', '.')),
        Just((':', ':')),
    ]
}

/// Generate valid Perl identifiers
pub fn identifier() -> impl Strategy<Value = String> {
    "[A-Za-z_][A-Za-z0-9_]{0,8}".prop_map(|s| s.to_string())
}

/// Generate a list of words for qw
pub fn words() -> impl Strategy<Value = Vec<String>> {
    prop::collection::vec(identifier(), 1..6)
}

/// Generate whitespace (spaces, tabs, newlines)
pub fn whitespace() -> impl Strategy<Value = String> {
    prop_oneof![
        Just(" ".to_string()),
        Just("  ".to_string()),
        Just("\t".to_string()),
        Just("\n".to_string()),
        Just("\n  ".to_string()),
    ]
}

/// Build a `use constant` with 1..4 qw-groups
pub fn use_constant_qw() -> impl Strategy<Value = (String, Vec<String>)> {
    (1usize..4, words(), delim(), whitespace()).prop_map(
        |(groups, word_list, (open, close), ws)| {
            let mut all_words = BTreeSet::new();
            let mut src = String::from("use constant ");

            for g in 0..groups {
                // Vary subset size by group index
                let subset: Vec<_> =
                    word_list.iter().take(1 + (g % word_list.len())).cloned().collect();

                let inner = subset.join(&ws);
                for w in &subset {
                    all_words.insert(w.clone());
                }

                src.push_str(&format!("qw{}{}{}", open, inner, close));

                if g + 1 < groups {
                    src.push_str(" => 1, ");
                } else {
                    src.push(';');
                }
            }

            (src, all_words.into_iter().collect())
        },
    )
}

/// Generate a simple qw expression
pub fn simple_qw() -> impl Strategy<Value = String> {
    (words(), delim(), whitespace()).prop_map(|(word_list, (open, close), ws)| {
        format!("qw{}{}{}", open, word_list.join(&ws), close)
    })
}

/// Generate qw with various contexts (assignment, push, etc.)
pub fn qw_in_context() -> impl Strategy<Value = String> {
    (
        simple_qw(),
        prop::sample::select(vec![
            "my @x = ",
            "push @arr, ",
            "unshift @list, ",
            "for (",
            "grep { $_ } ",
            "map { uc } ",
        ]),
    )
        .prop_map(|(qw, prefix)| {
            if prefix.starts_with("for") {
                format!("{}{}) {{ }}", prefix, qw)
            } else if prefix.starts_with("grep") || prefix.starts_with("map") {
                format!("{}{}", prefix, qw)
            } else {
                format!("{}{};", prefix, qw)
            }
        })
}

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

    proptest! {
        #[test]
        fn delimiters_are_balanced((open, close) in delim()) {
            // Paired delimiters
            if open != close {
                assert!(matches!((open, close),
                    ('(', ')') | ('[', ']') | ('{', '}') | ('<', '>')));
            }
            // Symmetric delimiters
            else {
                assert!(open == close);
            }
        }

        #[test]
        fn identifiers_are_valid(id in identifier()) {
            // Identifiers must not be empty (guaranteed by generator)
            let first_char = id.chars().next().unwrap_or('\0');
            assert!(first_char.is_ascii_alphabetic() || id.starts_with('_'));
            assert!(id.chars().all(|c| c.is_ascii_alphanumeric() || c == '_'));
        }

        #[test]
        fn use_constant_produces_valid_syntax((src, _expected) in use_constant_qw()) {
            assert!(src.starts_with("use constant "));
            assert!(src.ends_with(';'));
            assert!(src.contains("qw"));
        }
    }
}