loftspec 2.0.2

The Loft Specification Format: document model, identity, canonical bytes, hashing and conversion
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

//! The tokenizer the Format's statement parser and language rules share: a text splits on
//! Unicode word bounds, and each segment holding a letter or a decimal digit is a token, in
//! lower case. Punctuation, spaces and symbols such as backticks are not tokens.

use std::ops::Range;

use unicode_properties::{GeneralCategory, UnicodeGeneralCategory};
use unicode_segmentation::UnicodeSegmentation;

/// The tokens of `text`, lower-cased, in order.
#[must_use]
pub fn tokenize(text: &str) -> Vec<String> {
    token_ranges(text)
        .into_iter()
        .map(|range| lowercase(&text[range]))
        .collect()
}

/// A token in lower case.
pub(crate) fn lowercase(token: &str) -> String {
    token.chars().flat_map(char::to_lowercase).collect()
}

/// The byte range in `text` of each token [`tokenize`] returns, in the same order.
#[must_use]
pub fn token_ranges(text: &str) -> Vec<Range<usize>> {
    text.split_word_bound_indices()
        .filter(|(_, segment)| segment.chars().any(is_token_character))
        .map(|(start, segment)| start..start + segment.len())
        .collect()
}

fn is_token_character(character: char) -> bool {
    matches!(
        character.general_category(),
        GeneralCategory::UppercaseLetter
            | GeneralCategory::LowercaseLetter
            | GeneralCategory::TitlecaseLetter
            | GeneralCategory::ModifierLetter
            | GeneralCategory::OtherLetter
            | GeneralCategory::DecimalNumber
    )
}

/// The byte range of each code span in `text`, its backticks included, as a Markdown reader reads
/// it: a run of backticks opens a span that the next run of the same length closes, and a run
/// nothing closes is literal.
pub(crate) fn code_spans(text: &str) -> Vec<Range<usize>> {
    let run = |from: usize| {
        text[from..]
            .bytes()
            .take_while(|byte| *byte == b'`')
            .count()
    };
    let mut spans = Vec::new();
    let mut at = 0;
    while let Some(offset) = text[at..].find('`') {
        let open = at + offset;
        let length = run(open);
        let mut search = open + length;
        let mut close = None;
        while let Some(offset) = text[search..].find('`') {
            let start = search + offset;
            let found = run(start);
            if found == length {
                close = Some(start + found);
                break;
            }
            search = start + found;
        }
        match close {
            Some(end) => {
                spans.push(open..end);
                at = end;
            }
            None => at = open + length,
        }
    }
    spans
}

#[cfg(test)]
mod tests {
    use super::{token_ranges, tokenize};

    #[test]
    fn tokens_are_lower_case_words_and_numbers_without_punctuation() {
        assert_eq!(
            tokenize("If `spec/` exists, then `loft init` shall exit 1."),
            [
                "if", "spec", "exists", "then", "loft", "init", "shall", "exit", "1"
            ]
        );
    }

    #[test]
    fn each_range_covers_its_token() {
        let text = "When a, b hold, the Publisher shall refuse.";
        let ranges = token_ranges(text);
        let tokens = tokenize(text);
        assert_eq!(ranges.len(), tokens.len());
        for (range, token) in ranges.iter().zip(&tokens) {
            assert_eq!(text[range.clone()].to_lowercase(), *token);
        }
    }
}