smv 0.4.2

Smart Move - An enhanced mv command with transformation capabilities
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

use std::io;
use std::panic;
use std::time::{Duration, Instant};

use crossterm::{
    event::{self, DisableMouseCapture, EnableMouseCapture, Event as CrosstermEvent},
    execute,
    terminal::{self, EnterAlternateScreen, LeaveAlternateScreen},
};
use ratatui::{Terminal, backend::CrosstermBackend};

use crate::ui::terminal::Event;

/// Terminal UI initialization and event handling
pub struct Tui {
    /// Terminal interface
    terminal: Terminal<CrosstermBackend<io::Stdout>>,
    /// Event tick rate
    tick_rate: Duration,
    /// Last tick instant
    last_tick: Instant,
}

impl Tui {
    /// Initialize a new terminal UI
    pub fn new() -> anyhow::Result<Self> {
        // Setup terminal
        terminal::enable_raw_mode()
            .map_err(|e| anyhow::anyhow!("Failed to enable raw mode: {}", e))?;

        let mut stdout = io::stdout();
        execute!(stdout, EnterAlternateScreen, EnableMouseCapture)
            .map_err(|e| anyhow::anyhow!("Failed to initialize terminal: {}", e))?;

        // Create terminal with crossterm backend
        let backend = CrosstermBackend::new(stdout);
        let mut terminal = Terminal::new(backend)
            .map_err(|e| anyhow::anyhow!("Failed to create terminal: {}", e))?;

        // Clear the screen and hide cursor
        terminal
            .clear()
            .map_err(|e| anyhow::anyhow!("Failed to clear terminal: {}", e))?;
        terminal
            .hide_cursor()
            .map_err(|e| anyhow::anyhow!("Failed to hide cursor: {}", e))?;

        // Create Tui instance
        let tick_rate = Duration::from_millis(100);

        Ok(Self {
            terminal,
            tick_rate,
            last_tick: Instant::now(),
        })
    }

    /// Restore terminal state on drop
    fn restore_terminal(&mut self) -> anyhow::Result<()> {
        // Restore cursor and clear screen
        self.terminal.show_cursor()?;
        self.terminal.clear()?;

        // Restore terminal state
        terminal::disable_raw_mode()?;
        execute!(
            self.terminal.backend_mut(),
            LeaveAlternateScreen,
            DisableMouseCapture
        )?;

        Ok(())
    }

    /// Set up terminal panic hook to restore terminal state
    pub fn init_panic_hook() {
        let original_hook = panic::take_hook();
        panic::set_hook(Box::new(move |panic_info| {
            // Restore terminal state
            let _ = terminal::disable_raw_mode();
            let _ = execute!(io::stdout(), LeaveAlternateScreen, DisableMouseCapture);

            // Call the original hook
            original_hook(panic_info);
        }));
    }

    /// Clean up the terminal
    pub fn exit(&mut self) -> anyhow::Result<()> {
        self.restore_terminal()?;
        Ok(())
    }

    /// Draw the terminal UI with the provided render function
    pub fn draw<F>(&mut self, render_fn: F) -> anyhow::Result<()>
    where
        F: FnOnce(&mut ratatui::Frame<'_>),
    {
        self.terminal.draw(render_fn)?;
        Ok(())
    }

    /// Check for events with timeout
    pub fn next_event(&mut self) -> anyhow::Result<Event> {
        let timeout = self
            .tick_rate
            .checked_sub(self.last_tick.elapsed())
            .unwrap_or_else(|| Duration::from_secs(0));

        if event::poll(timeout)? {
            // If an event is available, process it
            match event::read()? {
                CrosstermEvent::Key(key) => Ok(Event::Key(key)),
                CrosstermEvent::Resize(width, height) => Ok(Event::Resize(width, height)),
                _ => {
                    // Wait for the tick timeout
                    if self.last_tick.elapsed() >= self.tick_rate {
                        self.last_tick = Instant::now();
                        Ok(Event::Tick)
                    } else {
                        self.next_event()
                    }
                }
            }
        } else {
            // No event, check for tick
            if self.last_tick.elapsed() >= self.tick_rate {
                self.last_tick = Instant::now();
                Ok(Event::Tick)
            } else {
                self.next_event()
            }
        }
    }
}

impl Drop for Tui {
    fn drop(&mut self) {
        // Ensure cleanup on drop
        let _ = self.restore_terminal();
    }
}