pipelight_utils 0.2.9

A set of trivial utilities for command line tools
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

use crate::git::types::Special::*;
use crate::git::types::{Flag, Hook, Special};
use convert_case::{Case, Casing};
use log::error;
use std::fmt;
use std::process::exit;
// Trait - Enum iteration workaround
use strum::IntoEnumIterator;

impl fmt::Display for Hook {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{:?}", self)
    }
}
impl From<&String> for Special {
    fn from(action: &String) -> Special {
        // let cased: &str = &action.to_case(Case::Snake);
        let cased: &str = &action.to_case(Case::Kebab);
        match cased {
            "manual" => Manual,
            "blank" => Blank,
            "watch" => Watch,
            _ => {
                let message = format!("The special flag {} is not known", cased);
                error!("{}", message);
                exit(1);
            }
        }
    }
}
impl From<&Special> for String {
    fn from(action: &Special) -> String {
        serde_plain::to_string::<Special>(action).unwrap()
    }
}

impl From<&String> for Hook {
    fn from(action: &String) -> Hook {
        // let cased: &str = &action.to_case(Case::Snake);
        let cased: &str = &action.to_case(Case::Kebab);
        serde_plain::from_str(cased).unwrap()
    }
}
impl From<&Hook> for String {
    fn from(action: &Hook) -> String {
        serde_plain::to_string::<Hook>(action).unwrap()
    }
}
impl From<&String> for Flag {
    fn from(action: &String) -> Flag {
        let cased: &String = &action.to_case(Case::Kebab);

        let specials: Vec<String> = Special::iter().map(|x| String::from(&x)).collect();
        let git_hooks: Vec<String> = Hook::iter().map(|x| String::from(&x)).collect();

        if specials.contains(cased) {
            Flag::Special(Special::from(cased))
        } else if git_hooks.contains(cased) {
            Flag::Hook(Hook::from(cased))
        } else {
            let message = format!("The special flag {} is not known", cased);
            error!("{}", message);
            panic!("{}", message);
        }
    }
}
impl From<&Flag> for String {
    fn from(action: &Flag) -> String {
        match action {
            Flag::Special(special) => String::from(special),
            Flag::Hook(hook) => String::from(hook),
        }
    }
}