shell-hist 0.2.0

A CLI tool for inspecting shell history
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
145
146
147
148
149

use std::env;
use std::path::PathBuf;
use structopt::StructOpt;
use regex::Regex;
use dirs::home_dir;
use crate::eject;

#[derive(StructOpt)]
pub struct Options {
    #[structopt(flatten)]
    pub display: DisplayOpts,

    #[structopt(flatten)]
    pub shell: ShellOpts,

    /// File to parse. Defaults to history file of selected or detected shell flavor
    #[structopt(short = "f", parse(from_os_str))]
    pub file: Option<PathBuf>,

    /// How many items to show
    #[structopt(short = "n", default_value = "10")]
    pub count: usize,
}


#[derive(StructOpt)]
pub struct DisplayOpts {
    /// Show fuzzy matched output. This is the default option.
    #[structopt(short="z", long="display-fuzzy")]
    pub fuzzy: bool,

    /// Show the most common exact commands
    #[structopt(short="e", long="display-exact")]
    pub exact: bool,

    /// Show the most common command components
    #[structopt(short="t", long="display-heat")]
    pub heat: bool,
}

#[derive(StructOpt)]
pub struct ShellOpts {
    /// Manually select ZSH history, overriding auto-detect
    #[structopt(long="flavor-zsh")]
    pub zsh: bool,

    /// Manually select Bash history, overriding auto-detect
    #[structopt(long="flavor-bash")]
    pub bash: bool,
}

#[derive(Copy, Clone)]
pub enum HistoryFlavor {
    Zsh,
    Bash,
}

impl ShellOpts {
    pub fn detect_shell() -> Option<HistoryFlavor> {
        const SHELL_MATCHES: &[(&str, HistoryFlavor)] = &[
            ("zsh", HistoryFlavor::Zsh),
            ("bash", HistoryFlavor::Bash),
        ];

        let shell_path = env::var("SHELL").ok()?;

        for (text, sh) in SHELL_MATCHES {
            if shell_path.contains(text) {
                return Some(*sh);
            }
        }

        None
    }

    pub fn validate(self) -> HistoryFlavor {
        match (self.zsh, self.bash) {
            (false, false) => {
                if let Some(sh) = Self::detect_shell() {
                    sh
                } else {
                    eject("Unable to detect shell, please manually select a shell flavor");
                }
            },
            (true, false) => HistoryFlavor::Zsh,
            (false, true) => HistoryFlavor::Bash,
            (true, true) => {
                eject("Multiple shell modes selected, please select one or none");
            }
        }
    }
}

impl HistoryFlavor {
    pub fn history_path(&self) -> PathBuf {
        use HistoryFlavor::*;
        let name = match self {
            Zsh => {
                ".zsh_history"
            },
            Bash => {
                ".bash_history"
            }
        };

        let mut dir = home_dir().unwrap_or_else(|| {
            eject("Unable to determine home path. Please specify history file path");
        });
        dir.push(name);
        dir
    }

    pub fn regex_and_capture_idx(&self) -> (Regex, usize) {
        use HistoryFlavor::*;
        let (re_res, idx) = match self {
            Zsh => {
                (Regex::new(r"^.*;(sudo )?(.*)$"), 2)
            },
            Bash => {
                (Regex::new(r"^(sudo )?(.*)$"), 2)
            }
        };

        (
            re_res.unwrap_or_else(|_| eject("Failed to compile regex!")),
            idx
        )
    }
}

pub enum DisplayMode {
    Fuzzy,
    Exact,
    Heat,
}

impl DisplayOpts {
    pub fn validate(self) -> DisplayMode {
        match (self.fuzzy, self.exact, self.heat) {
            (false, false, false) => DisplayMode::Fuzzy,
            (true, false, false) => DisplayMode::Fuzzy,
            (false, true, false) => DisplayMode::Exact,
            (false, false, true) => DisplayMode::Heat,
            _ => {
                eject("Multiple display modes selected, please select one or none");
            }
        }
    }
}