ok/jj
1
0
Fork 0
forked from mirrors/jj
jj/cli/src/ui.rs

391 lines
12 KiB
Rust

// Copyright 2020 The Jujutsu Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use std::io::{IsTerminal as _, Stderr, Stdout, Write};
use std::process::{Child, ChildStdin, Stdio};
use std::str::FromStr;
use std::{env, fmt, io, mem};
use tracing::instrument;
use crate::cli_util::CommandError;
use crate::config::CommandNameAndArgs;
use crate::formatter::{Formatter, FormatterFactory, LabeledWriter};
pub struct Ui {
color: bool,
pager_cmd: CommandNameAndArgs,
paginate: PaginationChoice,
progress_indicator: bool,
formatter_factory: FormatterFactory,
output: UiOutput,
}
fn progress_indicator_setting(config: &config::Config) -> bool {
config.get_bool("ui.progress-indicator").unwrap_or(true)
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum ColorChoice {
Always,
Never,
#[default]
Auto,
}
impl FromStr for ColorChoice {
type Err = &'static str;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"always" => Ok(ColorChoice::Always),
"never" => Ok(ColorChoice::Never),
"auto" => Ok(ColorChoice::Auto),
_ => Err("must be one of always, never, or auto"),
}
}
}
impl fmt::Display for ColorChoice {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let s = match self {
ColorChoice::Always => "always",
ColorChoice::Never => "never",
ColorChoice::Auto => "auto",
};
write!(f, "{s}")
}
}
fn color_setting(config: &config::Config) -> ColorChoice {
config
.get_string("ui.color")
.ok()
.and_then(|s| s.parse().ok())
.unwrap_or_default()
}
fn use_color(choice: ColorChoice) -> bool {
match choice {
ColorChoice::Always => true,
ColorChoice::Never => false,
ColorChoice::Auto => io::stdout().is_terminal(),
}
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, serde::Deserialize)]
#[serde(rename_all(deserialize = "kebab-case"))]
pub enum PaginationChoice {
Never,
#[default]
Auto,
}
fn pagination_setting(config: &config::Config) -> Result<PaginationChoice, CommandError> {
config
.get::<PaginationChoice>("ui.paginate")
.map_err(|err| CommandError::ConfigError(format!("Invalid `ui.paginate`: {err:?}")))
}
fn pager_setting(config: &config::Config) -> Result<CommandNameAndArgs, CommandError> {
config
.get::<CommandNameAndArgs>("ui.pager")
.map_err(|err| CommandError::ConfigError(format!("Invalid `ui.pager`: {err:?}")))
}
impl Ui {
pub fn with_config(config: &config::Config) -> Result<Ui, CommandError> {
let color = use_color(color_setting(config));
// Sanitize ANSI escape codes if we're printing to a terminal. Doesn't affect
// ANSI escape codes that originate from the formatter itself.
let sanitize = io::stdout().is_terminal();
let formatter_factory = FormatterFactory::prepare(config, color, sanitize)?;
let progress_indicator = progress_indicator_setting(config);
Ok(Ui {
color,
formatter_factory,
pager_cmd: pager_setting(config)?,
paginate: pagination_setting(config)?,
progress_indicator,
output: UiOutput::new_terminal(),
})
}
pub fn reset(&mut self, config: &config::Config) -> Result<(), CommandError> {
self.color = use_color(color_setting(config));
self.paginate = pagination_setting(config)?;
self.pager_cmd = pager_setting(config)?;
self.progress_indicator = progress_indicator_setting(config);
let sanitize = io::stdout().is_terminal();
self.formatter_factory = FormatterFactory::prepare(config, self.color, sanitize)?;
Ok(())
}
/// Switches the output to use the pager, if allowed.
#[instrument(skip_all)]
pub fn request_pager(&mut self) {
match self.paginate {
PaginationChoice::Never => return,
PaginationChoice::Auto => {}
}
match self.output {
UiOutput::Terminal { .. } if io::stdout().is_terminal() => {
match UiOutput::new_paged(&self.pager_cmd) {
Ok(new_output) => {
self.output = new_output;
}
Err(e) => {
writeln!(
self.warning(),
"Failed to spawn pager '{cmd}': {e}",
cmd = self.pager_cmd,
)
.ok();
}
}
}
UiOutput::Terminal { .. } | UiOutput::Paged { .. } => {}
}
}
pub fn color(&self) -> bool {
self.color
}
pub fn new_formatter<'output, W: Write + 'output>(
&self,
output: W,
) -> Box<dyn Formatter + 'output> {
self.formatter_factory.new_formatter(output)
}
/// Creates a formatter for the locked stdout stream.
///
/// Labels added to the returned formatter should be removed by caller.
/// Otherwise the last color would persist.
pub fn stdout_formatter<'a>(&'a self) -> Box<dyn Formatter + 'a> {
match &self.output {
UiOutput::Terminal { stdout, .. } => self.new_formatter(stdout.lock()),
UiOutput::Paged { child_stdin, .. } => self.new_formatter(child_stdin),
}
}
/// Creates a formatter for the locked stderr stream.
pub fn stderr_formatter<'a>(&'a self) -> Box<dyn Formatter + 'a> {
match &self.output {
UiOutput::Terminal { stderr, .. } => self.new_formatter(stderr.lock()),
UiOutput::Paged { child_stdin, .. } => self.new_formatter(child_stdin),
}
}
/// Stderr stream to be attached to a child process.
pub fn stderr_for_child(&self) -> io::Result<Stdio> {
match &self.output {
UiOutput::Terminal { .. } => Ok(Stdio::inherit()),
UiOutput::Paged { child_stdin, .. } => Ok(duplicate_child_stdin(child_stdin)?.into()),
}
}
/// Whether continuous feedback should be displayed for long-running
/// operations
pub fn use_progress_indicator(&self) -> bool {
match &self.output {
UiOutput::Terminal { stderr, .. } => self.progress_indicator && stderr.is_terminal(),
UiOutput::Paged { .. } => false,
}
}
pub fn progress_output(&self) -> Option<ProgressOutput> {
self.use_progress_indicator().then(|| ProgressOutput {
output: io::stderr(),
})
}
pub fn write(&mut self, text: &str) -> io::Result<()> {
let data = text.as_bytes();
match &mut self.output {
UiOutput::Terminal { stdout, .. } => stdout.write_all(data),
UiOutput::Paged { child_stdin, .. } => child_stdin.write_all(data),
}
}
pub fn write_stderr(&mut self, text: &str) -> io::Result<()> {
let data = text.as_bytes();
match &mut self.output {
UiOutput::Terminal { stderr, .. } => stderr.write_all(data),
UiOutput::Paged { child_stdin, .. } => child_stdin.write_all(data),
}
}
pub fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
match &mut self.output {
UiOutput::Terminal { stdout, .. } => stdout.write_fmt(fmt),
UiOutput::Paged { child_stdin, .. } => child_stdin.write_fmt(fmt),
}
}
pub fn hint(&self) -> LabeledWriter<Box<dyn Formatter + '_>, &'static str> {
LabeledWriter::new(self.stderr_formatter(), "hint")
}
pub fn warning(&self) -> LabeledWriter<Box<dyn Formatter + '_>, &'static str> {
LabeledWriter::new(self.stderr_formatter(), "warning")
}
pub fn error(&self) -> LabeledWriter<Box<dyn Formatter + '_>, &'static str> {
LabeledWriter::new(self.stderr_formatter(), "error")
}
pub fn flush(&mut self) -> io::Result<()> {
match &mut self.output {
UiOutput::Terminal { stdout, .. } => stdout.flush(),
UiOutput::Paged { child_stdin, .. } => child_stdin.flush(),
}
}
/// Waits for the pager exits.
#[instrument(skip_all)]
pub fn finalize_pager(&mut self) {
if let UiOutput::Paged {
mut child,
child_stdin,
} = mem::replace(&mut self.output, UiOutput::new_terminal())
{
drop(child_stdin);
if let Err(e) = child.wait() {
// It's possible (though unlikely) that this write fails, but
// this function gets called so late that there's not much we
// can do about it.
writeln!(self.error(), "Failed to wait on pager: {e}").ok();
}
}
}
pub fn prompt(&mut self, prompt: &str) -> io::Result<String> {
if !io::stdout().is_terminal() {
return Err(io::Error::new(
io::ErrorKind::Unsupported,
"Cannot prompt for input since the output is not connected to a terminal",
));
}
write!(self, "{prompt}: ")?;
self.flush()?;
let mut buf = String::new();
io::stdin().read_line(&mut buf)?;
Ok(buf)
}
pub fn prompt_password(&mut self, prompt: &str) -> io::Result<String> {
if !io::stdout().is_terminal() {
return Err(io::Error::new(
io::ErrorKind::Unsupported,
"Cannot prompt for input since the output is not connected to a terminal",
));
}
rpassword::prompt_password(format!("{prompt}: "))
}
pub fn term_width(&self) -> Option<u16> {
term_width()
}
}
enum UiOutput {
Terminal {
stdout: Stdout,
stderr: Stderr,
},
Paged {
child: Child,
child_stdin: ChildStdin,
},
}
impl UiOutput {
fn new_terminal() -> UiOutput {
UiOutput::Terminal {
stdout: io::stdout(),
stderr: io::stderr(),
}
}
fn new_paged(pager_cmd: &CommandNameAndArgs) -> io::Result<UiOutput> {
let mut child = pager_cmd.to_command().stdin(Stdio::piped()).spawn()?;
let child_stdin = child.stdin.take().unwrap();
Ok(UiOutput::Paged { child, child_stdin })
}
}
#[derive(Debug)]
pub struct ProgressOutput {
output: Stderr,
}
impl ProgressOutput {
pub fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
self.output.write_fmt(fmt)
}
pub fn flush(&mut self) -> io::Result<()> {
self.output.flush()
}
pub fn term_width(&self) -> Option<u16> {
// Terminal can be resized while progress is displayed, so don't cache it.
term_width()
}
/// Construct a guard object which writes `text` when dropped. Useful for
/// restoring terminal state.
pub fn output_guard(&self, text: String) -> OutputGuard {
OutputGuard {
text,
output: io::stderr(),
}
}
}
pub struct OutputGuard {
text: String,
output: Stderr,
}
impl Drop for OutputGuard {
#[instrument(skip_all)]
fn drop(&mut self) {
_ = self.output.write_all(self.text.as_bytes());
_ = self.output.flush();
}
}
#[cfg(unix)]
fn duplicate_child_stdin(stdin: &ChildStdin) -> io::Result<std::os::fd::OwnedFd> {
use std::os::fd::AsFd as _;
stdin.as_fd().try_clone_to_owned()
}
#[cfg(windows)]
fn duplicate_child_stdin(stdin: &ChildStdin) -> io::Result<std::os::windows::io::OwnedHandle> {
use std::os::windows::io::AsHandle as _;
stdin.as_handle().try_clone_to_owned()
}
fn term_width() -> Option<u16> {
if let Some(cols) = env::var("COLUMNS").ok().and_then(|s| s.parse().ok()) {
Some(cols)
} else {
crossterm::terminal::size().ok().map(|(cols, _)| cols)
}
}