pray-core 1.9.1

Core library for Prayfile, the package manager for the language placed before inference
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

pub const TOP_LEVEL_COMMANDS: &[&str] = &[
    "add",
    "apply",
    "clean",
    "completion",
    "confess",
    "drift",
    "explain",
    "fmt",
    "format",
    "help",
    "init",
    "install",
    "list",
    "login",
    "manifest",
    "outdated",
    "package",
    "plan",
    "prayer",
    "publish",
    "remove",
    "render",
    "repo",
    "search",
    "serve",
    "sync",
    "token",
    "tree",
    "trust",
    "unlock",
    "update",
    "upgrade",
    "vendor",
    "verify",
    "version",
    "yank",
];

pub fn unknown_command_message(command: &str) -> String {
    let mut message = format!("unknown command: {command}");
    if let Some(suggestion) = suggest_command(command, TOP_LEVEL_COMMANDS) {
        message.push_str(&format!("\nDid you mean `{suggestion}`?"));
    }
    message.push_str("\nSee 'pray --help'.");
    message
}

pub fn suggest_command<'a>(input: &str, candidates: &'a [&str]) -> Option<&'a str> {
    let maximum_distance = if input.chars().count() <= 3 { 1 } else { 2 };
    candidates
        .iter()
        .copied()
        .filter(|candidate| levenshtein_distance(input, candidate) <= maximum_distance)
        .min_by_key(|candidate| levenshtein_distance(input, candidate))
}

fn levenshtein_distance(left: &str, right: &str) -> usize {
    let left_chars: Vec<char> = left.chars().collect();
    let right_chars: Vec<char> = right.chars().collect();
    let left_length = left_chars.len();
    let right_length = right_chars.len();

    if left_length == 0 {
        return right_length;
    }
    if right_length == 0 {
        return left_length;
    }

    let mut previous_row: Vec<usize> = (0..=right_length).collect();
    let mut current_row = vec![0; right_length + 1];

    for (left_index, left_character) in left_chars.iter().enumerate() {
        current_row[0] = left_index + 1;
        for (right_index, right_character) in right_chars.iter().enumerate() {
            let substitution_cost = if left_character == right_character {
                0
            } else {
                1
            };
            current_row[right_index + 1] = (previous_row[right_index + 1] + 1)
                .min(current_row[right_index] + 1)
                .min(previous_row[right_index] + substitution_cost);
        }
        std::mem::swap(&mut previous_row, &mut current_row);
    }

    previous_row[right_length]
}

#[cfg(test)]
mod tests {
    use super::{suggest_command, unknown_command_message, TOP_LEVEL_COMMANDS};

    #[test]
    fn suggests_install_for_common_typo() {
        assert_eq!(
            suggest_command("instal", TOP_LEVEL_COMMANDS),
            Some("install")
        );
    }

    #[test]
    fn unknown_command_includes_suggestion() {
        let message = unknown_command_message("instal");
        assert!(message.contains("unknown command: instal"));
        assert!(message.contains("Did you mean `install`?"));
        assert!(message.contains("See 'pray --help'."));
    }
}