9507989191

Committed 13 Jun 2024 11:12PM UTC coverage: 99.411% (+0.004%) from 99.407%

Build # 9507989191

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #80 from FriedlandAaron/feat/raw-mode-flag

Add support for raw mode

Run Details

603 of 603 branches covered (100.0%)

Branch coverage included in aggregate %.

28 of 28 new or added lines in 5 files covered. (100.0%)

1 existing line in 1 file now uncovered.

2264 of 2281 relevant lines covered (99.25%)

814.5 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.08

/rust/src/args.rs

//! The contents of this module is all about parsing cli arguments
use std::collections::HashMap;

use crate::color::{color, get_foreground_color, hex2rgb, rgb2hex};
use crate::config::{
        Align, BgColors, CliOption, Colors, Env, Fonts, OptionType, Options, CLIOPTIONS, GRADIENTS_AGENDER,
        GRADIENTS_AROMANTIC, GRADIENTS_ASEXUAL, GRADIENTS_BISEXUAL, GRADIENTS_GENDERFLUID, GRADIENTS_GENDERQUEER,
        GRADIENTS_INTERSEX, GRADIENTS_LESBIAN, GRADIENTS_NONBINARY, GRADIENTS_PANSEXUAL, GRADIENTS_POLYSEXUAL,
        GRADIENTS_PRIDE, GRADIENTS_TRANSGENDER,
};
use crate::debug::{d, Dt};

