nbcl 0.1.1

Configuration language designed to be easy and understandable.
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

pub fn levenshtein_distance(a: &str, b: &str) -> usize {
    let b_len = b.chars().count();
    if a.is_empty() {
        return b_len;
    }
    if b.is_empty() {
        return a.chars().count();
    }

    let mut row: Vec<usize> = (0..=b_len).collect();

    for (i, char_a) in a.chars().enumerate() {
        let mut previous_diagonal = row[0];
        row[0] = i + 1;

        for (j, char_b) in b.chars().enumerate() {
            let old_row_j = row[j + 1];

            let cost = if char_a == char_b { 0 } else { 1 };

            row[j + 1] =
                std::cmp::min(std::cmp::min(row[j] + 1, row[j + 1] + 1), previous_diagonal + cost);

            previous_diagonal = old_row_j;
        }
    }

    row[b_len]
}

pub fn find_best_match<'a>(
    input: &str,
    candidates: impl Iterator<Item = &'a String>,
) -> Option<String> {
    let mut best_match: Option<(String, usize)> = None;
    let max_threshold = 3;

    for candidate in candidates {
        let dist = levenshtein_distance(input, candidate);

        if dist <= max_threshold {
            match best_match {
                None => best_match = Some((candidate.clone(), dist)),
                Some((_, best_dist)) if dist < best_dist => {
                    best_match = Some((candidate.clone(), dist));
                }
                _ => {}
            }
        }
    }

    best_match.map(|(name, _)| name)
}

pub fn ordinal(n: usize) -> String {
    let s = n.to_string();
    if s.ends_with('1') && !s.ends_with("11") {
        format!("{}st", n)
    } else if s.ends_with('2') && !s.ends_with("12") {
        format!("{}nd", n)
    } else if s.ends_with('3') && !s.ends_with("13") {
        format!("{}rd", n)
    } else {
        format!("{}th", n)
    }
}