sequoia-sq 1.4.0

Command-line frontends for Sequoia
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
150

//! Formats hints for users.

use std::fmt;
use std::io::IsTerminal;
use std::io::Write;

/// Formats a hint for the user.
pub struct Hint {
    /// Whether to suppress printing the hint.
    quiet: bool,

    /// Whether this is the first hint in this hint block.
    first: bool,
}

impl Hint {
    /// Constructs a new hint, optionally suppressing it.
    pub fn new(quiet: bool) -> Self {
        Hint {
            quiet,
            first: true,
        }
    }

    /// Displays a message to the user.
    ///
    /// It will be prefixed with "Hint: ", and should either end in a
    /// full stop or colon, depending on whether or not a command hint
    /// follows.
    pub fn hint(mut self, msg: fmt::Arguments) -> Self {
        if ! self.quiet {
            weprintln!();
            weprintln!(
                initial_indent=if self.first { "Hint: " } else { "      " },
                subsequent_indent="      ",
                "{}", msg);
            self.first = false;
        }
        self
    }

    /// Suggests an `sq` command to the user.
    pub fn sq(self) -> Command {
        Command::new(self, "sq")
    }

    /// Suggests a free-form command to the user.
    ///
    /// Note: if you want to suggest an `sq` invocation, use
    /// [`Hint::sq`] instead.
    pub fn command(self, argv0: &str) -> Command {
        Command::new(self, argv0)
    }
}

/// A structured command hint.
pub struct Command {
    hint: Hint,
    args: Vec<(String, Option<String>)>,
}

impl Command {
    fn new(hint: Hint, argv0: &str) -> Self {
        Command {
            hint,
            args: vec![(argv0.into(), None)],
        }
    }

    /// Adds `arg` to the command.
    pub fn arg<S: ToString>(mut self, arg: S) -> Self {
        self.args.push((arg.to_string(), None));
        self
    }

    /// Adds `arg` to the command, but show the user the replacement.
    pub fn arg_hidden<S: ToString, R: ToString>(
        mut self, arg: S, replacement: R)
        -> Self
    {
        self.args.push((arg.to_string(), Some(replacement.to_string())));
        self
    }

    /// Adds an argument `arg` with value to the command.
    pub fn arg_value<S: ToString, V: ToString>(mut self, arg: S, value: V)
                                               -> Self
    {
        self.args.push(
            (format!("{}={}", arg.to_string(), value.to_string()),
             None));
        self
    }

    /// Adds an argument `arg` with value to the command, but show the
    /// user the replacement value.
    pub fn arg_value_hidden<S: ToString, V: ToString, R: ToString>(
        mut self, arg: S, value: V, replacement_value: R)
        -> Self
    {
        self.args.push(
            (format!("{}={}", arg.to_string(), value.to_string()),
             Some(format!("{}={}",
                          arg.to_string(),
                          replacement_value.to_string()))));
        self
    }

    /// Emits the command hint.
    pub fn done(self) -> Hint {
        if ! self.hint.quiet {
            // If we're connected to a terminal, flush stdout to
            // reduce the chance of incorrectly interleaving output
            // and hints.
            let mut stdout = std::io::stdout();
            if stdout.is_terminal() {
                // Best effort.
                let _ = stdout.flush();
            }

            let width = crate::output::wrapping::stderr_terminal_width();

            let args = self.args.iter()
                .map(|(arg, replacement)| {
                    if let Some(replacement) = replacement {
                        replacement
                    } else {
                        arg
                    }
                })
                .collect::<Vec<_>>();

            eprintln!();
            eprintln!("{}", crate::cli::examples::wrap_command(
                &args, &[], "  ", width, "    ", width));
        }

        if cfg!(debug_assertions) && self.args[0].0 == "sq" {
            let cli = crate::cli::build(false);

            if let Err(e)
                = cli.try_get_matches_from(self.args.iter().map(|(a, _)| a))
            {
                panic!("bad hint, parsing {}", e);
            }
        }

        self.hint
    }
}