( )⚙ D12167 rhg: Add support for colored output

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12167

rhg: Add support for colored output
ClosedPublic

Authored by SimonSapin on Feb 10 2022, 2:18 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG39c447e03dbc: rhg: Add support for colored output
Summary

The same "label" system is used as in Python code

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

SimonSapin created this revision.Feb 10 2022, 2:18 PM
SimonSapin added a comment.Feb 10 2022, 2:21 PM

This will likely still need minor changes to make a test pass: https://foss.heptapod.net/mercurial/mercurial-devel/-/jobs/340039
This produces output that looks correct when rendered by a terminal, but escape sequences are not exactly where the test expects them.

SimonSapin updated this revision to Diff 32145.Feb 11 2022, 6:42 AM
SimonSapin retitled this revision from [WIP] rhg: Add support for colored output to rhg: Add support for colored output.Feb 11 2022, 11:35 AM
SimonSapin updated this revision to Diff 32148.
Alphare requested changes to this revision.Feb 12 2022, 7:02 PM
Alphare added a subscriber: Alphare.
Alphare added inline comments.
rust/rhg/src/ui.rs
61

Note to self: looks like this is removed in a later patch in the series

81

Needs a docstring

256

Those pyramids of scope would indeed fit in ancient Egypt. I think we should flatten the code somewhat for readability. :)

This revision now requires changes to proceed.Feb 12 2022, 7:02 PM
SimonSapin added inline comments.Feb 13 2022, 5:30 AM
rust/rhg/src/ui.rs
256

Haha that’s fair :) I’ll move some things around

