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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171

use crate::{
    args::Arg,
    item::{Item, ShortLong},
    Args, Error, Meta,
};

pub(crate) fn should_suggest(err: &Error) -> bool {
    match err {
        Error::Stdout(_) => false,
        Error::Stderr(_) => true,
        Error::Missing(xs) => {
            let mut hi = crate::meta_help::HelpItems::default();
            for x in xs.iter() {
                hi.classify_item(x);
            }
            hi.flgs.is_empty() && hi.psns.is_empty()
        }
    }
}

/// Looks for potential typos
pub(crate) fn suggest(args: &Args, meta: &Meta) -> Result<(), Error> {
    if args.tainted {
        return Ok(());
    }

    let arg = match args.peek() {
        Some(arg) => arg,
        None => return Ok(()),
    };

    if args.items.iter().filter(|&a| a == arg).count() > 1 {
        // args contains more than one copy of unexpected item. Either user specified
        // several of those or parser accepts only limited number of them.
        // Or a different branch handles them. Give up and produce a default
        // "not expected in this context" error
        return Ok(());
    }

    let mut variants = Vec::new();
    inner(arg, meta, &mut variants);

    variants.sort_by(|a, b| b.0.cmp(&a.0));

    if let Some((l, best)) = variants.pop() {
        if l > 0 {
            return Err(Error::Stderr(best));
        }
    }
    Ok(())
}

#[derive(Copy, Clone)]
enum I<'a> {
    ShortFlag(char),
    LongFlag(&'a str),
    ShortCmd(char),
    LongCmd(&'a str),
}

// human readable
impl std::fmt::Debug for I<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::ShortFlag(s) => write!(f, "flag: `-{}`", s),
            Self::LongFlag(s) => write!(f, "flag: `--{}`", s),
            Self::ShortCmd(s) => write!(f, "command alias: `{}`", s),
            Self::LongCmd(s) => write!(f, "command: `{}`", s),
        }
    }
}

// used for levenshtein distance calculation
impl std::fmt::Display for I<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        use std::fmt::Write;
        match self {
            Self::ShortFlag(s) => write!(f, "-{}", s),
            Self::LongFlag(s) => write!(f, "--{}", s),
            Self::ShortCmd(s) => f.write_char(*s),
            Self::LongCmd(s) => f.write_str(s),
        }
    }
}

fn ins(expected: I, actual: I, variants: &mut Vec<(usize, String)>) {
    variants.push((
        levenshtein(&expected.to_string(), &actual.to_string()),
        format!("No such {:?}, did you mean `{}`?", actual, expected),
    ));
}

fn inner_item(arg: &Arg, item: &Item, variants: &mut Vec<(usize, String)>) {
    let actual: I = match arg {
        Arg::Short(s, _) => I::ShortFlag(*s),
        Arg::Long(s, _) => I::LongFlag(s.as_str()),
        Arg::Word(w) => match &w.utf8 {
            Some(s) => I::LongCmd(s.as_str()),
            None => return,
        },
    };
    match item {
        Item::Positional { .. } => {}
        Item::Command { name, short, .. } => {
            ins(I::LongCmd(name), actual, variants);
            if let Some(s) = short {
                ins(I::ShortCmd(*s), actual, variants);
            }
        }
        Item::Flag { name, .. } | Item::Argument { name, .. } => match name {
            ShortLong::Short(s) => ins(I::ShortFlag(*s), actual, variants),
            ShortLong::Long(l) => ins(I::LongFlag(l), actual, variants),
            ShortLong::ShortLong(s, l) => {
                ins(I::ShortFlag(*s), actual, variants);
                ins(I::LongFlag(l), actual, variants);
            }
        },
    }
}

fn inner(arg: &Arg, meta: &Meta, variants: &mut Vec<(usize, String)>) {
    match meta {
        Meta::And(xs) | Meta::Or(xs) => {
            for x in xs {
                inner(arg, x, variants);
            }
        }
        Meta::Item(item) => inner_item(arg, item, variants),
        Meta::Optional(meta) | Meta::Many(meta) | Meta::Decorated(meta, _) => {
            inner(arg, meta, variants);
        }
        Meta::Skip => {}
    }
}

fn levenshtein(a: &str, b: &str) -> usize {
    let mut result = 0;
    let mut cache = a.chars().enumerate().map(|i| i.0 + 1).collect::<Vec<_>>();
    let mut distance_a;
    let mut distance_b;

    for (index_b, code_b) in b.chars().enumerate() {
        result = index_b;
        distance_a = index_b;

        for (index_a, code_a) in a.chars().enumerate() {
            distance_b = if code_a == code_b {
                distance_a
            } else {
                distance_a + 1
            };

            distance_a = cache[index_a];

            result = if distance_a > result {
                if distance_b > result {
                    result + 1
                } else {
                    distance_b
                }
            } else if distance_b > distance_a {
                distance_a + 1
            } else {
                distance_b
            };

            cache[index_a] = result;
        }
    }
    result
}