mlbt 0.2.0

A terminal user interface for the MLB stats API. Watch a baseball game in your terminal! ⚾
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

use nucleo_matcher::pattern::{CaseMatching, Normalization, Pattern};
use nucleo_matcher::{Matcher, Utf32Str};

/// Minimum number of characters before fuzzy matching kicks in.
const MIN_QUERY_LEN: usize = 2;

/// Maximum number of results to display.
const MAX_RESULTS: usize = 50;

#[derive(Default)]
pub struct SearchState {
    /// Whether the search input bar is open.
    pub is_open: bool,
    /// The current search input text.
    pub input: String,
    /// Fuzzy matcher for the search input.
    matcher: Matcher,
    /// Row indices (into the stats table) that match the query, sorted by score.
    pub matched_indices: Vec<usize>,
}

impl SearchState {
    pub fn open(&mut self) {
        self.is_open = true;
    }

    /// Cancel search entirely and clear input + matches.
    pub fn close(&mut self) {
        self.is_open = false;
        self.input.clear();
        self.matched_indices.clear();
    }

    /// Close the input bar but keep the filtered results.
    pub fn submit(&mut self) {
        self.is_open = false;
    }

    pub fn handle_char(&mut self, c: char) {
        self.input.push(c);
    }

    pub fn handle_backspace(&mut self) {
        self.input.pop();
    }

    /// Returns true if the stats table should be filtered.
    pub fn is_filtering(&self) -> bool {
        self.input.len() >= MIN_QUERY_LEN
    }

    /// Run fuzzy matching against the given names and populate `matched_indices`.
    pub fn update_matches(&mut self, names: &[String]) {
        self.matched_indices.clear();

        if self.input.len() < MIN_QUERY_LEN {
            return;
        }

        let pattern = Pattern::parse(&self.input, CaseMatching::Ignore, Normalization::Smart);
        let mut buf = Vec::new();

        let mut scored: Vec<(usize, u32)> = names
            .iter()
            .enumerate()
            .filter_map(|(idx, name)| {
                let haystack = Utf32Str::new(name, &mut buf);
                let score = pattern.score(haystack, &mut self.matcher)?;
                Some((idx, score))
            })
            .collect();

        scored.sort_by(|a, b| b.1.cmp(&a.1));
        scored.truncate(MAX_RESULTS);

        self.matched_indices = scored.into_iter().map(|(idx, _)| idx).collect();
    }
}