mysh 0.1.8

Scaffolding to build interactive shells
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

use anyhow::anyhow;
use serde::de;
use uuid::Uuid;

pub trait CommandArg {
  fn display_help() -> Vec<&'static str>;
}

impl CommandArg for String {
  fn display_help() -> Vec<&'static str> {
    vec!["[string]"]
  }
}

impl CommandArg for i64 {
  fn display_help() -> Vec<&'static str> {
    vec!["[i64]"]
  }
}

impl CommandArg for i32 {
  fn display_help() -> Vec<&'static str> {
    vec!["[i32]"]
  }
}

impl CommandArg for f32 {
  fn display_help() -> Vec<&'static str> {
    vec!["[f32]"]
  }
}

impl CommandArg for Uuid {
  fn display_help() -> Vec<&'static str> {
    vec!["[uuid]"]
  }
}

impl<T> CommandArg for Option<T>
where
  T: CommandArg,
{
  fn display_help() -> Vec<&'static str> {
    // @todo: properly format
    // let inner = T::display_help();
    // if inner.len() == 1 && let Some(first) = inner.get(0) && !first.starts_with("--") {
    //   return vec![format]
    // }
    let help = &mut T::display_help();
    if help.len() == 0 {
      return vec![];
    }

    let mut opt = vec!["<Optional>"];
    opt.append(help);
    opt
  }
}

pub fn parse_arguments<T>(argv: Vec<String>) -> Result<T, anyhow::Error>
where
  T: de::DeserializeOwned + CommandArg,
{
  // println!("--argv {:#?}", argv);

  if argv.len() == 1 {
    return Ok(serde_json::from_str("null")?);
  }

  if argv.len() == 2 {
    let only = argv.get(1).expect("");
    let ser = serde_json::to_string(&only)?;
    return Ok(serde_json::from_str(&ser)?);
  }

  use serde_json::Map;
  let mut map: Map<String, serde_json::Value> = Map::new();
  let mut key: Option<String> = None;
  for (i, arg) in argv.iter().enumerate() {
    // println!("[]: {arg}");
    if i == 0 {
      continue;
    }

    if arg.starts_with("--") {
      let arg = arg.trim_start_matches("--");
      if key.is_some() {
        return Err(anyhow!("option without param"));
      }
      key = Some(arg.to_owned());
    } else {
      let Some(unwrapped_key) = key else {
        return Err(anyhow!("param without option"));
      };
      match arg.parse::<i64>() {
        Ok(n) => {
          map.insert(
            unwrapped_key,
            serde_json::Value::Number(serde_json::Number::from(n as i64)),
          );
        }
        Err(_) => {
          map.insert(unwrapped_key, serde_json::Value::String(arg.to_string()));
        }
      }
      key = None;
    }
  }
  let ser = serde_json::to_string(&map)?;
  return Ok(serde_json::from_str(&ser)?);
}