clars 0.3.0

Command line arguments resolver
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

use crate::evaluator::Value;
use crate::messages;
use crate::model::{ClarDefinition, ClarItem};
use crate::path::{ClarPath, IntoClarPath};
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.
  definition: ClarDefinition,
  /// Color mode.
  cm: ColorMode,
}

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

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

  /// Returns `true` if an option with the given path
  /// appears in the short form in the command line.
  pub fn is_short(&self, path: impl IntoClarPath) -> bool {
    let path: ClarPath = path.into_clar_path();
    self
      .values
      .iter()
      .any(|v| matches!(v, Value::ShortOption(option_path, _) if path.eq(option_path)))
  }

  /// Returns `true` if option with the given path
  /// appears in the long form in the command line.
  pub fn is_long(&self, path: impl IntoClarPath) -> bool {
    let path: ClarPath = path.into_clar_path();
    self
      .values
      .iter()
      .any(|v| matches!(v, Value::LongOption(option_path, _) if path.eq(option_path)))
  }

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

  /// Returns values associated with option, command or argument
  /// with the given path; values of all appearances are returned.
  pub fn get_values(&self, path: impl IntoClarPath) -> Vec<Option<String>> {
    let path: ClarPath = path.into_clar_path();
    let mut values = self
      .values
      .iter()
      .filter(|v| path.eq(v.path()))
      .flat_map(|v| v.value())
      .collect::<Vec<Option<String>>>();
    println!("DDD: c = {}", values.is_empty());
    if values.is_empty()
      && let value @ Some(_) = self.default_value(&path)
    {
      values.push(value);
    }
    values
  }

  /// Returns the value of the first resolved option, command or argument
  /// with the given path.
  pub fn get_first_value(&self, path: impl IntoClarPath) -> Option<String> {
    println!("DDD: b");
    self.get_values(path).first().cloned().flatten()
  }

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

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

  pub fn get_help_command(&self, path: impl IntoClarPath) -> Text {
    messages::get_help_text_for_command(&self.app, &path.into_clar_path(), &self.definition, false, self.cm)
  }

  pub fn get_help_long_command(&self, path: impl IntoClarPath) -> Text {
    messages::get_help_text_for_command(&self.app, &path.into_clar_path(), &self.definition, true, self.cm)
  }

  fn default_value(&self, path: &ClarPath) -> Option<String> {
    println!("DDD: a");
    for item in self.definition.items() {
      match item {
        ClarItem::Options(options) => {
          for option in options {
            if option.get_path() == path && option.get_takes_value().is_some() {
              return option.get_default_value().clone();
            }
          }
        }
        ClarItem::Arguments(arguments) => {
          for argument in arguments {
            if argument.get_path() == path {
              return argument.get_default_value().clone();
            }
          }
        }
        _ => {}
      }
    }
    None
  }
}