SimonSapin updated this revision to Diff 32153.Feb 13 2022, 6:06 AM
Alphare accepted this revision.Feb 14 2022, 5:04 AM
This revision is now accepted and ready to land.Feb 14 2022, 5:04 AM
SimonSapin added a commit: rHG39c447e03dbc: rhg: Add support for colored output.Feb 14 2022, 5:25 AM
Closed by commit rHG39c447e03dbc: rhg: Add support for colored output (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 32145

rust/Cargo.lock

dependencies = [ dependencies = [
"winapi", "winapi",
] ]
[[package]] [[package]]
name = "rhg" name = "rhg"
version = "0.1.0" version = "0.1.0"
dependencies = [ dependencies = [
"atty",
"chrono", "chrono",
"clap", "clap",
"derive_more", "derive_more",
"env_logger", "env_logger",
"format-bytes", "format-bytes",
"hg-core", "hg-core",
"home", "home",
"lazy_static", "lazy_static",

rust/hg-core/src/config.rs

// config.rs // config.rs
// //
// Copyright 2020 // Copyright 2020
// Valentin Gatien-Baron, // Valentin Gatien-Baron,
// Raphaël Gomès <rgomes@octobus.net> // Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Mercurial config parsing and interfaces. //! Mercurial config parsing and interfaces.
mod config; mod config;
mod layer; mod layer;
mod values; mod values;
pub use config::{Config, ConfigSource, ConfigValueParseError}; pub use config::{Config, ConfigSource, ConfigValueParseError};
pub use layer::{ConfigError, ConfigParseError}; pub use layer::{ConfigError, ConfigOrigin, ConfigParseError};

rust/hg-core/src/config/config.rs

} }
/// Returns the raw value bytes of the first one found, or `None`. /// Returns the raw value bytes of the first one found, or `None`.
pub fn get(&self, section: &[u8], item: &[u8]) -> Option<&[u8]> { pub fn get(&self, section: &[u8], item: &[u8]) -> Option<&[u8]> {
self.get_inner(section, item) self.get_inner(section, item)
.map(|(_, value)| value.bytes.as_ref()) .map(|(_, value)| value.bytes.as_ref())
} }
/// Returns the raw value bytes of the first one found, or `None`.
pub fn get_with_origin(
&self,
section: &[u8],
item: &[u8],
) -> Option<(&[u8], &ConfigOrigin)> {
self.get_inner(section, item)
.map(|(layer, value)| (value.bytes.as_ref(), &layer.origin))
}
/// Returns the layer and the value of the first one found, or `None`. /// Returns the layer and the value of the first one found, or `None`.
fn get_inner( fn get_inner(
&self, &self,
section: &[u8], section: &[u8],
item: &[u8], item: &[u8],
) -> Option<(&ConfigLayer, &ConfigValue)> { ) -> Option<(&ConfigLayer, &ConfigValue)> {
for layer in self.layers.iter().rev() { for layer in self.layers.iter().rev() {
if !layer.trusted { if !layer.trusted {

rust/hg-core/src/config/layer.rs

#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
pub struct ConfigValue { pub struct ConfigValue {
/// The raw bytes of the value (be it from the CLI, env or from a file) /// The raw bytes of the value (be it from the CLI, env or from a file)
pub bytes: Vec<u8>, pub bytes: Vec<u8>,
/// Only present if the value comes from a file, 1-indexed. /// Only present if the value comes from a file, 1-indexed.
pub line: Option<usize>, pub line: Option<usize>,
} }
#[derive(Clone, Debug)] #[derive(Clone, Debug, PartialEq, Eq)]
pub enum ConfigOrigin { pub enum ConfigOrigin {
/// From a configuration file /// From a configuration file
File(PathBuf), File(PathBuf),
/// From a `--config` CLI argument /// From a `--config` CLI argument
CommandLine, CommandLine,
/// From a `--color` CLI argument /// From a `--color` CLI argument
CommandLineColor, CommandLineColor,
/// From environment variables like `$PAGER` or `$EDITOR` /// From environment variables like `$PAGER` or `$EDITOR`

rust/rhg/Cargo.toml

[package] [package]
name = "rhg" name = "rhg"
version = "0.1.0" version = "0.1.0"
authors = [ authors = [
"Antoine Cezar <antoine.cezar@octobus.net>", "Antoine Cezar <antoine.cezar@octobus.net>",
"Raphaël Gomès <raphael.gomes@octobus.net>", "Raphaël Gomès <raphael.gomes@octobus.net>",
] ]
edition = "2018" edition = "2018"
[dependencies] [dependencies]
atty = "0.2"
hg-core = { path = "../hg-core"} hg-core = { path = "../hg-core"}
chrono = "0.4.19" chrono = "0.4.19"
clap = "2.33.1" clap = "2.33.1"
derive_more = "0.99" derive_more = "0.99"
home = "0.5.3" home = "0.5.3"
lazy_static = "1.4.0" lazy_static = "1.4.0"
log = "0.4.11" log = "0.4.11"
micro-timer = "0.3.1" micro-timer = "0.3.1"
regex = "1.3.9" regex = "1.3.9"
env_logger = "0.7.1" env_logger = "0.7.1"
format-bytes = "0.3.0" format-bytes = "0.3.0"
users = "0.11.0" users = "0.11.0"

rust/rhg/src/ui.rs

use format_bytes::format_bytes; use format_bytes::format_bytes;
use format_bytes::write_bytes;
use hg::config::Config; use hg::config::Config;
use hg::config::ConfigOrigin;
use hg::errors::HgError; use hg::errors::HgError;
use hg::utils::files::get_bytes_from_os_string; use hg::utils::files::get_bytes_from_os_string;
use std::borrow::Cow; use std::borrow::Cow;
use std::collections::HashMap;
use std::env; use std::env;
use std::io; use std::io;
use std::io::{ErrorKind, Write}; use std::io::{ErrorKind, Write};
#[derive(Debug)]
pub struct Ui { pub struct Ui {
stdout: std::io::Stdout, stdout: std::io::Stdout,
stderr: std::io::Stderr, stderr: std::io::Stderr,
colors: Option<ColorConfig>,
} }
/// The kind of user interface error /// The kind of user interface error
pub enum UiError { pub enum UiError {
/// The standard output stream cannot be written to /// The standard output stream cannot be written to
StdoutError(io::Error), StdoutError(io::Error),
/// The standard error stream cannot be written to /// The standard error stream cannot be written to
StderrError(io::Error), StderrError(io::Error),
} }
/// The commandline user interface /// The commandline user interface
impl Ui { impl Ui {
pub fn new(_config: &Config) -> Result<Self, HgError> { pub fn new(config: &Config) -> Result<Self, HgError> {
Ok(Ui { Ok(Ui {
// If using something else, also adapt `isatty()` below.
stdout: std::io::stdout(), stdout: std::io::stdout(),
stderr: std::io::stderr(), stderr: std::io::stderr(),
colors: ColorConfig::new(config)?,
}) })
} }
/// Default to no color if color configuration errors. /// Default to no color if color configuration errors.
/// ///
/// Useful when we’re already handling another error. /// Useful when we’re already handling another error.
pub fn new_infallible(_config: &Config) -> Self { pub fn new_infallible(config: &Config) -> Self {
Ui { Ui {
// If using something else, also adapt `isatty()` below.
stdout: std::io::stdout(), stdout: std::io::stdout(),
stderr: std::io::stderr(), stderr: std::io::stderr(),
colors: ColorConfig::new(config).unwrap_or(None),
} }
} }
/// Returns a buffered handle on stdout for faster batch printing /// Returns a buffered handle on stdout for faster batch printing
/// operations. /// operations.
pub fn stdout_buffer(&self) -> StdoutBuffer<std::io::StdoutLock> { pub fn stdout_buffer(&self) -> StdoutBuffer<std::io::StdoutLock> {
StdoutBuffer::new(self.stdout.lock()) StdoutBuffer::new(self.stdout.lock())
} }
/// Write bytes to stdout /// Write bytes to stdout
pub fn write_stdout(&self, bytes: &[u8]) -> Result<(), UiError> { pub fn write_stdout(&self, bytes: &[u8]) -> Result<(), UiError> {
// Hack to silence "unused" warnings
if false {
AlphareUnsubmitted
Not Done

Note to self: looks like this is removed in a later patch in the series

Alphare: Note to self: looks like this is removed in a later patch in the series
return self.write_stdout_labelled(bytes, "");
}
let mut stdout = self.stdout.lock(); let mut stdout = self.stdout.lock();
stdout.write_all(bytes).or_else(handle_stdout_error)?; stdout.write_all(bytes).or_else(handle_stdout_error)?;
stdout.flush().or_else(handle_stdout_error) stdout.flush().or_else(handle_stdout_error)
} }
/// Write bytes to stderr /// Write bytes to stderr
pub fn write_stderr(&self, bytes: &[u8]) -> Result<(), UiError> { pub fn write_stderr(&self, bytes: &[u8]) -> Result<(), UiError> {
let mut stderr = self.stderr.lock(); let mut stderr = self.stderr.lock();
stderr.write_all(bytes).or_else(handle_stderr_error)?; stderr.write_all(bytes).or_else(handle_stderr_error)?;
stderr.flush().or_else(handle_stderr_error) stderr.flush().or_else(handle_stderr_error)
} }
pub fn write_stdout_labelled(
AlphareUnsubmitted
Not Done

Needs a docstring

Alphare: Needs a docstring
&self,
bytes: &[u8],
label: &str,
) -> Result<(), UiError> {
if let Some(colors) = &self.colors {
if let Some(effects) = colors.styles.get(label.as_bytes()) {
if !effects.is_empty() {
return self
.write_stdout_with_effects(bytes, effects)
.or_else(handle_stdout_error);
}
}
}
self.write_stdout(bytes)
}
fn write_stdout_with_effects(
&self,
bytes: &[u8],
effects: &[Effect],
) -> io::Result<()> {
let stdout = &mut self.stdout.lock();
let mut write_line = |line: &[u8], first: bool| {
// `line` does not include the newline delimiter
if !first {
stdout.write_all(b"\n")?;
}
if line.is_empty() {
return Ok(());
}
/// 0x1B == 27 == 0o33
const ASCII_ESCAPE: &[u8] = b"\x1b";
write_bytes!(stdout, b"{}[0", ASCII_ESCAPE)?;
for effect in effects {
write_bytes!(stdout, b";{}", effect)?;
}
write_bytes!(stdout, b"m")?;
stdout.write_all(line)?;
write_bytes!(stdout, b"{}[0m", ASCII_ESCAPE)
};
let mut lines = bytes.split(|&byte| byte == b'\n');
if let Some(first) = lines.next() {
write_line(first, true)?;
for line in lines {
write_line(line, false)?
}
}
stdout.flush()
}
/// Return whether plain mode is active. /// Return whether plain mode is active.
/// ///
/// Plain mode means that all configuration variables which affect /// Plain mode means that all configuration variables which affect
/// the behavior and output of Mercurial should be /// the behavior and output of Mercurial should be
/// ignored. Additionally, the output should be stable, /// ignored. Additionally, the output should be stable,
/// reproducible and suitable for use in scripts or applications. /// reproducible and suitable for use in scripts or applications.
/// ///
/// The only way to trigger plain mode is by setting either the /// The only way to trigger plain mode is by setting either the
} }
/// Encode rust strings according to the user system. /// Encode rust strings according to the user system.
pub fn utf8_to_local(s: &str) -> Cow<[u8]> { pub fn utf8_to_local(s: &str) -> Cow<[u8]> {
// TODO encode for the user's system // // TODO encode for the user's system //
let bytes = s.as_bytes(); let bytes = s.as_bytes();
Cow::Borrowed(bytes) Cow::Borrowed(bytes)
} }
struct ColorConfig {
styles: EffectsMap,
}
impl ColorConfig {
// Similar to _modesetup in mercurial/color.py
fn new(config: &Config) -> Result<Option<Self>, HgError> {
Ok(match ColorMode::get(config)? {
None => None,
Some(ColorMode::Ansi) => {
let mut styles = default_styles();
for (key, _value) in config.iter_section(b"color") {
if !key.contains(&b'.')
|| key.starts_with(b"color.")
|| key.starts_with(b"terminfo.")
{
continue;
}
// `unwrap` shouldn’t panic since we just got this key from
// iteration
styles.insert(
key.to_owned(),
config
.get_list(b"color", key)
.unwrap()
.iter()
// TODO: warn for unknown effect/color names
// (when `effect` returns `None`)
.filter_map(|name| effect(name))
.collect(),
);
}
Some(ColorConfig { styles })
}
AlphareUnsubmitted
Not Done

Those pyramids of scope would indeed fit in ancient Egypt. I think we should flatten the code somewhat for readability. :)

Alphare: Those pyramids of scope would indeed fit in ancient Egypt. I think we should flatten the code…
SimonSapinAuthorUnsubmitted
Done

Haha that’s fair :) I’ll move some things around

SimonSapin: Haha that’s fair :) I’ll move some things around
})
}
}
enum ColorMode {
// TODO: support other modes
Ansi,
}
impl ColorMode {
// Similar to _modesetup in mercurial/color.py
fn get(config: &Config) -> Result<Option<Self>, HgError> {
if plain(Some("color")) {
return Ok(None);
}
let enabled_default = b"auto";
// `origin` is only used when `!auto`, so its default doesn’t matter
let (enabled, origin) = config
.get_with_origin(b"ui", b"color")
.unwrap_or((enabled_default, &ConfigOrigin::CommandLineColor));
if enabled == b"debug" {
return Err(HgError::unsupported("debug color mode"));
}
let auto = enabled == b"auto";
let always;
if !auto {
let enabled_bool = config.get_bool(b"ui", b"color")?;
if !enabled_bool {
return Ok(None);
}
always = enabled == b"always"
|| *origin == ConfigOrigin::CommandLineColor
} else {
always = false
};
let formatted = always
|| (env::var_os("TERM").unwrap_or_default() != "dumb"
&& formatted(config)?);
// TODO: support modes other than ANSI and select based on color.mode
// config etc
if formatted {
Ok(Some(ColorMode::Ansi))
} else {
Ok(None)
}
}
}
/// Should formatted output be used?
///
/// Note: rhg does not have the formatter mechanism yet,
/// but this is also used when deciding whether to use color.
fn formatted(config: &Config) -> Result<bool, HgError> {
if let Some(formatted) = config.get_option(b"ui", b"formatted")? {
Ok(formatted)
} else {
isatty(config)
}
}
fn isatty(config: &Config) -> Result<bool, HgError> {
Ok(if config.get_bool(b"ui", b"nontty")? {
false
} else {
atty::is(atty::Stream::Stdout)
})
}
type Effect = u32;
type EffectsMap = HashMap<Vec<u8>, Vec<Effect>>;
macro_rules! effects {
($( $name: ident: $value: expr ,)+) => {
#[allow(non_upper_case_globals)]
mod effects {
$(
pub const $name: super::Effect = $value;
)+
}
fn effect(name: &[u8]) -> Option<Effect> {
$(
if name == stringify!($name).as_bytes() {
Some(effects::$name)
} else
)+
{
None
}
}
};
}
effects! {
none: 0,
black: 30,
red: 31,
green: 32,
yellow: 33,
blue: 34,
magenta: 35,
cyan: 36,
white: 37,
bold: 1,
italic: 3,
underline: 4,
inverse: 7,
dim: 2,
black_background: 40,
red_background: 41,
green_background: 42,
yellow_background: 43,
blue_background: 44,
purple_background: 45,
cyan_background: 46,
white_background: 47,
}
macro_rules! default_styles {
($( $key: expr => [$($value: expr),*],)+) => {
fn default_styles() -> EffectsMap {
use effects::*;
let mut map = HashMap::new();
$(
map.insert($key[..].to_owned(), vec![$( $value ),*]);
)+
map
}
};
}
default_styles! {
b"grep.match" => [red, bold],
b"grep.linenumber" => [green],
b"grep.rev" => [blue],
b"grep.sep" => [cyan],
b"grep.filename" => [magenta],
b"grep.user" => [magenta],
b"grep.date" => [magenta],
b"grep.inserted" => [green, bold],
b"grep.deleted" => [red, bold],
b"bookmarks.active" => [green],
b"branches.active" => [none],
b"branches.closed" => [black, bold],
b"branches.current" => [green],
b"branches.inactive" => [none],
b"diff.changed" => [white],
b"diff.deleted" => [red],
b"diff.deleted.changed" => [red, bold, underline],
b"diff.deleted.unchanged" => [red],
b"diff.diffline" => [bold],
b"diff.extended" => [cyan, bold],
b"diff.file_a" => [red, bold],
b"diff.file_b" => [green, bold],
b"diff.hunk" => [magenta],
b"diff.inserted" => [green],
b"diff.inserted.changed" => [green, bold, underline],
b"diff.inserted.unchanged" => [green],
b"diff.tab" => [],
b"diff.trailingwhitespace" => [bold, red_background],
b"changeset.public" => [],
b"changeset.draft" => [],
b"changeset.secret" => [],
b"diffstat.deleted" => [red],
b"diffstat.inserted" => [green],
b"formatvariant.name.mismatchconfig" => [red],
b"formatvariant.name.mismatchdefault" => [yellow],
b"formatvariant.name.uptodate" => [green],
b"formatvariant.repo.mismatchconfig" => [red],
b"formatvariant.repo.mismatchdefault" => [yellow],
b"formatvariant.repo.uptodate" => [green],
b"formatvariant.config.special" => [yellow],
b"formatvariant.config.default" => [green],
b"formatvariant.default" => [],
b"histedit.remaining" => [red, bold],
b"ui.addremove.added" => [green],
b"ui.addremove.removed" => [red],
b"ui.error" => [red],
b"ui.prompt" => [yellow],
b"log.changeset" => [yellow],
b"patchbomb.finalsummary" => [],
b"patchbomb.from" => [magenta],
b"patchbomb.to" => [cyan],
b"patchbomb.subject" => [green],
b"patchbomb.diffstats" => [],
b"rebase.rebased" => [blue],
b"rebase.remaining" => [red, bold],
b"resolve.resolved" => [green, bold],
b"resolve.unresolved" => [red, bold],
b"shelve.age" => [cyan],
b"shelve.newest" => [green, bold],
b"shelve.name" => [blue, bold],
b"status.added" => [green, bold],
b"status.clean" => [none],
b"status.copied" => [none],
b"status.deleted" => [cyan, bold, underline],
b"status.ignored" => [black, bold],
b"status.modified" => [blue, bold],
b"status.removed" => [red, bold],
b"status.unknown" => [magenta, bold, underline],
b"tags.normal" => [green],
b"tags.local" => [black, bold],
b"upgrade-repo.requirement.preserved" => [cyan],
b"upgrade-repo.requirement.added" => [green],
b"upgrade-repo.requirement.removed" => [red],
}