cuke-dedup 0.11.0

Static analysis for duplicate and reusable Cucumber step definitions
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

//! Preserve Cucumber's unknown table escapes across the stricter gherkin crate grammar.
use anyhow::{bail, Context, Result};
use gherkin::{Feature, Table};
use std::borrow::Cow;

pub(super) fn prepare(source: &str) -> Result<(Cow<'_, str>, Option<char>)> {
    let mut output = None;
    let mut marker = None;
    let mut copied = 0;
    let mut offset = 0;
    let mut fence = None;
    for line in source.split_inclusive('\n') {
        let trimmed = line.trim_start();
        let active = fence;
        if let Some(delimiter) = active {
            if trimmed.starts_with(delimiter) {
                fence = None;
            }
        } else if trimmed.starts_with("\"\"\"") {
            fence = Some("\"\"\"");
        } else if trimmed.starts_with("```") {
            fence = Some("```");
        } else if trimmed.starts_with('|') {
            let mut chars = line.char_indices();
            while let Some((index, character)) = chars.next() {
                if character != '\\' {
                    continue;
                }
                // Consume known escape pairs, including doubled backslashes, as one unit.
                if matches!(chars.clone().next(), Some((_, 'n' | '|' | '\\'))) {
                    chars.next();
                    continue;
                }
                let replacement = match marker {
                    Some(value) => value,
                    None => {
                        let value = unused_marker(source)?;
                        marker = Some(value);
                        value
                    }
                };
                let output = output.get_or_insert_with(|| String::with_capacity(source.len()));
                let position = offset + index;
                output.push_str(&source[copied..position]);
                output.push(replacement);
                copied = position + 1;
            }
        }
        offset += line.len();
    }
    Ok((
        match output {
            None => Cow::Borrowed(source),
            Some(mut output) => {
                output.push_str(&source[copied..]);
                Cow::Owned(output)
            }
        },
        marker,
    ))
}

fn unused_marker(source: &str) -> Result<char> {
    // Fixed occupancy storage and one scan avoid a source scan for every candidate marker.
    let mut used = [false; 0x1900];
    for character in source.chars() {
        if ('\u{e000}'..='\u{f8ff}').contains(&character) {
            used[character as usize - 0xe000] = true;
        }
    }
    if let Some(index) = used.iter().position(|present| !present) {
        return Ok(char::from_u32(0xe000 + index as u32).expect("private-use scalar"));
    }
    bail!("Gherkin table escape compatibility exhausted its reserved-character budget")
}

pub(super) fn finish(feature: &mut Feature, source: &str, marker: Option<char>) -> Result<()> {
    let restore_table = |table: &mut Option<Table>| -> Result<()> {
        if let Some(table) = table {
            let original = source
                .get(table.span.start..table.span.end.min(source.len()))
                .context("Gherkin table source span is out of bounds")?;
            for (index, line) in original.lines().enumerate() {
                if !line.trim_start().starts_with('|') {
                    continue;
                }
                let mut delimiters = 0_usize;
                let mut characters = line.chars();
                while let Some(character) = characters.next() {
                    match character {
                        '\\' => {
                            characters.next();
                        }
                        '|' => delimiters += 1,
                        _ => {}
                    }
                }
                if delimiters.saturating_sub(1) != table.row_width() {
                    bail!(
                        "inconsistent Gherkin table width at line {}",
                        table.position.line + index
                    );
                }
            }
            if let Some(marker) = marker {
                for cell in table.rows.iter_mut().flatten() {
                    *cell = cell.replace(marker, "\\");
                }
            }
        }
        Ok(())
    };
    for background in feature.background.iter_mut().chain(
        feature
            .rules
            .iter_mut()
            .filter_map(|rule| rule.background.as_mut()),
    ) {
        for step in &mut background.steps {
            restore_table(&mut step.table)?;
        }
    }
    for scenario in feature.scenarios.iter_mut().chain(
        feature
            .rules
            .iter_mut()
            .flat_map(|rule| rule.scenarios.iter_mut()),
    ) {
        for example in &mut scenario.examples {
            restore_table(&mut example.table)?;
        }
        for step in &mut scenario.steps {
            restore_table(&mut step.table)?;
        }
    }
    Ok(())
}