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
260	Those pyramids of scope would indeed fit in ancient Egypt. I think we should flatten the code somewhat for readability. :)

rust/rhg/src/ui.rs
260	Haha that’s fair :) I’ll move some things around

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	32126		Feb 10 2022, 2:18 PM	★	★
Diff 2	32145		Feb 11 2022, 6:42 AM	★	★
Diff 3	32148		Feb 11 2022, 11:35 AM	★	★
Diff 4	32153		Feb 13 2022, 6:06 AM	★	★
Diff 5	32159	rHG39c447e03dbc9ff290fb5b8328702391dbe90573	Feb 10 2022, 6:59 AM	★	★

Status	Author	Revision
Closed	SimonSapin	D12162 rhg: enable `rhg status` by default, without config or env opt-in
Closed	SimonSapin	D12168 rhg: Colorize `rhg status` output when appropriate
Closed	SimonSapin	D12167 rhg: Add support for colored output
Closed	SimonSapin	D12166 rhg: Add parsing for the --color global CLI argument
Closed	SimonSapin	D12165 rhg: Make Ui::new falliable, add Ui::new_infallible
Closed	SimonSapin	D12164 rhg: Pass a &Config to Ui::new
Closed	SimonSapin	D12163 rhg: Add support for HGPLAINEXPECT

Diff 32159

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/color.rs

This file was added.

				use crate::ui::formatted;
				use crate::ui::plain;
				use format_bytes::write_bytes;
				use hg::config::Config;
				use hg::config::ConfigOrigin;
				use hg::errors::HgError;
				use std::collections::HashMap;

				pub type Effect = u32;

				pub 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],
				}

				fn parse_effect(config_key: &[u8], effect_name: &[u8]) -> Option<Effect> {
				let found = effect(effect_name);
				if found.is_none() {
				// TODO: have some API for warnings
				// TODO: handle IO errors during warnings
				let stderr = std::io::stderr();
				let _ = write_bytes!(
				&mut stderr.lock(),
				b"ignoring unknown color/effect '{}' \
				(configured in color.{})\n",
				effect_name,
				config_key,
				);
				}
				found
				}

				fn effects_from_config(config: &Config) -> EffectsMap {
				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
				let list = config.get_list(b"color", key).unwrap();
				let parsed = list
				.iter()
				.filter_map(\|name\| parse_effect(key, name))
				.collect();
				styles.insert(key.to_owned(), parsed);
				}
				styles
				}

				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
				\|\| (std::env::var_os("TERM").unwrap_or_default() != "dumb"
				&& formatted(config)?);

				let mode_default = b"auto";
				let mode = config.get(b"color", b"mode").unwrap_or(mode_default);

				if formatted {
				match mode {
				b"ansi" \| b"auto" => Ok(Some(ColorMode::Ansi)),
				// TODO: support other modes
				_ => Err(HgError::UnsupportedFeature(format!(
				"color mode {}",
				String::from_utf8_lossy(mode)
				))),
				}
				} else {
				Ok(None)
				}
				}
				}

				pub struct ColorConfig {
				pub styles: EffectsMap,
				}

				impl ColorConfig {
				// Similar to _modesetup in mercurial/color.py
				pub fn new(config: &Config) -> Result<Option<Self>, HgError> {
				Ok(match ColorMode::get(config)? {
				None => None,
				Some(ColorMode::Ansi) => Some(ColorConfig {
				styles: effects_from_config(config),
				}),
				})
				}
				}

