finchie/new_manual - Change YTW5RB26IF3MHIED6RA3AQ7KAZHPLABJ63WFSGAO6FAATFFCP4UAC

Refactor argument type handling into enum

Not much has changed visually but should be a good basis to build more sophisticated visualizations on top of

Created by finchie on November 20, 2023

YTW5RB26IF3MHIED6RA3AQ7KAZHPLABJ63WFSGAO6FAATFFCP4UAC

Dependencies

In channels

main

Change contents

Insertion in src/arg.rs at line 1 [3.640]

[3.640]

[3.641]

use clap::builder::{RangedI64ValueParser, RangedU64ValueParser, ValueParser};

Replacement in src/arg.rs at line 3 [3.640]
B:BD[3.672] → [3.672:703]
```
use clap::{value_parser, Arg};
```
[3.672]
[3.703]
```
use clap::{Arg, ValueHint};
```

Replacement in src/arg.rs at line 8 [3.640]

B:BD[3.814] → [3.814:847]

#[non_exhaustive]
enum ArgType {

[3.814]

[3.847]

enum ValueType {
    Path,
    Command,
    Name,
    Url,
    Email,

Replacement in src/arg.rs at line 15 [3.640]
B:BD[3.859] → [3.859:870]
```
    Other,
```
[3.859]
[3.870]
```
    Range,
    Bool,
    Enum,
    Map,
    Unknown,
```

Replacement in src/arg.rs at line 22 [3.640]

B:BD[3.873] → [3.873:903]

impl From<&Arg> for ArgType {

[3.873]

[3.903]

impl ValueType {
    fn name(&self) -> &str {
        match self {
            Self::Path => "path",
            Self::Command => "command",
            Self::Name => "name",
            Self::Url => "url",
            Self::Email => "email",
            Self::String => "string",
            Self::Range => "range",
            Self::Bool => "bool",
            Self::Enum => "enum",
            Self::Map => "map",
            Self::Unknown => "unknown",
        }
    }
}
impl From<&Arg> for ValueType {

Replacement in src/arg.rs at line 42 [3.640]

B:BD[3.938] → [3.938:1118]

        let type_id = value.get_value_parser().type_id();
        if type_id == value_parser!(String).type_id() {
            Self::String
        } else {
            Self::Other

[3.938]

[3.1118]

        match value.get_value_hint() {
            ValueHint::AnyPath => Self::Path,
            ValueHint::FilePath => Self::Path,
            ValueHint::DirPath => Self::Path,
            ValueHint::ExecutablePath => Self::Path,
            ValueHint::CommandName => Self::Command,
            ValueHint::CommandString => Self::Command,
            ValueHint::CommandWithArguments => Self::Command,
            ValueHint::Username => Self::Name,
            ValueHint::Hostname => Self::Name,
            ValueHint::Url => Self::Url,
            ValueHint::EmailAddress => Self::Email,
            _ => {
                let type_id = value.get_value_parser().type_id();
                if type_id == ValueParser::new(RangedU64ValueParser::<u8>::new()).type_id() {
                    Self::Range
                } else if type_id == ValueParser::new(RangedU64ValueParser::<u16>::new()).type_id()
                {
                    Self::Range
                } else if type_id == ValueParser::new(RangedU64ValueParser::<u32>::new()).type_id()
                {
                    Self::Range
                } else if type_id == ValueParser::new(RangedU64ValueParser::<u64>::new()).type_id()
                {
                    Self::Range
                } else if type_id == ValueParser::new(RangedI64ValueParser::<i8>::new()).type_id() {
                    Self::Range
                } else if type_id == ValueParser::new(RangedI64ValueParser::<i16>::new()).type_id()
                {
                    Self::Range
                } else if type_id == ValueParser::new(RangedI64ValueParser::<i32>::new()).type_id()
                {
                    Self::Range
                } else if type_id == ValueParser::new(RangedI64ValueParser::<i64>::new()).type_id()
                {
                    Self::Range
                } else if type_id == ValueParser::string().type_id() {
                    Self::String
                } else {
                    Self::Unknown
                }
            }

Replacement in src/arg.rs at line 89 [3.640]

B:BD[3.1201] → [3.1201:1258]

B:BD[3.1258] → [2.0:127]

    let supported_type_description = ArgType::from(arg);
    el::span(match supported_type_description {
        ArgType::String => "string",
        ArgType::Other => "other",
    })

[3.1201]

[3.1516]

    let value_type = ValueType::from(arg);
    el::details(el::summary(value_type.name().to_string()))