omena-transform-passes 0.1.14

Transform pass registry and DAG planner for Omena CSS
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

use omena_parser::{StyleDialect, lex};
use omena_syntax::SyntaxKind;

pub(crate) fn remove_source_ranges(source: &str, ranges: &[(usize, usize)]) -> (String, usize) {
    if ranges.is_empty() {
        return (source.to_string(), 0);
    }

    let mut ranges = ranges.to_vec();
    ranges.sort_by_key(|(start, _)| *start);
    let mut output = String::with_capacity(source.len());
    let mut cursor = 0;
    let mut removed_count = 0;
    for (start, end) in &ranges {
        if *start < cursor {
            continue;
        }
        if *start > cursor {
            output.push_str(&source[cursor..*start]);
        }
        cursor = *end;
        removed_count += 1;
    }
    if cursor < source.len() {
        output.push_str(&source[cursor..]);
    }

    (output, removed_count)
}

pub(crate) fn replace_source_ranges(
    source: &str,
    replacements: &[(usize, usize, String)],
) -> (String, usize) {
    if replacements.is_empty() {
        return (source.to_string(), 0);
    }

    let mut replacements = replacements.to_vec();
    replacements.sort_by_key(|(start, _, _)| *start);
    let mut output = String::with_capacity(source.len());
    let mut cursor = 0;
    let mut replacement_count = 0;
    for (start, end, replacement) in &replacements {
        if *start < cursor {
            continue;
        }
        if *start > cursor {
            output.push_str(&source[cursor..*start]);
        }
        output.push_str(replacement);
        cursor = *end;
        replacement_count += 1;
    }
    if cursor < source.len() {
        output.push_str(&source[cursor..]);
    }

    (output, replacement_count)
}

pub(crate) fn rewrite_lexer_tokens(
    source: &str,
    dialect: StyleDialect,
    mut rewrite: impl FnMut(SyntaxKind, &str) -> Option<String>,
) -> (String, usize) {
    let lexed = lex(source, dialect);
    let mut output = String::with_capacity(source.len());
    let mut cursor = 0;
    let mut mutation_count = 0;

    for token in lexed.tokens() {
        let start = u32::from(token.range.start()) as usize;
        let end = u32::from(token.range.end()) as usize;
        if start > cursor {
            output.push_str(&source[cursor..start]);
        }
        if let Some(replacement) = rewrite(token.kind, &token.text) {
            if replacement != token.text {
                mutation_count += 1;
            }
            output.push_str(&replacement);
        } else {
            output.push_str(&source[start..end]);
        }
        cursor = end;
    }

    if cursor < source.len() {
        output.push_str(&source[cursor..]);
    }

    (output, mutation_count)
}