pathmut 0.8.0

Command line utility for manipulating path strings
Documentation 
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use clap::builder::PossibleValue;
use clap::ValueEnum;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Command {
    Get,
    Set,
    Replace,
    Delete,
    Has,
    Is,
    Convert,
    Info,
    Depth,
}

impl TryFrom<&str> for Command {
    type Error = ();

    fn try_from(s: &str) -> Result<Self, Self::Error> {
        use Command::*;
        let command = match s {
            "get" => Get,
            "set" => Set,
            "replace" => Replace,
            "delete" => Delete,
            "has" => Has,
            "is" => Is,
            "convert" => Convert,
            "info" => Info,
            "depth" => Depth,
            _ => Err(())?,
        };
        Ok(command)
    }
}

impl ValueEnum for Command {
    fn value_variants<'a>() -> &'a [Self] {
        &[
            Command::Get,
            Command::Set,
            Command::Replace,
            Command::Delete,
            Command::Has,
            Command::Is,
            Command::Convert,
            Command::Info,
            Command::Depth,
        ]
    }

    fn to_possible_value(&self) -> Option<PossibleValue> {
        use Command::*;
        let s = match self {
            Get => "get",
            Set => "set",
            Replace => "replace",
            Delete => "delete",
            Has => "has",
            Is => "is",
            Convert => "convert",
            Info => "info",
            Depth => "depth",
        };
        Some(PossibleValue::new(s))
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Question {
    Absolute,
    Relative,
    Unix,
    Windows,
    Url,
}

impl ValueEnum for Question {
    fn value_variants<'a>() -> &'a [Self] {
        &[
            Question::Absolute,
            Question::Relative,
            Question::Unix,
            Question::Windows,
            Question::Url,
        ]
    }

    fn to_possible_value(&self) -> Option<PossibleValue> {
        use Question::*;
        let s = match self {
            Absolute => "absolute",
            Relative => "relative",
            Unix => "unix",
            Windows => "windows",
            Url => "url",
        };
        Some(PossibleValue::new(s))
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PathKind {
    Unix,
    Windows,
}

impl ValueEnum for PathKind {
    fn value_variants<'a>() -> &'a [Self] {
        &[PathKind::Unix, PathKind::Windows]
    }

    fn to_possible_value(&self) -> Option<PossibleValue> {
        let s = match self {
            Self::Unix => "unix",
            Self::Windows => "win",
        };
        Some(PossibleValue::new(s))
    }
}