rusht 1.1.0

Shell commands written in Rust
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

use ::clap::StructOpt;
use ::std::str::FromStr;

#[derive(StructOpt, Debug)]
#[structopt(
    name = "namesafe",
    about = "Convert each line to a string that is safe for names (no whitespace or special characters, not too long)."
)]
pub struct NamesafeArgs {
    /// Allow non-ascii letters (but no non-letter symbols).
    #[structopt(
        parse(from_flag = Charset::from_allow),
        short = 'u',
        long = "allow-unicode",
    )]
    pub charset: Charset,
    /// In which cases to include a hash in the name ([a]lways, [c]hanged, too-[l]ong, [n]ever).
    #[structopt(
        short = 'x',
        long = "hash",
        default_value = "changed",  //TODO @mverleg: not sure why Default impl doesn't work
    )]
    pub hash_policy: HashPolicy,
    /// Maximum number of characters in the cleaned line (min 8).
    #[structopt(short = 'l', long = "max-length", default_value = "32")]
    pub max_length: u32,
    /// If the line appears to contain an filename extension (max 4 chars), preserve it.
    #[structopt(short = 'e', long = "extension")]
    pub keep_extension: bool,
    /// If the command has to be shortened, keep the end part instead of the start.
    #[structopt(short = 'E', long = "keep-tail")]
    pub keep_tail: bool,
    /// Do not fail if there are no input lines.
    #[structopt(short = '0', long = "allow-empty")]
    pub allow_empty: bool,
    /// Expect exactly one input line. Fail if more. Fail if fewer unless --allow_empty.
    #[structopt(short = '1', long = "single")]
    pub single_line: bool,
}
//TODO @mverleg: when to hash? (always, if changed, if too long, never)

#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub enum HashPolicy {
    Always,
    #[default]
    Changed,
    TooLong,
    Never,
}

impl HashPolicy {
    pub fn should_hash(&self, was_changed: bool, was_too_long: bool) -> bool {
        match self {
            HashPolicy::Always => true,
            HashPolicy::Changed => was_changed || was_too_long,
            HashPolicy::TooLong => was_too_long,
            HashPolicy::Never => false,
        }
    }
}

impl FromStr for HashPolicy {
    type Err = String;

    fn from_str(text: &str) -> Result<Self, Self::Err> {
        Ok(match text.to_lowercase().as_str() {
            "always" | "a" => HashPolicy::Always,
            "changed" | "c" => HashPolicy::Changed,
            "too-long" | "long" | "l" => HashPolicy::TooLong,
            "never" | "n" => HashPolicy::Never,
            other => return Err(format!("unknown hash policy: {}", other)),
        })
    }
}

#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub enum Charset {
    AllowUnicode,
    #[default]
    AsciiOnly,
}

impl Charset {
    fn from_allow(allow_unicode: bool) -> Self {
        if allow_unicode {
            Charset::AllowUnicode
        } else {
            Charset::AsciiOnly
        }
    }

    pub fn is_allowed(&self, symbol: char) -> bool {
        match self {
            Charset::AllowUnicode => symbol.is_alphanumeric() || symbol == '-' || symbol == '_',
            Charset::AsciiOnly => {
                ('a'..='z').contains(&symbol)
                    || ('A'..='Z').contains(&symbol)
                    || ('0'..='9').contains(&symbol)
                    || symbol == '-'
                    || symbol == '_'
            }
        }
    }
}

impl Default for NamesafeArgs {
    fn default() -> Self {
        NamesafeArgs {
            charset: Default::default(),
            hash_policy: Default::default(),
            max_length: 32,
            keep_extension: false,
            keep_tail: false,
            allow_empty: false,
            single_line: false,
        }
    }
}

#[test]
fn test_cli_args() {
    use clap::IntoApp;
    NamesafeArgs::into_app().debug_assert()
}