clars 0.2.0

Command line arguments resolution system
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use crate::evaluator::Value;
use crate::messages;
use crate::model::ClarItem;
use antex::{ColorMode, Text};

/// Command line arguments matches.
#[derive(Debug)]
pub struct ClarMatches {
  /// Application name.
  app: String,
  /// Application description.
  description: Option<String>,
  /// Resolved values.
  values: Vec<Value>,
  /// Command line items.
  items: Vec<ClarItem>,
  /// Color mode.
  cm: ColorMode,
}

impl ClarMatches {
  pub(crate) fn new(
    app: String,
    description: Option<String>,
    values: Vec<Value>,
    items: Vec<ClarItem>,
    cm: ColorMode,
  ) -> Self {
    ClarMatches {
      app,
      description,
      values,
      items,
      cm,
    }
  }

  /// Returns raw values resolved from command line input.
  pub fn raw_values(&self) -> &[Value] {
    &self.values
  }

  /// Returns `true` if an option, subcommand, or argument with the given
  /// name appears at least once in the command line.
  pub fn is_present(&self, path: impl AsRef<str>) -> bool {
    let name = path.as_ref();
    self
      .values
      .iter()
      .any(|value| value.path() == name && value.is_present())
  }

  /// Returns `true` if option with the given name
  /// appears in the **short** form in the command line.
  pub fn is_short(&self, name: impl AsRef<str>) -> bool {
    let name = name.as_ref();
    self
      .values
      .iter()
      .any(|v| matches!(v, Value::ShortOption(option_name, _) if option_name == name))
  }

  /// Returns `true` if option with the given name
  /// appears in the **long** form in the command line.
  pub fn is_long(&self, name: impl AsRef<str>) -> bool {
    let name = name.as_ref();
    self
      .values
      .iter()
      .any(|v| matches!(v, Value::LongOption(option_name, _) if option_name == name))
  }

  /// Returns the number of appearances of the option, subcommand or argument
  /// with the given name in the command line.
  pub fn get_count(&self, name: impl AsRef<str>) -> usize {
    let name = name.as_ref();
    self
      .values
      .iter()
      .filter(|value| value.path() == name && value.is_present())
      .count()
  }

  /// Returns values associated with option, subcommand or argument
  /// with the given name; values of all appearances are returned.
  pub fn get_values(&self, name: impl AsRef<str>) -> Vec<Option<String>> {
    let name = name.as_ref();
    let mut values = self
      .values
      .iter()
      .filter(|v| v.path() == name)
      .flat_map(|v| v.value())
      .collect::<Vec<Option<String>>>();
    if values.is_empty()
      && let value @ Some(_) = self.default_value(name)
    {
      values.push(value);
    }
    values
  }

  /// Returns paths of all matched subcommands, options and arguments.
  pub fn get_paths(&self) -> Vec<String> {
    self.values.iter().map(|value| value.path().to_string()).collect()
  }

  pub fn get_help(&self) -> Text {
    messages::get_help(&self.app, &self.description, &self.items, false, self.cm)
  }

  pub fn get_help_long(&self) -> Text {
    messages::get_help(&self.app, &self.description, &self.items, true, self.cm)
  }

  pub fn get_help_command(&self, path: impl AsRef<str>) -> Text {
    messages::get_help_command(&self.app, path.as_ref(), &self.items, false, self.cm)
  }

  pub fn get_help_long_command(&self, path: impl AsRef<str>) -> Text {
    messages::get_help_command(&self.app, path.as_ref(), &self.items, true, self.cm)
  }

  fn default_value(&self, name: impl AsRef<str>) -> Option<String> {
    let name = name.as_ref();
    for item in &self.items {
      match item {
        ClarItem::Options(options) => {
          for option in options {
            if option.get_name() == name && option.get_takes_value().is_some() {
              return option.get_default_value().clone();
            }
          }
        }
        ClarItem::Arguments(arguments) => {
          for argument in arguments {
            if argument.get_name() == name {
              return argument.get_default_value().clone();
            }
          }
        }
        _ => {}
      }
    }
    None
  }
}