rust/rhg/src/main.rs

	use hg::utils::files::{get_bytes_from_os_str, get_path_from_bytes};			use hg::utils::files::{get_bytes_from_os_str, get_path_from_bytes};
	use hg::utils::SliceExt;			use hg::utils::SliceExt;
	use std::collections::HashSet;			use std::collections::HashSet;
	use std::ffi::OsString;			use std::ffi::OsString;
	use std::path::PathBuf;			use std::path::PathBuf;
	use std::process::Command;			use std::process::Command;

	mod blackbox;			mod blackbox;
				mod color;
	mod error;			mod error;
	mod ui;			mod ui;
	pub mod utils {			pub mod utils {
	pub mod path_utils;			pub mod path_utils;
	}			}

	fn main_with_result(			fn main_with_result(
	process_start_time: &blackbox::ProcessStartTime,			process_start_time: &blackbox::ProcessStartTime,

rust/rhg/src/ui.rs

				use crate::color::ColorConfig;
				use crate::color::Effect;
	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::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::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)
	}			}

				/// Write bytes to stdout with the given label
				AlphareUnsubmitted Not Done Needs a docstring Alphare: Needs a docstring
				///
				/// Like the optional `label` parameter in `mercurial/ui.py`,
				/// this label influences the color used for this output.
				pub fn write_stdout_labelled(
				&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
	/// `HGPLAIN' or `HGPLAINEXCEPT' environment variables.			/// `HGPLAIN' or `HGPLAINEXCEPT' environment variables.
	///			///
	/// The return value can either be			/// The return value can either be
	/// - False if HGPLAIN is not set, or feature is in HGPLAINEXCEPT			/// - False if HGPLAIN is not set, or feature is in HGPLAINEXCEPT
	/// - False if feature is disabled by default and not included in HGPLAIN			/// - False if feature is disabled by default and not included in HGPLAIN
	/// - True otherwise			/// - True otherwise
	pub fn plain(&self, feature: Option<&str>) -> bool {			pub fn plain(&self, feature: Option<&str>) -> bool {
	plain(feature)			plain(feature)
	}			}
	}			}

	fn plain(opt_feature: Option<&str>) -> bool {			pub fn plain(opt_feature: Option<&str>) -> bool {
	if let Some(except) = env::var_os("HGPLAINEXCEPT") {			if let Some(except) = env::var_os("HGPLAINEXCEPT") {
	opt_feature.map_or(true, \|feature\| {			opt_feature.map_or(true, \|feature\| {
	get_bytes_from_os_string(except)			get_bytes_from_os_string(except)
	.split(\|&byte\| byte == b',')			.split(\|&byte\| byte == b',')
	.all(\|exception\| exception != feature.as_bytes())			.all(\|exception\| exception != feature.as_bytes())
	})			})
	} else {			} else {
	env::var_os("HGPLAIN").is_some()			env::var_os("HGPLAIN").is_some()
	}			}

	/// 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)
	}			}

				/// 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.
				pub 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)
				})
				}
				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

tests/test-status-color.t

	$ hg copy modified copied			$ hg copy modified copied

	test unknown color			test unknown color

	$ hg --config color.status.modified=periwinkle status			$ hg --config color.status.modified=periwinkle status
	ignoring unknown color/effect 'periwinkle' (configured in color.status.modified)			ignoring unknown color/effect 'periwinkle' (configured in color.status.modified)
	ignoring unknown color/effect 'periwinkle' (configured in color.status.modified)			ignoring unknown color/effect 'periwinkle' (configured in color.status.modified)
	ignoring unknown color/effect 'periwinkle' (configured in color.status.modified)			ignoring unknown color/effect 'periwinkle' (configured in color.status.modified)
				ignoring unknown color/effect 'periwinkle' (configured in color.status.modified) (rhg !)
	M modified			M modified
	\x1b[0;32;1mA \x1b[0m\x1b[0;32;1madded\x1b[0m (esc)			\x1b[0;32;1mA \x1b[0m\x1b[0;32;1madded\x1b[0m (esc)
	\x1b[0;32;1mA \x1b[0m\x1b[0;32;1mcopied\x1b[0m (esc)			\x1b[0;32;1mA \x1b[0m\x1b[0;32;1mcopied\x1b[0m (esc)
	\x1b[0;31;1mR \x1b[0m\x1b[0;31;1mremoved\x1b[0m (esc)			\x1b[0;31;1mR \x1b[0m\x1b[0;31;1mremoved\x1b[0m (esc)
	\x1b[0;36;1;4m! \x1b[0m\x1b[0;36;1;4mdeleted\x1b[0m (esc)			\x1b[0;36;1;4m! \x1b[0m\x1b[0;36;1;4mdeleted\x1b[0m (esc)
	\x1b[0;35;1;4m? \x1b[0m\x1b[0;35;1;4munknown\x1b[0m (esc)			\x1b[0;35;1;4m? \x1b[0m\x1b[0;35;1;4munknown\x1b[0m (esc)

	Run status with 2 different flags.			Run status with 2 different flags.

		Path
M		rust/Cargo.lock (1 line)
M		rust/hg-core/src/config.rs (2 lines)
M		rust/hg-core/src/config/config.rs (10 lines)
M		rust/hg-core/src/config/layer.rs (2 lines)
M		rust/rhg/Cargo.toml (1 line)
A	M	rust/rhg/src/color.rs (255 lines)
M		rust/rhg/src/main.rs (1 line)
M		rust/rhg/src/ui.rs (97 lines)
M		tests/test-status-color.t (1 line)

This is an archive of the discontinued Mercurial Phabricator instance.

rhg: Add support for colored output
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents
Changeset List

Diff 32159

rust/Cargo.lock

rust/hg-core/src/config.rs

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

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

rust/rhg/Cargo.toml

rust/rhg/src/color.rs

rust/rhg/src/main.rs

rust/rhg/src/ui.rs

tests/test-status-color.t

This is an archive of the discontinued Mercurial Phabricator instance.

rhg: Add support for colored outputClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 32159

rust/Cargo.lock

rust/hg-core/src/config.rs

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

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

rust/rhg/Cargo.toml

rust/rhg/src/color.rs

rust/rhg/src/main.rs

rust/rhg/src/ui.rs

tests/test-status-color.t

rhg: Add support for colored output
ClosedPublic

Revision Contents
Changeset List