jj_cli/
ui.rs

1// Copyright 2020 The Jujutsu Authors
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// https://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use std::env;
16use std::error;
17use std::fmt;
18use std::io;
19use std::io::IsTerminal as _;
20use std::io::Stderr;
21use std::io::StderrLock;
22use std::io::Stdout;
23use std::io::StdoutLock;
24use std::io::Write;
25use std::iter;
26use std::mem;
27use std::process::Child;
28use std::process::ChildStdin;
29use std::process::Stdio;
30use std::thread;
31use std::thread::JoinHandle;
32
33use itertools::Itertools as _;
34use jj_lib::config::ConfigGetError;
35use jj_lib::config::StackedConfig;
36use os_pipe::PipeWriter;
37use tracing::instrument;
38
39use crate::command_error::CommandError;
40use crate::config::CommandNameAndArgs;
41use crate::formatter::Formatter;
42use crate::formatter::FormatterFactory;
43use crate::formatter::HeadingLabeledWriter;
44use crate::formatter::LabeledWriter;
45use crate::formatter::PlainTextFormatter;
46
47const BUILTIN_PAGER_NAME: &str = ":builtin";
48
49enum UiOutput {
50    Terminal {
51        stdout: Stdout,
52        stderr: Stderr,
53    },
54    Paged {
55        child: Child,
56        child_stdin: ChildStdin,
57    },
58    BuiltinPaged {
59        out_wr: PipeWriter,
60        err_wr: PipeWriter,
61        pager_thread: JoinHandle<streampager::Result<()>>,
62    },
63    Null,
64}
65
66impl UiOutput {
67    fn new_terminal() -> UiOutput {
68        UiOutput::Terminal {
69            stdout: io::stdout(),
70            stderr: io::stderr(),
71        }
72    }
73
74    fn new_paged(pager_cmd: &CommandNameAndArgs) -> io::Result<UiOutput> {
75        let mut cmd = pager_cmd.to_command();
76        tracing::info!(?cmd, "spawning pager");
77        let mut child = cmd.stdin(Stdio::piped()).spawn()?;
78        let child_stdin = child.stdin.take().unwrap();
79        Ok(UiOutput::Paged { child, child_stdin })
80    }
81
82    fn new_builtin_paged(config: &StreampagerConfig) -> streampager::Result<UiOutput> {
83        let streampager_config = streampager::config::Config {
84            wrapping_mode: config.wrapping.into(),
85            interface_mode: config.streampager_interface_mode(),
86            show_ruler: config.show_ruler,
87            // We could make scroll-past-eof configurable, but I'm guessing people
88            // will not miss it. If we do make it configurable, we should mention
89            // that it's a bad idea to turn this on if `interface=quit-if-one-page`,
90            // as it can leave a lot of empty lines on the screen after exiting.
91            scroll_past_eof: false,
92            ..Default::default()
93        };
94        let mut pager = streampager::Pager::new_using_stdio_with_config(streampager_config)?;
95
96        // Use native pipe, which can be attached to child process. The stdout
97        // stream could be an in-process channel, but the cost of extra syscalls
98        // wouldn't matter.
99        let (out_rd, out_wr) = os_pipe::pipe()?;
100        let (err_rd, err_wr) = os_pipe::pipe()?;
101        pager.add_stream(out_rd, "")?;
102        pager.add_error_stream(err_rd, "stderr")?;
103
104        Ok(UiOutput::BuiltinPaged {
105            out_wr,
106            err_wr,
107            pager_thread: thread::spawn(|| pager.run()),
108        })
109    }
110
111    fn finalize(self, ui: &Ui) {
112        match self {
113            UiOutput::Terminal { .. } => { /* no-op */ }
114            UiOutput::Paged {
115                mut child,
116                child_stdin,
117            } => {
118                drop(child_stdin);
119                if let Err(err) = child.wait() {
120                    // It's possible (though unlikely) that this write fails, but
121                    // this function gets called so late that there's not much we
122                    // can do about it.
123                    writeln!(
124                        ui.warning_default(),
125                        "Failed to wait on pager: {err}",
126                        err = format_error_with_sources(&err),
127                    )
128                    .ok();
129                }
130            }
131            UiOutput::BuiltinPaged {
132                out_wr,
133                err_wr,
134                pager_thread,
135            } => {
136                drop(out_wr);
137                drop(err_wr);
138                match pager_thread.join() {
139                    Ok(Ok(())) => {}
140                    Ok(Err(err)) => {
141                        writeln!(
142                            ui.warning_default(),
143                            "Failed to run builtin pager: {err}",
144                            err = format_error_with_sources(&err),
145                        )
146                        .ok();
147                    }
148                    Err(_) => {
149                        writeln!(ui.warning_default(), "Builtin pager crashed.").ok();
150                    }
151                }
152            }
153            UiOutput::Null => {}
154        }
155    }
156}
157
158pub enum UiStdout<'a> {
159    Terminal(StdoutLock<'static>),
160    Paged(&'a ChildStdin),
161    Builtin(&'a PipeWriter),
162    Null(io::Sink),
163}
164
165pub enum UiStderr<'a> {
166    Terminal(StderrLock<'static>),
167    Paged(&'a ChildStdin),
168    Builtin(&'a PipeWriter),
169    Null(io::Sink),
170}
171
172macro_rules! for_outputs {
173    ($ty:ident, $output:expr, $pat:pat => $expr:expr) => {
174        match $output {
175            $ty::Terminal($pat) => $expr,
176            $ty::Paged($pat) => $expr,
177            $ty::Builtin($pat) => $expr,
178            $ty::Null($pat) => $expr,
179        }
180    };
181}
182
183impl Write for UiStdout<'_> {
184    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
185        for_outputs!(Self, self, w => w.write(buf))
186    }
187
188    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
189        for_outputs!(Self, self, w => w.write_all(buf))
190    }
191
192    fn flush(&mut self) -> io::Result<()> {
193        for_outputs!(Self, self, w => w.flush())
194    }
195}
196
197impl Write for UiStderr<'_> {
198    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
199        for_outputs!(Self, self, w => w.write(buf))
200    }
201
202    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
203        for_outputs!(Self, self, w => w.write_all(buf))
204    }
205
206    fn flush(&mut self) -> io::Result<()> {
207        for_outputs!(Self, self, w => w.flush())
208    }
209}
210
211pub struct Ui {
212    quiet: bool,
213    pager: PagerConfig,
214    progress_indicator: bool,
215    formatter_factory: FormatterFactory,
216    output: UiOutput,
217}
218
219#[derive(Clone, Copy, Debug, Eq, PartialEq, serde::Deserialize, clap::ValueEnum)]
220#[serde(rename_all = "kebab-case")]
221pub enum ColorChoice {
222    Always,
223    Never,
224    Debug,
225    Auto,
226}
227
228impl fmt::Display for ColorChoice {
229    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
230        let s = match self {
231            ColorChoice::Always => "always",
232            ColorChoice::Never => "never",
233            ColorChoice::Debug => "debug",
234            ColorChoice::Auto => "auto",
235        };
236        write!(f, "{s}")
237    }
238}
239
240fn prepare_formatter_factory(
241    config: &StackedConfig,
242    stdout: &Stdout,
243) -> Result<FormatterFactory, ConfigGetError> {
244    let terminal = stdout.is_terminal();
245    let (color, debug) = match config.get("ui.color")? {
246        ColorChoice::Always => (true, false),
247        ColorChoice::Never => (false, false),
248        ColorChoice::Debug => (true, true),
249        ColorChoice::Auto => (terminal, false),
250    };
251    if color {
252        FormatterFactory::color(config, debug)
253    } else if terminal {
254        // Sanitize ANSI escape codes if we're printing to a terminal. Doesn't
255        // affect ANSI escape codes that originate from the formatter itself.
256        Ok(FormatterFactory::sanitized())
257    } else {
258        Ok(FormatterFactory::plain_text())
259    }
260}
261
262#[derive(Clone, Copy, Debug, Eq, PartialEq, serde::Deserialize)]
263#[serde(rename_all(deserialize = "kebab-case"))]
264pub enum PaginationChoice {
265    Never,
266    Auto,
267}
268
269#[derive(Clone, Copy, Debug, Eq, PartialEq, serde::Deserialize)]
270#[serde(rename_all(deserialize = "kebab-case"))]
271pub enum StreampagerAlternateScreenMode {
272    QuitIfOnePage,
273    FullScreenClearOutput,
274    QuitQuicklyOrClearOutput,
275}
276
277#[derive(Clone, Copy, Debug, Eq, PartialEq, serde::Deserialize)]
278#[serde(rename_all(deserialize = "kebab-case"))]
279enum StreampagerWrappingMode {
280    None,
281    Word,
282    Anywhere,
283}
284
285impl From<StreampagerWrappingMode> for streampager::config::WrappingMode {
286    fn from(val: StreampagerWrappingMode) -> Self {
287        use streampager::config::WrappingMode;
288        match val {
289            StreampagerWrappingMode::None => WrappingMode::Unwrapped,
290            StreampagerWrappingMode::Word => WrappingMode::WordBoundary,
291            StreampagerWrappingMode::Anywhere => WrappingMode::GraphemeBoundary,
292        }
293    }
294}
295
296#[derive(Clone, Copy, Debug, Eq, PartialEq, serde::Deserialize)]
297#[serde(rename_all(deserialize = "kebab-case"))]
298struct StreampagerConfig {
299    interface: StreampagerAlternateScreenMode,
300    wrapping: StreampagerWrappingMode,
301    show_ruler: bool,
302    // TODO: Add an `quit-quickly-delay-seconds` floating point option or a
303    // `quit-quickly-delay` option that takes a 's' or 'ms' suffix. Note that as
304    // of this writing, floating point numbers do not work with `--config`
305}
306
307impl StreampagerConfig {
308    fn streampager_interface_mode(&self) -> streampager::config::InterfaceMode {
309        use streampager::config::InterfaceMode;
310        use StreampagerAlternateScreenMode::*;
311        match self.interface {
312            // InterfaceMode::Direct not implemented
313            FullScreenClearOutput => InterfaceMode::FullScreen,
314            QuitIfOnePage => InterfaceMode::Hybrid,
315            QuitQuicklyOrClearOutput => InterfaceMode::Delayed(std::time::Duration::from_secs(2)),
316        }
317    }
318}
319
320enum PagerConfig {
321    Disabled,
322    Builtin(StreampagerConfig),
323    External(CommandNameAndArgs),
324}
325
326impl PagerConfig {
327    fn from_config(config: &StackedConfig) -> Result<PagerConfig, ConfigGetError> {
328        if matches!(config.get("ui.paginate")?, PaginationChoice::Never) {
329            return Ok(PagerConfig::Disabled);
330        };
331        let args: CommandNameAndArgs = config.get("ui.pager")?;
332        if args.as_str() == Some(BUILTIN_PAGER_NAME) {
333            Ok(PagerConfig::Builtin(config.get("ui.streampager")?))
334        } else {
335            Ok(PagerConfig::External(args))
336        }
337    }
338}
339
340impl Ui {
341    pub fn null() -> Ui {
342        Ui {
343            quiet: true,
344            pager: PagerConfig::Disabled,
345            progress_indicator: false,
346            formatter_factory: FormatterFactory::plain_text(),
347            output: UiOutput::Null,
348        }
349    }
350
351    pub fn with_config(config: &StackedConfig) -> Result<Ui, CommandError> {
352        let formatter_factory = prepare_formatter_factory(config, &io::stdout())?;
353        Ok(Ui {
354            quiet: config.get("ui.quiet")?,
355            formatter_factory,
356            pager: PagerConfig::from_config(config)?,
357            progress_indicator: config.get("ui.progress-indicator")?,
358            output: UiOutput::new_terminal(),
359        })
360    }
361
362    pub fn reset(&mut self, config: &StackedConfig) -> Result<(), CommandError> {
363        self.quiet = config.get("ui.quiet")?;
364        self.pager = PagerConfig::from_config(config)?;
365        self.progress_indicator = config.get("ui.progress-indicator")?;
366        self.formatter_factory = prepare_formatter_factory(config, &io::stdout())?;
367        Ok(())
368    }
369
370    /// Switches the output to use the pager, if allowed.
371    #[instrument(skip_all)]
372    pub fn request_pager(&mut self) {
373        if !matches!(&self.output, UiOutput::Terminal { stdout, .. } if stdout.is_terminal()) {
374            return;
375        }
376
377        let new_output = match &self.pager {
378            PagerConfig::Disabled => {
379                return;
380            }
381            PagerConfig::Builtin(streampager_config) => {
382                UiOutput::new_builtin_paged(streampager_config)
383                    .inspect_err(|err| {
384                        writeln!(
385                            self.warning_default(),
386                            "Failed to set up builtin pager: {err}",
387                            err = format_error_with_sources(err),
388                        )
389                        .ok();
390                    })
391                    .ok()
392            }
393            PagerConfig::External(command_name_and_args) => {
394                UiOutput::new_paged(command_name_and_args)
395                    .inspect_err(|err| {
396                        // The pager executable couldn't be found or couldn't be run
397                        writeln!(
398                            self.warning_default(),
399                            "Failed to spawn pager '{name}': {err}",
400                            name = command_name_and_args.split_name(),
401                            err = format_error_with_sources(err),
402                        )
403                        .ok();
404                        writeln!(self.hint_default(), "Consider using the `:builtin` pager.").ok();
405                    })
406                    .ok()
407            }
408        };
409        if let Some(output) = new_output {
410            self.output = output;
411        }
412    }
413
414    pub fn color(&self) -> bool {
415        self.formatter_factory.is_color()
416    }
417
418    pub fn new_formatter<'output, W: Write + 'output>(
419        &self,
420        output: W,
421    ) -> Box<dyn Formatter + 'output> {
422        self.formatter_factory.new_formatter(output)
423    }
424
425    /// Locked stdout stream.
426    pub fn stdout(&self) -> UiStdout<'_> {
427        match &self.output {
428            UiOutput::Terminal { stdout, .. } => UiStdout::Terminal(stdout.lock()),
429            UiOutput::Paged { child_stdin, .. } => UiStdout::Paged(child_stdin),
430            UiOutput::BuiltinPaged { out_wr, .. } => UiStdout::Builtin(out_wr),
431            UiOutput::Null => UiStdout::Null(io::sink()),
432        }
433    }
434
435    /// Creates a formatter for the locked stdout stream.
436    ///
437    /// Labels added to the returned formatter should be removed by caller.
438    /// Otherwise the last color would persist.
439    pub fn stdout_formatter(&self) -> Box<dyn Formatter + '_> {
440        for_outputs!(UiStdout, self.stdout(), w => self.new_formatter(w))
441    }
442
443    /// Locked stderr stream.
444    pub fn stderr(&self) -> UiStderr<'_> {
445        match &self.output {
446            UiOutput::Terminal { stderr, .. } => UiStderr::Terminal(stderr.lock()),
447            UiOutput::Paged { child_stdin, .. } => UiStderr::Paged(child_stdin),
448            UiOutput::BuiltinPaged { err_wr, .. } => UiStderr::Builtin(err_wr),
449            UiOutput::Null => UiStderr::Null(io::sink()),
450        }
451    }
452
453    /// Creates a formatter for the locked stderr stream.
454    pub fn stderr_formatter(&self) -> Box<dyn Formatter + '_> {
455        for_outputs!(UiStderr, self.stderr(), w => self.new_formatter(w))
456    }
457
458    /// Stderr stream to be attached to a child process.
459    pub fn stderr_for_child(&self) -> io::Result<Stdio> {
460        match &self.output {
461            UiOutput::Terminal { .. } => Ok(Stdio::inherit()),
462            UiOutput::Paged { child_stdin, .. } => Ok(duplicate_child_stdin(child_stdin)?.into()),
463            UiOutput::BuiltinPaged { err_wr, .. } => Ok(err_wr.try_clone()?.into()),
464            UiOutput::Null => Ok(Stdio::null()),
465        }
466    }
467
468    /// Whether continuous feedback should be displayed for long-running
469    /// operations
470    pub fn use_progress_indicator(&self) -> bool {
471        match &self.output {
472            UiOutput::Terminal { stderr, .. } => self.progress_indicator && stderr.is_terminal(),
473            UiOutput::Paged { .. } => false,
474            UiOutput::BuiltinPaged { .. } => false,
475            UiOutput::Null => false,
476        }
477    }
478
479    pub fn progress_output(&self) -> Option<ProgressOutput<std::io::Stderr>> {
480        self.use_progress_indicator()
481            .then(ProgressOutput::for_stderr)
482    }
483
484    /// Writer to print an update that's not part of the command's main output.
485    pub fn status(&self) -> Box<dyn Write + '_> {
486        if self.quiet {
487            Box::new(io::sink())
488        } else {
489            Box::new(self.stderr())
490        }
491    }
492
493    /// A formatter to print an update that's not part of the command's main
494    /// output. Returns `None` if `--quiet` was requested.
495    pub fn status_formatter(&self) -> Option<Box<dyn Formatter + '_>> {
496        (!self.quiet).then(|| self.stderr_formatter())
497    }
498
499    /// Writer to print hint with the default "Hint: " heading.
500    pub fn hint_default(
501        &self,
502    ) -> HeadingLabeledWriter<Box<dyn Formatter + '_>, &'static str, &'static str> {
503        self.hint_with_heading("Hint: ")
504    }
505
506    /// Writer to print hint without the "Hint: " heading.
507    pub fn hint_no_heading(&self) -> LabeledWriter<Box<dyn Formatter + '_>, &'static str> {
508        let formatter = self
509            .status_formatter()
510            .unwrap_or_else(|| Box::new(PlainTextFormatter::new(io::sink())));
511        LabeledWriter::new(formatter, "hint")
512    }
513
514    /// Writer to print hint with the given heading.
515    pub fn hint_with_heading<H: fmt::Display>(
516        &self,
517        heading: H,
518    ) -> HeadingLabeledWriter<Box<dyn Formatter + '_>, &'static str, H> {
519        self.hint_no_heading().with_heading(heading)
520    }
521
522    /// Writer to print warning with the default "Warning: " heading.
523    pub fn warning_default(
524        &self,
525    ) -> HeadingLabeledWriter<Box<dyn Formatter + '_>, &'static str, &'static str> {
526        self.warning_with_heading("Warning: ")
527    }
528
529    /// Writer to print warning without the "Warning: " heading.
530    pub fn warning_no_heading(&self) -> LabeledWriter<Box<dyn Formatter + '_>, &'static str> {
531        LabeledWriter::new(self.stderr_formatter(), "warning")
532    }
533
534    /// Writer to print warning with the given heading.
535    pub fn warning_with_heading<H: fmt::Display>(
536        &self,
537        heading: H,
538    ) -> HeadingLabeledWriter<Box<dyn Formatter + '_>, &'static str, H> {
539        self.warning_no_heading().with_heading(heading)
540    }
541
542    /// Writer to print error without the "Error: " heading.
543    pub fn error_no_heading(&self) -> LabeledWriter<Box<dyn Formatter + '_>, &'static str> {
544        LabeledWriter::new(self.stderr_formatter(), "error")
545    }
546
547    /// Writer to print error with the given heading.
548    pub fn error_with_heading<H: fmt::Display>(
549        &self,
550        heading: H,
551    ) -> HeadingLabeledWriter<Box<dyn Formatter + '_>, &'static str, H> {
552        self.error_no_heading().with_heading(heading)
553    }
554
555    /// Waits for the pager exits.
556    #[instrument(skip_all)]
557    pub fn finalize_pager(&mut self) {
558        let old_output = mem::replace(&mut self.output, UiOutput::new_terminal());
559        old_output.finalize(self);
560    }
561
562    pub fn can_prompt() -> bool {
563        io::stderr().is_terminal()
564            || env::var("JJ_INTERACTIVE")
565                .map(|v| v == "1")
566                .unwrap_or(false)
567    }
568
569    pub fn prompt(&self, prompt: &str) -> io::Result<String> {
570        if !Self::can_prompt() {
571            return Err(io::Error::new(
572                io::ErrorKind::Unsupported,
573                "Cannot prompt for input since the output is not connected to a terminal",
574            ));
575        }
576        write!(self.stderr(), "{prompt}: ")?;
577        self.stderr().flush()?;
578        let mut buf = String::new();
579        io::stdin().read_line(&mut buf)?;
580
581        if buf.is_empty() {
582            return Err(io::Error::new(
583                io::ErrorKind::UnexpectedEof,
584                "Prompt cancelled by EOF",
585            ));
586        }
587
588        if let Some(trimmed) = buf.strip_suffix('\n') {
589            buf.truncate(trimmed.len());
590        }
591        Ok(buf)
592    }
593
594    /// Repeat the given prompt until the input is one of the specified choices.
595    /// Returns the index of the choice.
596    pub fn prompt_choice(
597        &self,
598        prompt: &str,
599        choices: &[impl AsRef<str>],
600        default_index: Option<usize>,
601    ) -> io::Result<usize> {
602        self.prompt_choice_with(
603            prompt,
604            default_index.map(|index| {
605                choices
606                    .get(index)
607                    .expect("default_index should be within range")
608                    .as_ref()
609            }),
610            |input| {
611                choices
612                    .iter()
613                    .position(|c| input == c.as_ref())
614                    .ok_or("unrecognized response")
615            },
616        )
617    }
618
619    /// Prompts for a yes-or-no response, with yes = true and no = false.
620    pub fn prompt_yes_no(&self, prompt: &str, default: Option<bool>) -> io::Result<bool> {
621        let default_str = match &default {
622            Some(true) => "(Yn)",
623            Some(false) => "(yN)",
624            None => "(yn)",
625        };
626        self.prompt_choice_with(
627            &format!("{prompt} {default_str}"),
628            default.map(|v| if v { "y" } else { "n" }),
629            |input| {
630                if input.eq_ignore_ascii_case("y") || input.eq_ignore_ascii_case("yes") {
631                    Ok(true)
632                } else if input.eq_ignore_ascii_case("n") || input.eq_ignore_ascii_case("no") {
633                    Ok(false)
634                } else {
635                    Err("unrecognized response")
636                }
637            },
638        )
639    }
640
641    /// Repeats the given prompt until `parse(input)` returns a value.
642    ///
643    /// If the default `text` is given, an empty input will be mapped to it. It
644    /// will also be used in non-interactive session. The default `text` must
645    /// be parsable. If no default is given, this function will fail in
646    /// non-interactive session.
647    pub fn prompt_choice_with<T, E: fmt::Debug + fmt::Display>(
648        &self,
649        prompt: &str,
650        default: Option<&str>,
651        mut parse: impl FnMut(&str) -> Result<T, E>,
652    ) -> io::Result<T> {
653        // Parse the default to ensure that the text is valid.
654        let default = default.map(|text| (parse(text).expect("default should be valid"), text));
655
656        if !Self::can_prompt() {
657            if let Some((value, text)) = default {
658                // Choose the default automatically without waiting.
659                writeln!(self.stderr(), "{prompt}: {text}")?;
660                return Ok(value);
661            }
662        }
663
664        loop {
665            let input = self.prompt(prompt)?;
666            let input = input.trim();
667            if input.is_empty() {
668                if let Some((value, _)) = default {
669                    return Ok(value);
670                } else {
671                    continue;
672                }
673            }
674            match parse(input) {
675                Ok(value) => return Ok(value),
676                Err(err) => writeln!(self.warning_no_heading(), "{err}")?,
677            }
678        }
679    }
680
681    pub fn prompt_password(&self, prompt: &str) -> io::Result<String> {
682        if !io::stdout().is_terminal() {
683            return Err(io::Error::new(
684                io::ErrorKind::Unsupported,
685                "Cannot prompt for input since the output is not connected to a terminal",
686            ));
687        }
688        rpassword::prompt_password(format!("{prompt}: "))
689    }
690
691    pub fn term_width(&self) -> usize {
692        term_width().unwrap_or(80).into()
693    }
694}
695
696#[derive(Debug)]
697pub struct ProgressOutput<W> {
698    output: W,
699    term_width: Option<u16>,
700}
701
702impl ProgressOutput<io::Stderr> {
703    pub fn for_stderr() -> ProgressOutput<io::Stderr> {
704        ProgressOutput {
705            output: io::stderr(),
706            term_width: None,
707        }
708    }
709}
710
711impl<W> ProgressOutput<W> {
712    pub fn for_test(output: W, term_width: u16) -> Self {
713        Self {
714            output,
715            term_width: Some(term_width),
716        }
717    }
718
719    pub fn term_width(&self) -> Option<u16> {
720        // Terminal can be resized while progress is displayed, so don't cache it.
721        self.term_width.or_else(term_width)
722    }
723
724    /// Construct a guard object which writes `text` when dropped. Useful for
725    /// restoring terminal state.
726    pub fn output_guard(&self, text: String) -> OutputGuard {
727        OutputGuard {
728            text,
729            output: io::stderr(),
730        }
731    }
732}
733
734impl<W: Write> ProgressOutput<W> {
735    pub fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
736        self.output.write_fmt(fmt)
737    }
738
739    pub fn flush(&mut self) -> io::Result<()> {
740        self.output.flush()
741    }
742}
743
744pub struct OutputGuard {
745    text: String,
746    output: Stderr,
747}
748
749impl Drop for OutputGuard {
750    #[instrument(skip_all)]
751    fn drop(&mut self) {
752        _ = self.output.write_all(self.text.as_bytes());
753        _ = self.output.flush();
754    }
755}
756
757#[cfg(unix)]
758fn duplicate_child_stdin(stdin: &ChildStdin) -> io::Result<std::os::fd::OwnedFd> {
759    use std::os::fd::AsFd as _;
760    stdin.as_fd().try_clone_to_owned()
761}
762
763#[cfg(windows)]
764fn duplicate_child_stdin(stdin: &ChildStdin) -> io::Result<std::os::windows::io::OwnedHandle> {
765    use std::os::windows::io::AsHandle as _;
766    stdin.as_handle().try_clone_to_owned()
767}
768
769fn format_error_with_sources(err: &dyn error::Error) -> impl fmt::Display + use<'_> {
770    iter::successors(Some(err), |&err| err.source()).format(": ")
771}
772
773fn term_width() -> Option<u16> {
774    if let Some(cols) = env::var("COLUMNS").ok().and_then(|s| s.parse().ok()) {
775        Some(cols)
776    } else {
777        crossterm::terminal::size().ok().map(|(cols, _)| cols)
778    }
779}
jj_cli/ui.rs

jj_cli/
ui.rs
