colo 0.4.1

CLI tool to show and convert colors between various color spaces
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use anyhow::Result;
use clap::{App, Arg, ArgMatches, SubCommand};
use std::iter;

use super::{util, Cmd};
use crate::{
    color::{Color, ColorFormat},
    terminal::{self, stdin},
    State,
};

const COLOR_HELP_MESSAGE: &str = "\
The input colors. Multiple colors can be specified. Supported formats:

* HTML color name, e.g. 'rebeccapurple'
* Hexadecimal RGB color, e.g. '07F', '0077FF'
* Color components, e.g. 'hsl(30, 100%, 50%)'
  Commas and parentheses are optional.
  For supported color spaces, see <https://aloso.github.io/colo/color_spaces>

If colo is used behind a pipe or outside of a terminal, the colors can be provided via stdin, e.g.

$ echo orange blue FF7700 | colo textcolor";

/// The `textcolor` subcommand
pub struct TextColor {
    pub colors: Vec<(Color, ColorFormat)>,
}

impl Cmd for TextColor {
    fn command<'a, 'b>(state: State) -> App<'a, 'b> {
        SubCommand::with_name("textcolor")
            .alias("textcolour")
            .about("Get a readable text color for a given background color")
            .long_about(
                "Return a readable text color (black or white) for each given background color. \
            This can also be used in the opposite way, i.e. to create a background color \
            for a given text color.",
            )
            .arg(
                Arg::with_name("colors")
                    .help(COLOR_HELP_MESSAGE)
                    .index(1)
                    .multiple(true)
                    .required(state.interactive),
            )
    }

    fn parse(matches: &ArgMatches, &mut state: &mut State) -> Result<Self> {
        let mut colors = match matches.values_of("colors") {
            Some(values) => util::values_to_colors(values, state)?,
            None => vec![],
        };

        if !state.interactive && colors.is_empty() {
            let text = stdin::read_all()?;
            colors = util::values_to_colors(iter::once(text.as_str()), state)?;
        }

        Ok(TextColor { colors })
    }

    fn run(&self, state: State) -> Result<()> {
        terminal::text_colors(state, self.colors.iter().map(|&(c, _)| c))
    }
}