sql_cli/ui/traits/
yank_ops.rs

1use crate::app_state_container::AppStateContainer;
2use crate::buffer::BufferAPI;
3use crate::handlers::YankHandler;
4use crate::ui::input::actions::{Action, YankTarget};
5// Arc import removed - no longer needed
6
7/// Trait that provides yank operation behavior for TUI components
8/// This extracts yank operations from `EnhancedTui` to reduce coupling
9pub trait YankBehavior {
10    // Required methods - these provide access to TUI internals
11    fn buffer(&self) -> &dyn BufferAPI;
12    fn buffer_mut(&mut self) -> &mut dyn BufferAPI;
13    fn state_container(&self) -> &AppStateContainer;
14    fn set_status_message(&mut self, message: String);
15    fn set_error_status(&mut self, prefix: &str, error: anyhow::Error);
16
17    // ========== Yank Operation Methods ==========
18
19    /// Yank the currently selected cell
20    fn yank_cell(&mut self) {
21        let action = Action::Yank(YankTarget::Cell);
22        let buffer = self.buffer();
23        let result = YankHandler::handle_yank_action(&action, buffer, self.state_container());
24
25        match result {
26            Ok(Some(message)) => {
27                self.set_status_message(message);
28            }
29            Ok(None) => {}
30            Err(e) => {
31                self.set_error_status("Failed to yank cell", e);
32            }
33        }
34    }
35
36    /// Yank the currently selected row
37    fn yank_row(&mut self) {
38        let action = Action::Yank(YankTarget::Row);
39        let buffer = self.buffer();
40        let result = YankHandler::handle_yank_action(&action, buffer, self.state_container());
41
42        match result {
43            Ok(Some(message)) => {
44                self.set_status_message(message);
45            }
46            Ok(None) => {}
47            Err(e) => {
48                self.set_error_status("Failed to yank row", e);
49            }
50        }
51    }
52
53    /// Yank the currently selected column
54    fn yank_column(&mut self) {
55        let action = Action::Yank(YankTarget::Column);
56        let buffer = self.buffer();
57        let result = YankHandler::handle_yank_action(&action, buffer, self.state_container());
58
59        match result {
60            Ok(Some(message)) => {
61                self.set_status_message(message);
62            }
63            Ok(None) => {}
64            Err(e) => {
65                self.set_error_status("Failed to yank column", e);
66            }
67        }
68    }
69
70    /// Yank all visible data
71    fn yank_all(&mut self) {
72        let action = Action::Yank(YankTarget::All);
73        let buffer = self.buffer();
74        let result = YankHandler::handle_yank_action(&action, buffer, self.state_container());
75
76        match result {
77            Ok(Some(message)) => {
78                self.set_status_message(message);
79            }
80            Ok(None) => {}
81            Err(e) => {
82                self.set_error_status("Failed to yank all", e);
83            }
84        }
85    }
86
87    /// Yank the current query
88    fn yank_query(&mut self) {
89        let action = Action::Yank(YankTarget::Query);
90        let buffer = self.buffer();
91        let result = YankHandler::handle_yank_action(&action, buffer, self.state_container());
92
93        match result {
94            Ok(Some(message)) => {
95                self.set_status_message(message);
96            }
97            Ok(None) => {}
98            Err(e) => {
99                self.set_error_status("Failed to yank query", e);
100            }
101        }
102    }
103
104    /// Yank current query and results as a complete test case (Ctrl+T in debug mode)
105    fn yank_as_test_case(&mut self) {
106        let buffer = self.buffer();
107        let result = YankHandler::handle_yank_as_test_case(buffer, self.state_container());
108
109        match result {
110            Ok(message) => {
111                self.set_status_message(message);
112            }
113            Err(e) => {
114                self.set_error_status("Failed to copy test case", e);
115            }
116        }
117    }
118
119    /// Yank debug dump with context for manual test creation (Shift+Y in debug mode)
120    fn yank_debug_with_context(&mut self) {
121        let buffer = self.buffer();
122        let result = YankHandler::handle_yank_debug_context(buffer, self.state_container());
123
124        match result {
125            Ok(message) => {
126                self.set_status_message(message);
127            }
128            Err(e) => {
129                self.set_error_status("Failed to copy debug context", e);
130            }
131        }
132    }
133}