rust-meth 0.1.6

Discover methods available on any Rust type with fuzzy filtering, inline documentation, interactive selection, and go-to-definition into standard library source code.
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

use dialoguer::{FuzzySelect, theme::ColorfulTheme};
use fuzzy_matcher::FuzzyMatcher;
use fuzzy_matcher::skim::SkimMatcherV2;

use crate::analyzer;

use super::{args::Opts, display::print_method};

/// Displays a fuzzy-searchable list in the terminal using `dialoguer`.
pub fn run_interactive(opts: &Opts, methods: &[analyzer::Method]) -> Result<(), String> {
    let items: Vec<&str> = methods.iter().map(|m| m.name.as_str()).collect();

    let selection = FuzzySelect::with_theme(&ColorfulTheme::default())
        .with_prompt(format!("Methods on `{}`", opts.type_name))
        .items(&items)
        .interact_opt()
        .map_err(|e| e.to_string())?;

    if let Some(idx) = selection {
        print_method(&methods[idx], 0, opts.show_doc);
    }

    Ok(())
}

/// Applies fuzzy matching to the list of methods.
pub fn filter_methods<'a>(
    methods: &'a [analyzer::Method],
    filter: Option<&str>,
) -> Vec<&'a analyzer::Method> {
    filter.map_or_else(
        || methods.iter().collect(),
        |pat| {
            let matcher = SkimMatcherV2::default();
            let mut scored: Vec<_> = methods
                .iter()
                .filter_map(|m| matcher.fuzzy_match(&m.name, pat).map(|score| (score, m)))
                .collect();

            scored.sort_by_key(|(score, _)| std::cmp::Reverse(*score));
            scored.into_iter().map(|(_, m)| m).collect()
        },
    )
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::analyzer::Method;

    fn make_method(name: &str) -> Method {
        Method {
            name: name.to_string(),
            detail: None,
            documentation: None,
        }
    }

    // ═══════════════════════════════════════════════════════════════
    // UNIT TESTS: filter_methods
    // ═══════════════════════════════════════════════════════════════

    #[test]
    fn test_filter_methods_no_filter() {
        let methods = vec![make_method("len"), make_method("push"), make_method("pop")];

        // No filter = return all
        let result = filter_methods(&methods, None);
        assert_eq!(result.len(), 3);
    }

    #[test]
    fn test_filter_methods_exact_match() {
        let methods = vec![make_method("len"), make_method("push"), make_method("pop")];

        let result = filter_methods(&methods, Some("len"));
        assert_eq!(result.len(), 1);
        assert_eq!(result[0].name, "len");
    }

    #[test]
    fn test_filter_methods_fuzzy_match() {
        let methods = vec![
            make_method("wrapping_add"),
            make_method("wrapping_sub"),
            make_method("checked_add"),
            make_method("saturating_add"),
            make_method("overflowing_add"),
        ];

        // "wrap" should match all "wrapping_*" methods
        let result = filter_methods(&methods, Some("wrap"));
        assert!(result.len() >= 2);
        assert!(result.iter().any(|m| m.name == "wrapping_add"));
        assert!(result.iter().any(|m| m.name == "wrapping_sub"));
    }

    #[test]
    fn test_filter_methods_fuzzy_ordering() {
        let methods = vec![
            make_method("checked_add"),
            make_method("add"),
            make_method("wrapping_add"),
        ];

        // "add" should rank "add" highest, then others
        let result = filter_methods(&methods, Some("add"));
        assert!(!result.is_empty());
        // Exact match should be first
        assert_eq!(result[0].name, "add");
    }

    #[test]
    fn test_filter_methods_no_matches() {
        let methods = vec![make_method("len"), make_method("push")];

        let result = filter_methods(&methods, Some("xyz_nonexistent"));
        assert!(result.is_empty());
    }
}