/// This function converts command line arguments into an [`Options`] struct
///
/// ```rust
/// extern crate cfonts;
///
/// use cfonts::{ Options, Align, Colors, BgColors, Fonts, Env };
/// use cfonts::args::parse;
///
/// let mut options = Options::default();
/// options.text = "long text|with new line".to_string();
/// options.font = Fonts::FontSimple3d;
/// options.align = Align::Center;
/// options.colors = vec![Colors::Blue, Colors::White];
/// options.background = BgColors::CyanBright;
/// options.letter_spacing = 9;
/// options.line_height = 2;
/// options.spaceless = true;
/// options.max_length = 100;
/// options.gradient = vec!["#ff0000".to_string(), "#0000ff".to_string()];
/// options.independent_gradient = true;
/// options.transition_gradient = true;
/// options.env = Env::Browser;
/// options.raw_mode = true;
/// options.help = true;
/// options.version = true;
/// options.debug = true;
/// options.debug_level = 3;
///
/// // All shortcut flags
/// assert_eq!(
///     parse(vec![
///         "path/to/bin".to_string(),
///         "long text|with new line".to_string(),
///         "-f".to_string(),
///         "simple3d".to_string(),
///         "-a".to_string(),
///         "center".to_string(),
///         "-c".to_string(),
///         "blue,white".to_string(),
///         "-b".to_string(),
///         "cyanBright".to_string(),
///         "-l".to_string(),
///         "9".to_string(),
///         "-z".to_string(),
///         "2".to_string(),
///         "-s".to_string(),
///         "-m".to_string(),
///         "100".to_string(),
///         "-g".to_string(),
///         "red,blue".to_string(),
///         "-i".to_string(),
///         "-t".to_string(),
///         "-e".to_string(),
///         "browser".to_string(),
///         "-r".to_string(),
///         "-h".to_string(),
///         "-v".to_string(),
///         "-d".to_string(),
///         "-x".to_string(),
///         "3".to_string(),
///     ])
///     .unwrap(),
///     options
/// );
///
/// // All shortcut flags but all boolean flags are stacked
/// assert_eq!(
///     parse(vec![
///         "path/to/bin".to_string(),
///         "long text|with new line".to_string(),
///         "-f".to_string(),
///         "simple3d".to_string(),
///         "-a".to_string(),
///         "center".to_string(),
///         "-c".to_string(),
///         "blue,white".to_string(),
///         "-b".to_string(),
///         "cyanBright".to_string(),
///         "-l".to_string(),
///         "9".to_string(),
///         "-z".to_string(),
///         "2".to_string(),
///         "-sithvdr".to_string(), // <-- stacked boolean flags
///         "-m".to_string(),
///         "100".to_string(),
///         "-g".to_string(),
///         "red,blue".to_string(),
///         "-e".to_string(),
///         "browser".to_string(),
///         "-x".to_string(),
///         "3".to_string(),
///     ])
///     .unwrap(),
///     options
/// );
///
/// // All long-form flags
/// assert_eq!(
///     parse(vec![
///         "path/to/bin".to_string(),
///         "long text|with new line".to_string(),
///         "--font".to_string(),
///         "simple3d".to_string(),
///         "--align".to_string(),
///         "center".to_string(),
///         "--colors".to_string(),
///         "blue,white".to_string(),
///         "--background".to_string(),
///         "cyanBright".to_string(),
///         "--letter-spacing".to_string(),
///         "9".to_string(),
///         "--line-height".to_string(),
///         "2".to_string(),
///         "--spaceless".to_string(),
///         "--independent-gradient".to_string(),
///         "--transition-gradient".to_string(),
///         "--help".to_string(),
///         "--version".to_string(),
///         "--debug".to_string(),
///         "--raw-mode".to_string(),
///         "--max-length".to_string(),
///         "100".to_string(),
///         "--gradient".to_string(),
///         "red,blue".to_string(),
///         "--env".to_string(),
///         "browser".to_string(),
///         "--debug-level".to_string(),
///         "3".to_string(),
///     ])
///     .unwrap(),
///     options
/// );
/// ```
pub fn parse(args: Vec<String>) -> Result<Options, String> {
        let mut my_args = args;
        let mut options = Options::default();

        // create a lookup table for our CLIOPTIONS
        let mut options_lookup: HashMap<String, CliOption> = HashMap::new();

        for option in CLIOPTIONS {
                let name = option.name.to_string();
                let shortcut = option.shortcut.to_string();
                options_lookup.insert(name, option.clone());
                options_lookup.insert(shortcut, option.clone());
                if !option.fallback_shortcut.is_empty() {
                        let shortcut = option.fallback_shortcut.to_string();
                        options_lookup.insert(shortcut, option);
                }
        }

        // we check for the debug flag to make sure we send debug messages in this function as well
        let debug_options = options_lookup.get("-d").unwrap();
        let enabled_debug =
                my_args.contains(&debug_options.name.to_string()) || my_args.contains(&debug_options.shortcut.to_string());
        if enabled_debug {
                options.debug = true;
        }

        // we check for the line_height flag to make sure we don't override it with the console font
        let line_height_options = options_lookup.get("-z").unwrap();
        let line_height_changed = my_args.contains(&line_height_options.name.to_string())
                || my_args.contains(&line_height_options.shortcut.to_string());

        d("args::parse()", 1, Dt::Head, &options, &mut std::io::stdout());

        if my_args.len() < 2 {
                let (start, end) = get_foreground_color(&Colors::Green);
                return Err(format!(
                        "Please provide text to convert with: {start}cfonts \"Text\"{end}\nRun {start}cfonts --help{end} for more infos",
                        start = start,
                        end = end
                ));
        }

        let version_options = options_lookup.get("-v").unwrap();
        if my_args[1] == *version_options.shortcut.to_string()
                || my_args[1] == *version_options.name.to_string()
                || my_args[1] == *version_options.fallback_shortcut.to_string()
        {
                options.version = true;
        }

        let help_options = options_lookup.get("-h").unwrap();
        if my_args[1] == *help_options.shortcut.to_string() || my_args[1] == *help_options.name.to_string() {
                options.help = true;
        }

        // our text to be converted
        options.text = my_args[1].clone();

        let mut args_length = my_args.len();
        let mut i = 2; // we skip the first two arguments as the first is path to binary and the second we already take care of above
                                                         // we iterate over all arguments and match them with our lookup table
        while i < args_length {
                // before we see if this flag exists in our lookup we see if boolean flags have been stacked here
                if my_args[i].starts_with('-') && !my_args[i].starts_with("--") && my_args[i].len() > 2 {
                        // we know that this is a stack of boolean flags
                        let this_flag = my_args[i].clone();
                        let mut middle_flags = Vec::new();

                        // unwrap is guarded by if clause it's contained in
                        for flag in this_flag.strip_prefix('-').unwrap().chars() {
                                let flag_name = format!("-{}", flag);
                                if options_lookup.get(&flag_name).is_some() {
                                        middle_flags.push(flag_name);
                                }
                        }

                        my_args.splice(i..i + 1, middle_flags.iter().cloned());
                        args_length = my_args.len();
                }

                match options_lookup.get(&my_args[i]) {
                        Some(this_flag) => {
                                match this_flag.kind {
                                        OptionType::Text => { /* Only Text type is on argvs[1] */ }
                                        OptionType::Font => {
                                                i += 1;
                                                if i >= args_length {
                                                        return Err(format!("Missing value for option: {}", color(this_flag.name, Colors::Green)));
                                                }
                                                options.font = match my_args[i].to_lowercase().as_str() {
                                                        "console" => Fonts::FontConsole,
                                                        "block" => Fonts::FontBlock,
                                                        "simpleblock" => Fonts::FontSimpleBlock,
                                                        "simple" => Fonts::FontSimple,
                                                        "3d" => Fonts::Font3d,
                                                        "simple3d" => Fonts::FontSimple3d,
                                                        "chrome" => Fonts::FontChrome,
                                                        "huge" => Fonts::FontHuge,
                                                        "shade" => Fonts::FontShade,
                                                        "slick" => Fonts::FontSlick,
                                                        "grid" => Fonts::FontGrid,
                                                        "pallet" => Fonts::FontPallet,
                                                        "tiny" => Fonts::FontTiny,
                                                        unknown => {
                                                                return Err(format!(
                                                                        "The font \"{}\" is not supported.\nAllowed options are: {}",
                                                                        color(unknown, Colors::Green),
                                                                        color(&Fonts::list(), Colors::Green)
                                                                ));
                                                        }
                                                };

                                                if options.font == Fonts::FontConsole && !line_height_changed {
                                                        options.line_height = 0;
                                                }
                                        }
                                        OptionType::Align => {
                                                i += 1;
                                                if i >= args_length {
                                                        return Err(format!("Missing value for option: {}", color(this_flag.name, Colors::Green)));
                                                }
                                                options.align = match my_args[i].to_lowercase().as_str() {
                                                        "left" => Align::Left,
                                                        "center" => Align::Center,
                                                        "right" => Align::Right,
                                                        "top" => Align::Top,
                                                        "bottom" => Align::Bottom,
                                                        unknown => {
                                                                return Err(format!(
                                                                        "The alignment option \"{}\" is not supported.\nAllowed options are: {}",
                                                                        color(unknown, Colors::Green),
                                                                        color(&Align::list(), Colors::Green)
                                                                ));
                                                        }
                                                };
                                        }
                                        OptionType::Colors => {
                                                i += 1;
                                                if i >= args_length {
                                                        return Err(format!("Missing value for option: {}", color(this_flag.name, Colors::Green)));
                                                }
                                                options.colors = my_args[i]
                                                        .to_lowercase()
                                                        .as_str()
                                                        .split(',')
                                                        .map(|this_color| match this_color {
                                                                "system" => Ok(Colors::System),
                                                                "black" => Ok(Colors::Black),
                                                                "red" => Ok(Colors::Red),
                                                                "green" => Ok(Colors::Green),
                                                                "yellow" => Ok(Colors::Yellow),
                                                                "blue" => Ok(Colors::Blue),
                                                                "magenta" => Ok(Colors::Magenta),
                                                                "cyan" => Ok(Colors::Cyan),
                                                                "white" => Ok(Colors::White),
                                                                "gray" => Ok(Colors::Gray),
                                                                "grey" => Ok(Colors::Gray),
                                                                "redbright" => Ok(Colors::RedBright),
                                                                "greenbright" => Ok(Colors::GreenBright),
                                                                "yellowbright" => Ok(Colors::YellowBright),
                                                                "bluebright" => Ok(Colors::BlueBright),
                                                                "magentabright" => Ok(Colors::MagentaBright),
                                                                "cyanbright" => Ok(Colors::CyanBright),
                                                                "whitebright" => Ok(Colors::WhiteBright),
                                                                "candy" => Ok(Colors::Candy),
                                                                unknown => {
                                                                        if unknown.starts_with('#') && unknown.len() > 2 {
                                                                                Ok(Colors::Rgb(hex2rgb(unknown, &options)))
                                                                        } else {
                                                                                Err(format!(
                                                                                        "The color \"{}\" is not supported.\nAllowed options are: {}",
                                                                                        color(unknown, Colors::Green),
                                                                                        color(&Colors::list(), Colors::Green)
                                                                                ))
                                                                        }
                                                                }
                                                        })
                                                        .collect::<Result<Vec<Colors>, String>>()?;
                                        }
                                        OptionType::BgColor => {
                                                i += 1;
                                                if i >= args_length {
                                                        return Err(format!("Missing value for option: {}", color(this_flag.name, Colors::Green)));
                                                }
                                                options.background = match my_args[i].to_lowercase().as_str() {
                                                        "transparent" => BgColors::Transparent,
                                                        "black" => BgColors::Black,
                                                        "red" => BgColors::Red,
                                                        "green" => BgColors::Green,
                                                        "yellow" => BgColors::Yellow,
                                                        "blue" => BgColors::Blue,
                                                        "magenta" => BgColors::Magenta,
                                                        "cyan" => BgColors::Cyan,
                                                        "white" => BgColors::White,
                                                        "gray" => BgColors::Gray,
                                                        "grey" => BgColors::Gray,
                                                        "redbright" => BgColors::RedBright,
                                                        "greenbright" => BgColors::GreenBright,
                                                        "yellowbright" => BgColors::YellowBright,
                                                        "bluebright" => BgColors::BlueBright,
                                                        "magentabright" => BgColors::MagentaBright,
                                                        "cyanbright" => BgColors::CyanBright,
                                                        "whitebright" => BgColors::WhiteBright,
                                                        unknown => {
                                                                if unknown.starts_with('#') && unknown.len() > 2 {
                                                                        BgColors::Rgb(hex2rgb(unknown, &options))
                                                                } else {
                                                                        return Err(format!(
                                                                                "The background color \"{}\" is not supported.\nAllowed options are: {}",
                                                                                color(unknown, Colors::Green),
                                                                                color(&BgColors::list(), Colors::Green)
                                                                        ));
                                                                }
                                                        }
                                                };
                                        }
                                        OptionType::Gradient => {
                                                i += 1;
                                                if i >= args_length {
                                                        return Err(format!("Missing value for option: {}", color(this_flag.name, Colors::Green)));
                                                }
                                                let expanded_args = match my_args[i].to_lowercase().as_str() {
                                                        "lgbt" | "lgbtq" | "lgbtqa" | "pride" => {
                                                                options.transition_gradient = true;
                                                                GRADIENTS_PRIDE.join(",")
                                                        }
                                                        "agender" => {
                                                                options.transition_gradient = true;
                                                                GRADIENTS_AGENDER.join(",")
                                                        }
                                                        "aromantic" => {
                                                                options.transition_gradient = true;
                                                                GRADIENTS_AROMANTIC.join(",")
                                                        }
                                                        "asexual" => {
                                                                options.transition_gradient = true;
                                                                GRADIENTS_ASEXUAL.join(",")
                                                        }
                                                        "bisexual" | "bi" => {
                                                                options.transition_gradient = true;
                                                                GRADIENTS_BISEXUAL.join(",")
                                                        }
                                                        "genderfluid" => {
                                                                options.transition_gradient = true;
                                                                GRADIENTS_GENDERFLUID.join(",")
                                                        }
                                                        "genderqueer" => {
                                                                options.transition_gradient = true;
                                                                GRADIENTS_GENDERQUEER.join(",")
                                                        }
                                                        "intersex" => {
                                                                options.transition_gradient = true;
                                                                GRADIENTS_INTERSEX.join(",")
                                                        }
                                                        "lesbian" => {
                                                                options.transition_gradient = true;
                                                                GRADIENTS_LESBIAN.join(",")
                                                        }
                                                        "nonbinary" => {
                                                                options.transition_gradient = true;
                                                                GRADIENTS_NONBINARY.join(",")
                                                        }
                                                        "pansexual" | "pan" => {
                                                                options.transition_gradient = true;
                                                                GRADIENTS_PANSEXUAL.join(",")
                                                        }
                                                        "polysexual" | "poly" => {
                                                                options.transition_gradient = true;
                                                                GRADIENTS_POLYSEXUAL.join(",")
                                                        }
                                                        "transgender" | "trans" => {
                                                                options.transition_gradient = true;
                                                                GRADIENTS_TRANSGENDER.join(",")
                                                        }
                                                        unknown => unknown.to_string(),
                                                };

                                                options.gradient = expanded_args
                                                        .split(',')
                                                        .map(|this_color| match this_color {
                                                                "black" => Ok(String::from("#000000")),
                                                                "red" => Ok(String::from("#ff0000")),
                                                                "green" => Ok(String::from("#00ff00")),
                                                                "blue" => Ok(String::from("#0000ff")),
                                                                "yellow" => Ok(String::from("#ffff00")),
                                                                "magenta" => Ok(String::from("#ff00ff")),
                                                                "cyan" => Ok(String::from("#00ffff")),
                                                                "white" => Ok(String::from("#ffffff")),
                                                                "gray" | "grey" => Ok(String::from("#808080")),
                                                                unknown => {
                                                                        if unknown.starts_with('#') && unknown.len() > 2 {
                                                                                // parsing hex round trip to make sure it's in a good format
                                                                                Ok(rgb2hex(&hex2rgb(unknown, &options), &options))
                                                                        } else {
                                                                                Err(format!("The gradient color \"{}\" is not supported.\nAllowed options are: black, red, green, blue, yellow, magenta, cyan, white, gray, grey", color(unknown, Colors::Green)))
                                                                        }
                                                                }
                                                        }).collect::<Result<Vec<String>,String>>()?;

                                                let transition_options = options_lookup.get("-t").unwrap();
                                                let is_transition = my_args.contains(&transition_options.name.to_string())
                                                        || my_args.contains(&transition_options.shortcut.to_string())
                                                        || options.transition_gradient;
                                                if is_transition && options.gradient.len() < 2 {
                                                        return Err(format!(
                                                                "You must specify at least two colors for transition gradients. You specified only \"{}\"",
                                                                color(&format!("{}", options.gradient.len()), Colors::Green)
                                                        ));
                                                }

                                                if !is_transition && options.gradient.len() != 2 {
                                                        return Err(format!(
                                                                "You must specify two colors for a gradient. You specified \"{}\"",
                                                                color(&format!("{}", options.gradient.len()), Colors::Green)
                                                        ));
                                                }
                                        }
                                        OptionType::Number => {
                                                i += 1;
                                                if i >= args_length {
                                                        return Err(format!("Missing value for option: {}", color(this_flag.name, Colors::Green)));
                                                }
                                                let number = match my_args[i].parse::<u16>() {
                                                        Ok(n) => n,
                                                        Err(_) => {
                                                                return Err(format!(
                                                                        "Could not read argument for option: {}. Needs to be a positive number but found instead: \"{}\"",
                                                                        color(this_flag.name, Colors::Green),
                                                                        color(&my_args[i], Colors::Green)
                                                                ));
                                                        }
                                                };

                                                match this_flag.key {
                                                        "letter_spacing" => {
                                                                options.letter_spacing = number;
                                                        }
                                                        "line_height" => {
                                                                options.line_height = number;
                                                        }
                                                        "max_length" => {
                                                                options.max_length = number;
                                                        }
                                                        "debug_level" => {
                                                                options.debug_level = number;
                                                        }
                                                        _ => {}
                                                }
                                        }
                                        OptionType::Bool => match this_flag.key {
                                                "version" => {
                                                        options.version = true;
                                                }
                                                "help" => {
                                                        options.help = true;
                                                }
                                                "spaceless" => {
                                                        options.spaceless = true;
                                                }
                                                "independent_gradient" => {
                                                        options.independent_gradient = true;
                                                }
                                                "transition_gradient" => {
                                                        options.transition_gradient = true;
                                                }
                                                "debug" => {
                                                        options.debug = true;
                                                }
                                                "raw_mode" => {
                                                        options.raw_mode = true;
                                                }
                                                _ => {}
                                        },
                                        OptionType::Env => {
                                                i += 1;
                                                if i >= args_length {
                                                        return Err(format!("Missing value for option: {}", color(this_flag.name, Colors::Green)));
                                                }
                                                options.env = match my_args[i].to_lowercase().as_str() {
                                                        "node" | "cli" => Env::Cli,
                                                        "browser" => Env::Browser,
                                                        unknown => {
                                                                return Err(format!(
                                                                        "The env option \"{}\" is not supported.\nAllowed options are: {}",
                                                                        color(unknown, Colors::Green),
                                                                        color(&Env::list(), Colors::Green)
                                                                ));
                                                        }
                                                };
                                        }
                                }
                        }
                        None => {
                                /* We ignore flags we don't recognize */
                                d(&format!("CLI flag \"{}\" was ignored", my_args[i]), 1, Dt::Log, &options, &mut std::io::stdout());
                                // note this will only debug print flags after the encounter the debug flag
                        }
                };

                // iterating to next loop count
                i += 1;
        }

        Ok(options)
}

