view rust/rhg/src/color.rs @ 51602:68929cf3c0c6

match: avoid rust fast path if the matcher was tampered with

Otherwise the fast path does not respect the modifications made
by the extension (concretely largefiles, but other extensions can
start using that too)

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);
            }
            enabled == b"always" || *origin == ConfigOrigin::CommandLineColor
        } else {
            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(ColorMode::get(config)?.map(|ColorMode::Ansi| ColorConfig {
            styles: effects_from_config(config),
        }))
    }
}