perl-module-token 0.12.2

Rewrite standalone Perl module tokens without partial-name matches
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

use perl_module_name::legacy_package_separator;
use perl_module_token::{contains_module_token, replace_module_token};
use proptest::prelude::*;

fn module_name_strategy() -> impl Strategy<Value = String> {
    proptest::collection::vec("[A-Za-z_][A-Za-z0-9_]{0,8}", 1..5)
        .prop_map(|segments| segments.join("::"))
}

fn boundary_padding_strategy() -> impl Strategy<Value = String> {
    let boundary_char = prop_oneof![
        Just(' '),
        Just('\t'),
        Just(';'),
        Just(','),
        Just('('),
        Just(')'),
        Just('['),
        Just(']'),
        Just('{'),
        Just('}'),
        Just('/'),
        Just('-'),
        Just('"'),
    ];

    proptest::collection::vec(boundary_char, 0..8).prop_map(|chars| chars.into_iter().collect())
}

fn nonempty_boundary_padding_strategy() -> impl Strategy<Value = String> {
    boundary_padding_strategy()
        .prop_filter("boundary padding must not be empty", |padding| !padding.is_empty())
}

fn module_char_strategy() -> impl Strategy<Value = char> {
    prop_oneof![
        proptest::char::range('a', 'z'),
        proptest::char::range('A', 'Z'),
        proptest::char::range('0', '9'),
        Just('_'),
        Just(':'),
    ]
}

proptest! {
    #[test]
    fn prop_replacement_occurs_for_standalone_module_tokens(
        prefix in boundary_padding_strategy(),
        suffix in boundary_padding_strategy(),
        from in module_name_strategy(),
        to in module_name_strategy(),
    ) {
        prop_assume!(from != to);

        let line = format!("{prefix}{from}{suffix}");
        let (rewritten, changed) = replace_module_token(&line, &from, &to);

        prop_assert!(changed);
        prop_assert_eq!(rewritten, format!("{prefix}{to}{suffix}"));
    }

    #[test]
    fn prop_replacement_occurs_for_legacy_module_tokens(
        prefix in boundary_padding_strategy(),
        suffix in boundary_padding_strategy(),
        from in module_name_strategy(),
        to in module_name_strategy(),
    ) {
        prop_assume!(from != to);

        let legacy_from = legacy_package_separator(&from).into_owned();
        let legacy_to = legacy_package_separator(&to).into_owned();
        let line = format!("{prefix}{legacy_from}{suffix}");
        let (rewritten, changed) = replace_module_token(&line, &legacy_from, &legacy_to);

        prop_assert!(changed);
        prop_assert_eq!(rewritten, format!("{prefix}{legacy_to}{suffix}"));
    }

    #[test]
    fn prop_replacement_does_not_trigger_on_partial_module_names(
        left in module_char_strategy(),
        right in module_char_strategy(),
        from in module_name_strategy(),
        to in module_name_strategy(),
    ) {
        prop_assume!(from != to);

        let line = format!("{left}{from}{right}");
        let (rewritten, changed) = replace_module_token(&line, &from, &to);

        prop_assert!(!changed);
        prop_assert_eq!(rewritten.as_str(), line.as_str());
        prop_assert!(!contains_module_token(&rewritten, &from));
    }

    #[test]
    fn prop_replacement_updates_every_standalone_occurrence(
        prefix in boundary_padding_strategy(),
        infix in nonempty_boundary_padding_strategy(),
        suffix in boundary_padding_strategy(),
        from in module_name_strategy(),
        to in module_name_strategy(),
    ) {
        prop_assume!(from != to);

        let line = format!("{prefix}{from}{infix}{from}{suffix}");
        let (rewritten, changed) = replace_module_token(&line, &from, &to);

        prop_assert!(changed);
        let expected = format!("{prefix}{to}{infix}{to}{suffix}");
        prop_assert_eq!(rewritten.as_str(), expected.as_str());
        prop_assert!(!contains_module_token(&rewritten, &from));
        prop_assert!(contains_module_token(&rewritten, &to));
    }

    #[test]
    fn prop_self_replacement_preserves_the_line(
        line in "(?s).{0,256}",
        module in module_name_strategy(),
    ) {
        let (rewritten, changed) = replace_module_token(&line, &module, &module);
        prop_assert_eq!(contains_module_token(&line, &module), changed);
        prop_assert_eq!(rewritten, line);
    }
}