1use crate::command_line::{CommandLineAlg, ParseError, ParseErrorKind, Span, os_string, read};
2use alux_cli::{ArgumentInfo, Arity, CliWordAlg, CliWordsAlg, Conventions, SourceInfo};
3use std::{
4 ffi::{OsStr, OsString},
5 net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6},
6 num::{
7 NonZeroI8, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI128, NonZeroIsize, NonZeroU8, NonZeroU16, NonZeroU32,
8 NonZeroU64, NonZeroU128, NonZeroUsize,
9 },
10 path::PathBuf,
11};
12
13#[derive(Debug, Default, PartialEq, Eq)]
18pub struct Parsed {
19 positional: Vec<OsString>,
20 takes: Option<usize>,
22 unexpected: Option<(usize, OsString)>,
24 named: Vec<(String, OsString)>,
26}
27
28impl Parsed {
29 pub(crate) fn new(
32 arguments: &[ArgumentInfo],
33 words: &[OsString],
34 conventions: Conventions,
35 ) -> Result<Self, ParseError> {
36 let positions = arguments.iter().filter(|argument| matches!(argument.source, SourceInfo::Positional { .. }));
37 let takes_many = positions.clone().any(|argument| argument.arity == Arity::Many);
38 let takes = (!takes_many && !conventions.verbatim).then(|| positions.count());
40 let mut parsed = Self { takes, ..Self::default() };
41 read(arguments, words, conventions, &mut parsed)?;
42 if let Some((word, extra)) = parsed.unexpected {
43 let kind = ParseErrorKind::Unexpected(extra.to_string_lossy().into_owned());
44 return Err(ParseError { at: Span { word, byte: 0 }, kind });
45 }
46
47 Ok(parsed)
48 }
49
50 fn record(&mut self, argument: &ArgumentInfo, given: OsString) {
51 if let Some(key) = key(argument) {
52 self.named.push((key, given));
53 }
54 }
55}
56
57fn key(argument: &ArgumentInfo) -> Option<String> {
60 match &argument.source {
61 SourceInfo::Named { long, .. } => Some(long.clone()),
62 SourceInfo::Assigned { name } => Some(format!("{name}=")),
63 SourceInfo::Positional { .. } => None,
64 }
65}
66
67impl CommandLineAlg for Parsed {
69 fn switch(&mut self, argument: &ArgumentInfo) {
70 self.record(argument, OsString::new());
71 }
72
73 fn value(&mut self, argument: &ArgumentInfo, value: OsString) {
74 self.record(argument, value);
75 }
76
77 fn operand(&mut self, word: &OsStr, at: usize) {
78 if self.unexpected.is_none() && self.takes == Some(self.positional.len()) {
79 self.unexpected = Some((at, word.to_os_string()));
80 }
81 self.positional.push(word.to_os_string());
82 }
83}
84
85impl CliWordsAlg for Parsed {
86 type Word = OsString;
87
88 fn cli_words(&self, argument: &ArgumentInfo) -> Vec<OsString> {
89 match &argument.source {
90 SourceInfo::Positional { index } if argument.arity == Arity::Many => {
91 self.positional.get(*index..).unwrap_or_default().to_vec()
92 }
93 SourceInfo::Positional { index } => self.positional.get(*index).cloned().into_iter().collect(),
94 SourceInfo::Named { .. } | SourceInfo::Assigned { .. } => {
95 let key = key(argument);
96 self.named.iter().filter(|(own, _)| Some(own) == key.as_ref()).map(|(_, word)| word.clone()).collect()
97 }
98 }
99 }
100
101 fn cli_env(&self, name: &str) -> Option<OsString> {
102 std::env::var_os(name)
103 }
104
105 fn cli_default(&self, default: &'static str) -> OsString {
106 OsString::from(default)
107 }
108
109 fn cli_split(&self, word: OsString, delimiter: char) -> Vec<OsString> {
110 split(&word, delimiter)
111 }
112}
113
114pub(crate) fn split(word: &OsStr, delimiter: char) -> Vec<OsString> {
116 let mut encoded = [0; 4];
117 let delimiter = delimiter.encode_utf8(&mut encoded).as_bytes();
118 let bytes = word.as_encoded_bytes();
119 let mut parts = Vec::new();
120 let mut start = 0;
121 let mut at = 0;
122 while at + delimiter.len() <= bytes.len() {
123 if &bytes[at..at + delimiter.len()] == delimiter {
124 parts.push(os_string(&bytes[start..at]));
125 at += delimiter.len();
126 start = at;
127 } else {
128 at += 1;
129 }
130 }
131 parts.push(os_string(&bytes[start..]));
132 parts
133}
134
135pub trait DirectWord: Sized {
140 fn direct_word(word: &OsStr) -> Result<Self, String>;
146}
147
148macro_rules! text_words {
149 ($($value:ty),* $(,)?) => {
150 $(
151 impl DirectWord for $value {
152 fn direct_word(word: &OsStr) -> Result<Self, String> {
153 let text = word.to_str().ok_or_else(|| format!("`{}` is not UTF-8", word.to_string_lossy()))?;
154 text.parse().map_err(|error: <$value as std::str::FromStr>::Err| error.to_string())
155 }
156 }
157 )*
158 };
159}
160
161text_words!(
162 NonZeroI8,
163 NonZeroI16,
164 NonZeroI32,
165 NonZeroI64,
166 NonZeroI128,
167 NonZeroIsize,
168 NonZeroU8,
169 NonZeroU16,
170 NonZeroU32,
171 NonZeroU64,
172 NonZeroU128,
173 NonZeroUsize,
174 IpAddr,
175 Ipv4Addr,
176 Ipv6Addr,
177 SocketAddr,
178 SocketAddrV4,
179 SocketAddrV6,
180 char,
181 f32,
182 f64,
183 i8,
184 i16,
185 i32,
186 i64,
187 i128,
188 isize,
189 u8,
190 u16,
191 u32,
192 u64,
193 u128,
194 usize
195);
196
197impl DirectWord for bool {
200 fn direct_word(word: &OsStr) -> Result<Self, String> {
201 let truth = word.to_str().map(str::to_ascii_lowercase);
202 match truth.as_deref() {
203 Some("" | "true" | "t" | "yes" | "y" | "on" | "1") => Ok(true),
204 Some("false" | "f" | "no" | "n" | "off" | "0") => Ok(false),
205 _ => Err(format!("`{}` is not true or false", word.to_string_lossy())),
206 }
207 }
208}
209
210impl DirectWord for String {
212 fn direct_word(word: &OsStr) -> Result<Self, String> {
213 word.to_str().map(str::to_owned).ok_or_else(|| format!("`{}` is not UTF-8", word.to_string_lossy()))
214 }
215}
216
217impl DirectWord for OsString {
218 fn direct_word(word: &OsStr) -> Result<Self, String> {
219 Ok(word.to_os_string())
220 }
221}
222
223impl DirectWord for PathBuf {
224 fn direct_word(word: &OsStr) -> Result<Self, String> {
225 Ok(Self::from(word))
226 }
227}
228
229impl<Value> CliWordAlg<Value, OsString> for Parsed
231where
232 Value: DirectWord,
233{
234 type Error = String;
235
236 fn cli_word(&self, word: &OsString) -> Result<Value, String> {
237 Value::direct_word(word)
238 }
239}