Phase 5: Ausführung und Output implementieren und archivieren

crates/tb-ide/src/terminal.rs

@@ -1,109 +1 @@
-use crossterm::{
-    cursor::{Hide, Show},
-    event::{DisableBracketedPaste, DisableMouseCapture, EnableBracketedPaste, EnableMouseCapture},
-    execute,
-    style::ResetColor,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
-use std::io::{self, Write};
-
-/// Ein Besitzer für Raw Mode und Terminalzustand, auch bei teilweiser Initialisierung.
-pub struct TerminalGuard<W: Write> {
-    writer: W,
-    raw: fn(bool) -> io::Result<()>,
-}
-impl<W: Write> TerminalGuard<W> {
-    pub fn enter(writer: W) -> io::Result<Self> {
-        Self::with_raw(writer, |on| {
-            if on {
-                enable_raw_mode()
-            } else {
-                disable_raw_mode()
-            }
-        })
-    }
-    fn with_raw(writer: W, raw: fn(bool) -> io::Result<()>) -> io::Result<Self> {
-        let mut guard = Self { writer, raw };
-        (guard.raw)(true)?;
-        execute!(
-            guard.writer,
-            EnterAlternateScreen,
-            EnableMouseCapture,
-            EnableBracketedPaste,
-            Hide
-        )?;
-        Ok(guard)
-    }
-}
-impl<W: Write> Drop for TerminalGuard<W> {
-    fn drop(&mut self) {
-        let _ = (self.raw)(false);
-        let _ = execute!(
-            self.writer,
-            ResetColor,
-            Show,
-            DisableMouseCapture,
-            DisableBracketedPaste,
-            LeaveAlternateScreen
-        );
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::{
-        cell::RefCell,
-        rc::Rc,
-        sync::atomic::{AtomicI32, Ordering},
-    };
-    static RAW: AtomicI32 = AtomicI32::new(0);
-    #[derive(Clone)]
-    struct Output(Rc<RefCell<Vec<u8>>>);
-    impl Write for Output {
-        fn write(&mut self, b: &[u8]) -> io::Result<usize> {
-            self.0.borrow_mut().extend_from_slice(b);
-            Ok(b.len())
-        }
-        fn flush(&mut self) -> io::Result<()> {
-            Ok(())
-        }
-    }
-    fn raw(on: bool) -> io::Result<()> {
-        RAW.store(i32::from(on), Ordering::SeqCst);
-        Ok(())
-    }
-    #[test]
-    fn terminal_cleanup_on_normal_error_and_partial_initialization() {
-        for fail in [false, true] {
-            let out = Output(Rc::default());
-            let copy = out.clone();
-            let result = (|| -> io::Result<()> {
-                let _guard = TerminalGuard::with_raw(out, raw)?;
-                if fail {
-                    return Err(io::Error::other("Renderfehler"));
-                }
-                Ok(())
-            })();
-            assert_eq!(result.is_err(), fail);
-            assert_eq!(RAW.load(Ordering::SeqCst), 0);
-            let s = String::from_utf8(copy.0.borrow().clone()).unwrap();
-            assert!(s.contains("?1049h") && s.contains("?1049l") && s.contains("?25h"));
-        }
-        let out = Output(Rc::default());
-        let copy = out.clone();
-        assert!(TerminalGuard::with_raw(out, |on| {
-            raw(on)?;
-            if on {
-                Err(io::Error::other("Raw-Fehler"))
-            } else {
-                Ok(())
-            }
-        })
-        .is_err());
-        assert_eq!(RAW.load(Ordering::SeqCst), 0);
-        assert!(String::from_utf8(copy.0.borrow().clone())
-            .unwrap()
-            .contains("?25h"));
-    }
-}
+pub use tb_ui::terminal::TerminalGuard;