gex 0.6.6

Git workflow improvement CLI tool inspired by Magit
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

//! Terminal commands related to rendering. These often just wrap commands from [`crossterm`].
//!
//! This exists because when resetting the terminal colours or clearing the screen we may have to
//! handle the case where the user has set custom FG/BG colours specially.

use std::fmt;

use crossterm::{
    cursor,
    style::{self, Color},
    terminal::{self, ClearType},
};

use crate::config;

/// See [`Clear`](`crossterm::terminal::Clear`).
pub struct Clear(pub ClearType);

impl fmt::Display for Clear {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match config!().colors.background {
            Color::Reset => write!(f, "{}", crossterm::terminal::Clear(self.0)),
            color => {
                let Ok((cols, rows)) = terminal::size() else {
                    return Err(fmt::Error);
                };

                write!(f, "{}", style::SetBackgroundColor(color))?;
                match self.0 {
                    ClearType::All => {
                        write!(f, "{}{}", cursor::SavePosition, cursor::MoveTo(0, 0))?;
                        for _ in 0..rows {
                            write!(f, "{:width$}", ' ', width = cols as usize)?;
                        }
                        write!(f, "{}", cursor::RestorePosition)
                    }
                    ClearType::Purge => write!(
                        f,
                        "{}{}",
                        crossterm::terminal::Clear(crossterm::terminal::ClearType::Purge),
                        Self(ClearType::All)
                    ),
                    ClearType::FromCursorDown => {
                        let Ok((_, row)) = cursor::position() else {
                            return Err(fmt::Error);
                        };
                        write!(
                            f,
                            "{}{}{}",
                            cursor::SavePosition,
                            cursor::MoveToColumn(0),
                            cursor::MoveToNextLine(1)
                        )?;
                        for _ in 0..rows - row - 1 {
                            write!(f, "{:width$}", ' ', width = cols as usize)?;
                        }
                        write!(f, "{}", cursor::RestorePosition)
                    }
                    ClearType::FromCursorUp => {
                        let Ok((_, row)) = cursor::position() else {
                            return Err(fmt::Error);
                        };
                        write!(f, "{}{}", cursor::SavePosition, cursor::MoveTo(0, 0))?;
                        for _ in 0..=row {
                            write!(f, "{:width$}", ' ', width = cols as usize)?;
                        }
                        write!(f, "{}", cursor::RestorePosition)
                    }
                    ClearType::CurrentLine => write!(
                        f,
                        "{}{:width$}{}",
                        cursor::MoveToColumn(0),
                        ' ',
                        cursor::MoveToColumn(0),
                        width = cols as usize
                    ),
                    ClearType::UntilNewLine => {
                        let Ok((col, _)) = cursor::position() else {
                            return Err(fmt::Error);
                        };
                        write!(
                            f,
                            "{:width$}{}",
                            ' ',
                            cursor::MoveToColumn(col),
                            width = (cols - col) as usize
                        )
                    }
                }
            }
        }
    }
}

/// See [`ResetColor`](`crossterm::style::ResetColor`).
pub struct ResetColor;

impl fmt::Display for ResetColor {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "{}{}",
            crossterm::style::SetForegroundColor(config!().colors.foreground),
            crossterm::style::SetBackgroundColor(config!().colors.background),
        )
    }
}

/// See [`Attribute`](`crossterm::style::Attribute`).
///
/// Simulates the `Reset` variant.
pub struct ResetAttributes;

impl fmt::Display for ResetAttributes {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}{}", crossterm::style::Attribute::Reset, ResetColor,)
    }
}