sql-cli 1.71.0

SQL query tool for CSV/JSON with both interactive TUI and non-interactive CLI modes - perfect for exploration and automation
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
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

//! State coordination trait for Buffer

use crate::buffer::{AppMode, Buffer, FilterState, FuzzyFilterState, SearchState};
use crate::state::events::{StateChange, StateEvent};
use crate::ui::state::shadow_state::SearchType;
use tracing::{debug, info};

/// Trait for coordinating state changes
pub trait StateCoordinator {
    /// Process a state event and return changes to apply
    fn process_event(&self, event: &StateEvent) -> StateChange;

    /// Apply a state change to the buffer
    fn apply_change(&mut self, change: StateChange);

    /// Emit an event (for notification)
    fn emit_event(&self, event: StateEvent);
}

impl StateCoordinator for Buffer {
    fn process_event(&self, event: &StateEvent) -> StateChange {
        match event {
            StateEvent::ModeChanged { from, to } => self.process_mode_change(from, to),
            StateEvent::SearchStarted { search_type } => self.process_search_start(search_type),
            StateEvent::SearchEnded { search_type } => self.process_search_end(search_type),
            _ => StateChange::default(),
        }
    }

    fn apply_change(&mut self, change: StateChange) {
        debug!("Buffer applying state change: {:?}", change);

        if let Some(mode) = change.mode {
            self.mode = mode;
        }

        if change.clear_all_searches {
            info!("Buffer: Clearing all search states");
            self.search_state = SearchState::default();
            self.filter_state = FilterState::default();
            self.fuzzy_filter_state = FuzzyFilterState::default();
        } else {
            if let Some(search) = change.search_state {
                self.search_state = search;
            }
            if let Some(filter) = change.filter_state {
                self.filter_state = filter;
            }
            if let Some(fuzzy) = change.fuzzy_filter_state {
                self.fuzzy_filter_state = fuzzy;
            }
        }
    }

    fn emit_event(&self, event: StateEvent) {
        // This will be connected to the dispatcher
        debug!("Buffer emitting event: {:?}", event);
    }
}

impl Buffer {
    /// Process mode change and determine required state changes
    fn process_mode_change(&self, from: &AppMode, to: &AppMode) -> StateChange {
        debug!("Processing mode change: {:?} -> {:?}", from, to);

        match (from, to) {
            // Exiting any search mode to Results
            (
                AppMode::Search | AppMode::Filter | AppMode::FuzzyFilter | AppMode::ColumnSearch,
                AppMode::Results,
            ) => {
                info!("Exiting search mode -> clearing all searches");
                StateChange::clear_searches().and(StateChange::mode(AppMode::Results))
            }

            // Entering search mode from Results
            (AppMode::Results, AppMode::Search) => {
                // Clear other search types
                let mut change = StateChange::mode(AppMode::Search);
                change.filter_state = Some(FilterState::default());
                change.fuzzy_filter_state = Some(FuzzyFilterState::default());
                change
            }

            // Default mode change
            _ => StateChange::mode(to.clone()),
        }
    }

    /// Process search start event
    fn process_search_start(&self, search_type: &SearchType) -> StateChange {
        debug!("Processing search start: {:?}", search_type);

        match search_type {
            SearchType::Vim => {
                let mut change = StateChange::mode(AppMode::Search);
                // Clear other search types
                change.filter_state = Some(FilterState::default());
                change.fuzzy_filter_state = Some(FuzzyFilterState::default());
                change
            }
            SearchType::Column => StateChange::mode(AppMode::ColumnSearch),
            SearchType::Fuzzy => {
                let mut change = StateChange::mode(AppMode::FuzzyFilter);
                // Clear other search types
                change.search_state = Some(SearchState::default());
                change.filter_state = Some(FilterState::default());
                change
            }
            SearchType::Data => {
                let mut change = StateChange::mode(AppMode::Filter);
                // Clear other search types
                change.search_state = Some(SearchState::default());
                change.fuzzy_filter_state = Some(FuzzyFilterState::default());
                change
            }
        }
    }

    /// Process search end event
    fn process_search_end(&self, search_type: &SearchType) -> StateChange {
        info!("Processing search end: {:?}", search_type);

        // Clear the specific search type and return to Results
        match search_type {
            SearchType::Vim => {
                let mut change = StateChange::mode(AppMode::Results);
                change.search_state = Some(SearchState::default());
                change
            }
            SearchType::Column => StateChange::mode(AppMode::Results),
            SearchType::Fuzzy => {
                let mut change = StateChange::mode(AppMode::Results);
                change.fuzzy_filter_state = Some(FuzzyFilterState::default());
                change
            }
            SearchType::Data => {
                let mut change = StateChange::mode(AppMode::Results);
                change.filter_state = Some(FilterState::default());
                change
            }
        }
    }
}