1	//! The contents of this module is all about parsing cli arguments
2	use std::collections::HashMap;
3
4	use crate::color::{color, get_foreground_color, hex2rgb, rgb2hex};
5	use crate::config::{
6	Align, BgColors, CliOption, Colors, Env, Fonts, OptionType, Options, CLIOPTIONS, GRADIENTS_AGENDER,
7	GRADIENTS_AROMANTIC, GRADIENTS_ASEXUAL, GRADIENTS_BISEXUAL, GRADIENTS_GENDERFLUID, GRADIENTS_GENDERQUEER,
8	GRADIENTS_INTERSEX, GRADIENTS_LESBIAN, GRADIENTS_NONBINARY, GRADIENTS_PANSEXUAL, GRADIENTS_POLYSEXUAL,
9	GRADIENTS_PRIDE, GRADIENTS_TRANSGENDER,
10	};
11	use crate::debug::{d, Dt};
12
13	/// This function converts command line arguments into an [`Options`] struct
14	///
15	/// ```rust
16	/// extern crate cfonts;
17	///
18	/// use cfonts::{ Options, Align, Colors, BgColors, Fonts, Env };
19	/// use cfonts::args::parse;
20	///
21	/// let mut options = Options::default();
22	/// options.text = "long text\|with new line".to_string();
23	/// options.font = Fonts::FontSimple3d;
24	/// options.align = Align::Center;
25	/// options.colors = vec![Colors::Blue, Colors::White];
26	/// options.background = BgColors::CyanBright;
27	/// options.letter_spacing = 9;
28	/// options.line_height = 2;
29	/// options.spaceless = true;
30	/// options.max_length = 100;
31	/// options.gradient = vec!["#ff0000".to_string(), "#0000ff".to_string()];
32	/// options.independent_gradient = true;
33	/// options.transition_gradient = true;
34	/// options.env = Env::Browser;
35	/// options.raw_mode = true;
36	/// options.help = true;
37	/// options.version = true;
38	/// options.debug = true;
39	/// options.debug_level = 3;
40	///
41	/// // All shortcut flags
42	/// assert_eq!(
43	/// parse(vec![
44	/// "path/to/bin".to_string(),
45	/// "long text\|with new line".to_string(),
46	/// "-f".to_string(),
47	/// "simple3d".to_string(),
48	/// "-a".to_string(),
49	/// "center".to_string(),
50	/// "-c".to_string(),
51	/// "blue,white".to_string(),
52	/// "-b".to_string(),
53	/// "cyanBright".to_string(),
54	/// "-l".to_string(),
55	/// "9".to_string(),
56	/// "-z".to_string(),
57	/// "2".to_string(),
58	/// "-s".to_string(),
59	/// "-m".to_string(),
60	/// "100".to_string(),
61	/// "-g".to_string(),
62	/// "red,blue".to_string(),
63	/// "-i".to_string(),
64	/// "-t".to_string(),
65	/// "-e".to_string(),
66	/// "browser".to_string(),
67	/// "-r".to_string(),
68	/// "-h".to_string(),
69	/// "-v".to_string(),
70	/// "-d".to_string(),
71	/// "-x".to_string(),
72	/// "3".to_string(),
73	/// ])
74	/// .unwrap(),
75	/// options
76	/// );
77	///
78	/// // All shortcut flags but all boolean flags are stacked
79	/// assert_eq!(
80	/// parse(vec![
81	/// "path/to/bin".to_string(),
82	/// "long text\|with new line".to_string(),
83	/// "-f".to_string(),
84	/// "simple3d".to_string(),
85	/// "-a".to_string(),
86	/// "center".to_string(),
87	/// "-c".to_string(),
88	/// "blue,white".to_string(),
89	/// "-b".to_string(),
90	/// "cyanBright".to_string(),
91	/// "-l".to_string(),
92	/// "9".to_string(),
93	/// "-z".to_string(),
94	/// "2".to_string(),
95	/// "-sithvdr".to_string(), // <-- stacked boolean flags
96	/// "-m".to_string(),
97	/// "100".to_string(),
98	/// "-g".to_string(),
99	/// "red,blue".to_string(),
100	/// "-e".to_string(),
101	/// "browser".to_string(),
102	/// "-x".to_string(),
103	/// "3".to_string(),
104	/// ])
105	/// .unwrap(),
106	/// options
107	/// );
108	///
109	/// // All long-form flags
110	/// assert_eq!(
111	/// parse(vec![
112	/// "path/to/bin".to_string(),
113	/// "long text\|with new line".to_string(),
114	/// "--font".to_string(),
115	/// "simple3d".to_string(),
116	/// "--align".to_string(),
117	/// "center".to_string(),
118	/// "--colors".to_string(),
119	/// "blue,white".to_string(),
120	/// "--background".to_string(),
121	/// "cyanBright".to_string(),
122	/// "--letter-spacing".to_string(),
123	/// "9".to_string(),
124	/// "--line-height".to_string(),
125	/// "2".to_string(),
126	/// "--spaceless".to_string(),
127	/// "--independent-gradient".to_string(),
128	/// "--transition-gradient".to_string(),
129	/// "--help".to_string(),
130	/// "--version".to_string(),
131	/// "--debug".to_string(),
132	/// "--raw-mode".to_string(),
133	/// "--max-length".to_string(),
134	/// "100".to_string(),
135	/// "--gradient".to_string(),
136	/// "red,blue".to_string(),
137	/// "--env".to_string(),
138	/// "browser".to_string(),
139	/// "--debug-level".to_string(),
140	/// "3".to_string(),
141	/// ])
142	/// .unwrap(),
143	/// options
144	/// );
145	/// ```
146	pub fn parse(args: Vec<String>) -> Result<Options, String> {	586✔
147	let mut my_args = args;	586✔
148	let mut options = Options::default();	586✔
149		586✔
150	// create a lookup table for our CLIOPTIONS	586✔
151	let mut options_lookup: HashMap<String, CliOption> = HashMap::new();	586✔
152
153	for option in CLIOPTIONS {	10,548✔
154	let name = option.name.to_string();	9,962✔
155	let shortcut = option.shortcut.to_string();	9,962✔
156	options_lookup.insert(name, option.clone());	9,962✔
157	options_lookup.insert(shortcut, option.clone());	9,962✔
158	if !option.fallback_shortcut.is_empty() {	9,962✔
159	let shortcut = option.fallback_shortcut.to_string();	586✔
160	options_lookup.insert(shortcut, option);	586✔
161	}	9,376✔
162	}
163
164	// we check for the debug flag to make sure we send debug messages in this function as well
165	let debug_options = options_lookup.get("-d").unwrap();	586✔
166	let enabled_debug =	586✔
167	my_args.contains(&debug_options.name.to_string()) \|\| my_args.contains(&debug_options.shortcut.to_string());	586✔
168	if enabled_debug {	586✔
169	options.debug = true;	6✔
170	}	580✔
171
172	// we check for the line_height flag to make sure we don't override it with the console font
173	let line_height_options = options_lookup.get("-z").unwrap();	586✔
174	let line_height_changed = my_args.contains(&line_height_options.name.to_string())	586✔
175	\|\| my_args.contains(&line_height_options.shortcut.to_string());	585✔
176
177	d("args::parse()", 1, Dt::Head, &options, &mut std::io::stdout());	586✔
178		586✔
179	if my_args.len() < 2 {	586✔
180	let (start, end) = get_foreground_color(&Colors::Green);	1✔
181	return Err(format!(	1✔
182	"Please provide text to convert with: {start}cfonts \"Text\"{end}\nRun {start}cfonts --help{end} for more infos",	1✔
183	start = start,	1✔
184	end = end	1✔
185	));	1✔
186	}	585✔
187		585✔
188	let version_options = options_lookup.get("-v").unwrap();	585✔
189	if my_args[1] == *version_options.shortcut.to_string()	585✔
190	\|\| my_args[1] == *version_options.name.to_string()	583✔
191	\|\| my_args[1] == *version_options.fallback_shortcut.to_string()	582✔
192	{	4✔
193	options.version = true;	4✔
194	}	581✔
195
196	let help_options = options_lookup.get("-h").unwrap();	585✔
197	if my_args[1] == help_options.shortcut.to_string() \|\| my_args[1] == help_options.name.to_string() {	585✔
198	options.help = true;	3✔
199	}	582✔
200
201	// our text to be converted
202	options.text = my_args[1].clone();	585✔
203		585✔
204	let mut args_length = my_args.len();	585✔
205	let mut i = 2; // we skip the first two arguments as the first is path to binary and the second we already take care of above	585✔
206	// we iterate over all arguments and match them with our lookup table
207	while i < args_length {	1,258✔
208	// before we see if this flag exists in our lookup we see if boolean flags have been stacked here
209	if my_args[i].starts_with('-') && !my_args[i].starts_with("--") && my_args[i].len() > 2 {	689✔
210	// we know that this is a stack of boolean flags
211	let this_flag = my_args[i].clone();	3✔
212	let mut middle_flags = Vec::new();	3✔
213
214	// unwrap is guarded by if clause it's contained in
215	for flag in this_flag.strip_prefix('-').unwrap().chars() {	16✔
216	let flag_name = format!("-{}", flag);	16✔
217	if options_lookup.get(&flag_name).is_some() {	16✔
218	middle_flags.push(flag_name);	16✔
219	}	16✔
220	}
221
222	my_args.splice(i..i + 1, middle_flags.iter().cloned());	3✔
223	args_length = my_args.len();	3✔
224	}	686✔
225
226	match options_lookup.get(&my_args[i]) {	689✔
227	Some(this_flag) => {	687✔
228	match this_flag.kind {	687✔
229	OptionType::Text => { /* Only Text type is on argvs[1] */ }	×
230	OptionType::Font => {
231	i += 1;	60✔
232	if i >= args_length {	60✔
233	return Err(format!("Missing value for option: {}", color(this_flag.name, Colors::Green)));	1✔
234	}	59✔
235	options.font = match my_args[i].to_lowercase().as_str() {	59✔
236	"console" => Fonts::FontConsole,	59✔
237	"block" => Fonts::FontBlock,	43✔
238	"simpleblock" => Fonts::FontSimpleBlock,	40✔
239	"simple" => Fonts::FontSimple,	37✔
240	"3d" => Fonts::Font3d,	34✔
241	"simple3d" => Fonts::FontSimple3d,	31✔
242	"chrome" => Fonts::FontChrome,	25✔
243	"huge" => Fonts::FontHuge,	22✔
244	"shade" => Fonts::FontShade,	19✔
245	"slick" => Fonts::FontSlick,	16✔
246	"grid" => Fonts::FontGrid,	13✔
247	"pallet" => Fonts::FontPallet,	10✔
248	"tiny" => Fonts::FontTiny,	7✔
249	unknown => {	1✔
250	return Err(format!(	1✔
251	"The font \"{}\" is not supported.\nAllowed options are: {}",	1✔
252	color(unknown, Colors::Green),	1✔
253	color(&Fonts::list(), Colors::Green)	1✔
254	));	1✔
255	}
256	};
257
258	if options.font == Fonts::FontConsole && !line_height_changed {	58✔
259	options.line_height = 0;	14✔
260	}	44✔
261	}
262	OptionType::Align => {
263	i += 1;	21✔
264	if i >= args_length {	21✔
265	return Err(format!("Missing value for option: {}", color(this_flag.name, Colors::Green)));	1✔
266	}	20✔
267	options.align = match my_args[i].to_lowercase().as_str() {	20✔
268	"left" => Align::Left,	20✔
269	"center" => Align::Center,	19✔
270	"right" => Align::Right,	10✔
271	"top" => Align::Top,	7✔
272	"bottom" => Align::Bottom,	4✔
273	unknown => {	1✔
274	return Err(format!(	1✔
275	"The alignment option \"{}\" is not supported.\nAllowed options are: {}",	1✔
276	color(unknown, Colors::Green),	1✔
277	color(&Align::list(), Colors::Green)	1✔
278	));	1✔
279	}
280	};
281	}
282	OptionType::Colors => {
283	i += 1;	264✔
284	if i >= args_length {	264✔
285	return Err(format!("Missing value for option: {}", color(this_flag.name, Colors::Green)));	1✔
286	}	263✔
287	options.colors = my_args[i]	263✔
288	.to_lowercase()	263✔
289	.as_str()	263✔
290	.split(',')	263✔
291	.map(\|this_color\| match this_color {	496✔
292	"system" => Ok(Colors::System),	496✔
293	"black" => Ok(Colors::Black),	484✔
294	"red" => Ok(Colors::Red),	472✔
295	"green" => Ok(Colors::Green),	444✔
296	"yellow" => Ok(Colors::Yellow),	427✔
297	"blue" => Ok(Colors::Blue),	415✔
298	"magenta" => Ok(Colors::Magenta),	283✔
299	"cyan" => Ok(Colors::Cyan),	271✔
300	"white" => Ok(Colors::White),	259✔
301	"gray" => Ok(Colors::Gray),	244✔
302	"grey" => Ok(Colors::Gray),	232✔
303	"redbright" => Ok(Colors::RedBright),	220✔
304	"greenbright" => Ok(Colors::GreenBright),	208✔
305	"yellowbright" => Ok(Colors::YellowBright),	196✔
306	"bluebright" => Ok(Colors::BlueBright),	184✔
307	"magentabright" => Ok(Colors::MagentaBright),	172✔
308	"cyanbright" => Ok(Colors::CyanBright),	160✔
309	"whitebright" => Ok(Colors::WhiteBright),	148✔
310	"candy" => Ok(Colors::Candy),	136✔
311	unknown => {	130✔
312	if unknown.starts_with('#') && unknown.len() > 2 {	130✔
313	Ok(Colors::Rgb(hex2rgb(unknown, &options)))	129✔
314	} else {
315	Err(format!(	1✔
316	"The color \"{}\" is not supported.\nAllowed options are: {}",	1✔
317	color(unknown, Colors::Green),	1✔
318	color(&Colors::list(), Colors::Green)	1✔
319	))	1✔
320	}
321	}
322	})	496✔
323	.collect::<Result<Vec<Colors>, String>>()?;	263✔
324	}
325	OptionType::BgColor => {
326	i += 1;	135✔
327	if i >= args_length {	135✔
328	return Err(format!("Missing value for option: {}", color(this_flag.name, Colors::Green)));	1✔
329	}	134✔
330	options.background = match my_args[i].to_lowercase().as_str() {	134✔
331	"transparent" => BgColors::Transparent,	134✔
332	"black" => BgColors::Black,	128✔
333	"red" => BgColors::Red,	122✔
334	"green" => BgColors::Green,	116✔
335	"yellow" => BgColors::Yellow,	110✔
336	"blue" => BgColors::Blue,	104✔
337	"magenta" => BgColors::Magenta,	97✔
338	"cyan" => BgColors::Cyan,	91✔
339	"white" => BgColors::White,	85✔
340	"gray" => BgColors::Gray,	79✔
341	"grey" => BgColors::Gray,	73✔
342	"redbright" => BgColors::RedBright,	67✔
343	"greenbright" => BgColors::GreenBright,	61✔
344	"yellowbright" => BgColors::YellowBright,	55✔
345	"bluebright" => BgColors::BlueBright,	49✔
346	"magentabright" => BgColors::MagentaBright,	43✔
347	"cyanbright" => BgColors::CyanBright,	37✔
348	"whitebright" => BgColors::WhiteBright,	28✔
349	unknown => {	22✔
350	if unknown.starts_with('#') && unknown.len() > 2 {	22✔
351	BgColors::Rgb(hex2rgb(unknown, &options))	21✔
352	} else {
353	return Err(format!(	1✔
354	"The background color \"{}\" is not supported.\nAllowed options are: {}",	1✔
355	color(unknown, Colors::Green),	1✔
356	color(&BgColors::list(), Colors::Green)	1✔
357	));	1✔
358	}
359	}
360	};
361	}
362	OptionType::Gradient => {
363	i += 1;	100✔
364	if i >= args_length {	100✔
365	return Err(format!("Missing value for option: {}", color(this_flag.name, Colors::Green)));	1✔
366	}	99✔
367	let expanded_args = match my_args[i].to_lowercase().as_str() {	99✔
368	"lgbt" \| "lgbtq" \| "lgbtqa" \| "pride" => {	99✔
369	options.transition_gradient = true;	6✔
370	GRADIENTS_PRIDE.join(",")	6✔
371	}
372	"agender" => {	93✔
373	options.transition_gradient = true;	1✔
374	GRADIENTS_AGENDER.join(",")	1✔
375	}
376	"aromantic" => {	92✔
377	options.transition_gradient = true;	1✔
378	GRADIENTS_AROMANTIC.join(",")	1✔
379	}
380	"asexual" => {	91✔
381	options.transition_gradient = true;	1✔
382	GRADIENTS_ASEXUAL.join(",")	1✔
383	}
384	"bisexual" \| "bi" => {	90✔
385	options.transition_gradient = true;	2✔
386	GRADIENTS_BISEXUAL.join(",")	2✔
387	}
388	"genderfluid" => {	88✔
389	options.transition_gradient = true;	1✔
390	GRADIENTS_GENDERFLUID.join(",")	1✔
391	}
392	"genderqueer" => {	87✔
393	options.transition_gradient = true;	1✔
394	GRADIENTS_GENDERQUEER.join(",")	1✔
395	}
396	"intersex" => {	86✔
397	options.transition_gradient = true;	1✔
398	GRADIENTS_INTERSEX.join(",")	1✔
399	}
400	"lesbian" => {	85✔
401	options.transition_gradient = true;	1✔
402	GRADIENTS_LESBIAN.join(",")	1✔
403	}
404	"nonbinary" => {	84✔
405	options.transition_gradient = true;	1✔
406	GRADIENTS_NONBINARY.join(",")	1✔
407	}
408	"pansexual" \| "pan" => {	83✔
409	options.transition_gradient = true;	2✔
410	GRADIENTS_PANSEXUAL.join(",")	2✔
411	}
412	"polysexual" \| "poly" => {	81✔
413	options.transition_gradient = true;	2✔
414	GRADIENTS_POLYSEXUAL.join(",")	2✔
415	}
416	"transgender" \| "trans" => {	79✔
417	options.transition_gradient = true;	2✔
418	GRADIENTS_TRANSGENDER.join(",")	2✔
419	}
420	unknown => unknown.to_string(),	77✔
421	};
422
423	options.gradient = expanded_args	99✔
424	.split(',')	99✔
425	.map(\|this_color\| match this_color {	262✔
426	"black" => Ok(String::from("#000000")),	262✔
427	"red" => Ok(String::from("#ff0000")),	254✔
428	"green" => Ok(String::from("#00ff00")),	233✔
429	"blue" => Ok(String::from("#0000ff")),	166✔
430	"yellow" => Ok(String::from("#ffff00")),	153✔
431	"magenta" => Ok(String::from("#ff00ff")),	151✔
432	"cyan" => Ok(String::from("#00ffff")),	143✔
433	"white" => Ok(String::from("#ffffff")),	135✔
434	"gray" \| "grey" => Ok(String::from("#808080")),	127✔
435	unknown => {	111✔
436	if unknown.starts_with('#') && unknown.len() > 2 {	111✔
437	// parsing hex round trip to make sure it's in a good format
438	Ok(rgb2hex(&hex2rgb(unknown, &options), &options))	110✔
439	} else {
440	Err(format!("The gradient color \"{}\" is not supported.\nAllowed options are: black, red, green, blue, yellow, magenta, cyan, white, gray, grey", color(unknown, Colors::Green)))	1✔
441	}
442	}
443	}).collect::<Result<Vec<String>,String>>()?;	262✔
444
445	let transition_options = options_lookup.get("-t").unwrap();	98✔
446	let is_transition = my_args.contains(&transition_options.name.to_string())	98✔
447	\|\| my_args.contains(&transition_options.shortcut.to_string())	97✔
448	\|\| options.transition_gradient;	92✔
449	if is_transition && options.gradient.len() < 2 {	98✔
450	return Err(format!(	1✔
451	"You must specify at least two colors for transition gradients. You specified only \"{}\"",	1✔
452	color(&format!("{}", options.gradient.len()), Colors::Green)	1✔
453	));	1✔
454	}	97✔
455		97✔
456	if !is_transition && options.gradient.len() != 2 {	97✔
457	return Err(format!(	1✔
458	"You must specify two colors for a gradient. You specified \"{}\"",	1✔
459	color(&format!("{}", options.gradient.len()), Colors::Green)	1✔
460	));	1✔
461	}	96✔
462	}
463	OptionType::Number => {
464	i += 1;	26✔
465	if i >= args_length {	26✔
466	return Err(format!("Missing value for option: {}", color(this_flag.name, Colors::Green)));	1✔
467	}	25✔
468	let number = match my_args[i].parse::<u16>() {	25✔
469	Ok(n) => n,	24✔
470	Err(_) => {
471	return Err(format!(	1✔
472	"Could not read argument for option: {}. Needs to be a positive number but found instead: \"{}\"",	1✔
473	color(this_flag.name, Colors::Green),	1✔
474	color(&my_args[i], Colors::Green)	1✔
475	));	1✔
476	}
477	};
478
479	match this_flag.key {	24✔
480	"letter_spacing" => {	24✔
481	options.letter_spacing = number;	7✔
482	}	7✔
483	"line_height" => {	17✔
484	options.line_height = number;	7✔
485	}	7✔
486	"max_length" => {	10✔
487	options.max_length = number;	7✔
488	}	7✔
489	"debug_level" => {	3✔
490	options.debug_level = number;	3✔
491	}	3✔
492	_ => {}	×
493	}
494	}
495	OptionType::Bool => match this_flag.key {	69✔
496	"version" => {	69✔
497	options.version = true;	9✔
498	}	9✔
499	"help" => {	60✔
500	options.help = true;	9✔
501	}	9✔
502	"spaceless" => {	51✔
503	options.spaceless = true;	8✔
504	}	8✔
505	"independent_gradient" => {	43✔
506	options.independent_gradient = true;	7✔
507	}	7✔
508	"transition_gradient" => {	36✔
509	options.transition_gradient = true;	8✔
510	}	8✔
511	"debug" => {	28✔
512	options.debug = true;	9✔
513	}	9✔
514	"raw_mode" => {	19✔
515	options.raw_mode = true;	19✔
516	}	19✔
UNCOV 517	_ => {}	×
518	},
519	OptionType::Env => {
520	i += 1;	12✔
521	if i >= args_length {	12✔
522	return Err(format!("Missing value for option: {}", color(this_flag.name, Colors::Green)));	1✔
523	}	11✔
524	options.env = match my_args[i].to_lowercase().as_str() {	11✔
525	"node" \| "cli" => Env::Cli,	11✔
526	"browser" => Env::Browser,	9✔
527	unknown => {	1✔
528	return Err(format!(	1✔
529	"The env option \"{}\" is not supported.\nAllowed options are: {}",	1✔
530	color(unknown, Colors::Green),	1✔
531	color(&Env::list(), Colors::Green)	1✔
532	));	1✔
533	}
534	};
535	}
536	}
537	}
538	None => {	2✔
539	/* We ignore flags we don't recognize */	2✔
540	d(&format!("CLI flag \"{}\" was ignored", my_args[i]), 1, Dt::Log, &options, &mut std::io::stdout());	2✔
541	// note this will only debug print flags after the encounter the debug flag	2✔
542	}	2✔
543	};
544
545	// iterating to next loop count
546	i += 1;	673✔
547	}
548
549	Ok(options)	569✔
550	}	586✔

dominikwilkowski / cfonts / 9507989191

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous