macro-rules-rt 0.1.1

Transforms text or TokenStream using Rust's macro_rules syntax.
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

use macro_rules_rt::{match_all, Rule};
use pretty_assertions::assert_eq;
use syn::Result;

#[derive(Clone, Debug, PartialEq)]
enum Part {
    Unchanged(String),
    Changed(Changed),
}
impl Part {
    fn from(value: match_all::MatchAllPart) -> Self {
        match value {
            match_all::MatchAllPart::Unchanged(u) => Self::Unchanged(u.to_string()),
            match_all::MatchAllPart::Changed(c) => Self::Changed(Changed::from(c)),
        }
    }
}

#[derive(Clone, Debug, PartialEq)]
struct Changed {
    source_str: String,
    replacement_str: String,
    replacements: Vec<Replacement>,
}
impl Changed {
    fn from(value: match_all::Changed) -> Self {
        let source_str = value.input().to_string();
        let replacement_str = value.output();
        let replacements = value.iter().map(Replacement::from).collect();
        Self {
            source_str,
            replacement_str,
            replacements,
        }
    }
}

#[derive(Clone, Debug, PartialEq)]
enum Replacement {
    Match(String),
    Transform(String),
}
impl Replacement {
    fn from(value: match_all::ChangedPart) -> Self {
        match value {
            match_all::ChangedPart::Match(m) => Self::Match(m.to_string()),
            match_all::ChangedPart::Transform(t) => Self::Transform(t.to_string()),
        }
    }
}

fn unchanged(source: &str) -> Part {
    Part::Unchanged(source.to_string())
}
fn changed(source: &str, replacement: &str, replacements: &[Replacement]) -> Part {
    Part::Changed(Changed {
        source_str: source.to_string(),
        replacement_str: replacement.to_string(),
        replacements: replacements.to_vec(),
    })
}
fn m(s: &str) -> Replacement {
    Replacement::Match(s.to_string())
}
fn t(s: &str) -> Replacement {
    Replacement::Transform(s.to_string())
}

#[track_caller]
fn check_raw(from: &str, to: &str, input: &str, expect: &[Part]) -> Result<()> {
    let rule = Rule::new(from.parse()?, to.parse()?)?;
    let m = rule.match_all(input)?;
    let actual: Vec<_> = m.iter().map(Part::from).collect();
    assert_eq!(actual, expect);
    Ok(())
}
#[track_caller]
fn check(from: &str, to: &str, input: &str, expect: &[Part]) {
    check_raw(from, to, input, expect).unwrap()
}

#[test]
fn test_changed() {
    let e = [changed("1+2", "@", &[m("@")])];
    check("$e:expr", "@", "1+2", &e)
}

#[test]
fn test_unchanged_and_changed() {
    let e = [
        unchanged("@@"),
        changed("1+2", "x", &[m("x")]),
        unchanged("@@"),
    ];
    check("$e:expr", "x", "@@1+2@@", &e)
}

#[test]
fn test_transform() {
    let e = [changed(
        "/// xxx",
        "# [ docx = \" xxx\" ]",
        &[t("# ["), m("docx = "), t("\" xxx\" ]")],
    )];
    check("doc = ", "docx = ", "/// xxx", &e)
}

#[test]
fn test_unchanged_and_transform() {
    let e = [
        unchanged("@@\n"),
        changed(
            "/// xxx",
            "# [ docx = \" xxx\" ]",
            &[t("# ["), m("docx = "), t("\" xxx\" ]")],
        ),
    ];
    check("doc = ", "docx = ", "@@\n/// xxx", &e)
}