refactor(command_parser): move parameter fmt to Parameter types Display impl

crates/command_parser/src/flag.rs

@@ -2,7 +2,7 @@ use std::fmt::Display;
 
 use smol_str::SmolStr;
 
-use crate::parameter::{ParameterKind, ParameterValue};
+use crate::parameter::{Parameter, ParameterKind, ParameterValue};
 
 #[derive(Debug)]
 pub enum FlagValueMatchError {
@@ -22,7 +22,7 @@ impl Display for Flag {
         write!(f, "-{}", self.name)?;
         if let Some(value) = self.value.as_ref() {
             write!(f, "=")?;
-            value.format(f, value.default_name())?;
+            Parameter::from(*value).fmt(f)?;
         }
         Ok(())
     }

crates/command_parser/src/parameter.rs

@@ -1,4 +1,7 @@
-use std::{fmt::Debug, str::FromStr};
+use std::{
+    fmt::{Debug, Display},
+    str::FromStr,
+};
 
 use smol_str::SmolStr;
 
@@ -30,6 +33,21 @@ impl Parameter {
     }
 }
 
+impl Display for Parameter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self.kind {
+            ParameterKind::OpaqueString | ParameterKind::OpaqueStringRemainder => {
+                write!(f, "[{}]", self.name)
+            }
+            ParameterKind::MemberRef => write!(f, "<target member>"),
+            ParameterKind::SystemRef => write!(f, "<target system>"),
+            ParameterKind::MemberPrivacyTarget => write!(f, "<privacy target>"),
+            ParameterKind::PrivacyLevel => write!(f, "[privacy level]"),
+            ParameterKind::Toggle => write!(f, "on/off"),
+        }
+    }
+}
+
 impl From<ParameterKind> for Parameter {
     fn from(value: ParameterKind) -> Self {
         Parameter {
@@ -76,19 +94,6 @@ impl ParameterKind {
         matches!(self, ParameterKind::OpaqueStringRemainder)
     }
 
-    pub(crate) fn format(&self, f: &mut std::fmt::Formatter, param_name: &str) -> std::fmt::Result {
-        match self {
-            ParameterKind::OpaqueString | ParameterKind::OpaqueStringRemainder => {
-                write!(f, "[{param_name}]")
-            }
-            ParameterKind::MemberRef => write!(f, "<target member>"),
-            ParameterKind::SystemRef => write!(f, "<target system>"),
-            ParameterKind::MemberPrivacyTarget => write!(f, "<privacy target>"),
-            ParameterKind::PrivacyLevel => write!(f, "[privacy level]"),
-            ParameterKind::Toggle => write!(f, "on/off"),
-        }
-    }
-
     pub(crate) fn match_value(&self, input: &str) -> Result<ParameterValue, SmolStr> {
         match self {
             ParameterKind::OpaqueString | ParameterKind::OpaqueStringRemainder => {

crates/command_parser/src/token.rs

@@ -81,11 +81,12 @@ impl Display for Token {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::Value { name, .. } => write!(f, "{name}"),
-            Self::Parameter(param) => param.kind().format(f, param.name()),
+            Self::Parameter(param) => write!(f, "{param}"),
         }
     }
 }
 
+// (name, aliases) -> Token::Value
 impl<const L: usize> From<(&str, [&str; L])> for Token {
     fn from((name, aliases): (&str, [&str; L])) -> Self {
         Self::Value {
@@ -95,6 +96,7 @@ impl<const L: usize> From<(&str, [&str; L])> for Token {
     }
 }
 
+// name -> Token::Value
 impl From<&str> for Token {
     fn from(value: &str) -> Self {
         Self::from((value, []))
@@ -119,11 +121,21 @@ impl From<(&str, ParameterKind)> for Token {
     }
 }
 
+/// Iterator that produces [`Token`]s.
+///
+/// This is more of a convenience type that the [`tokens!`] macro uses in order
+/// to more easily combine tokens together.
 #[derive(Debug, Clone)]
 pub struct TokensIterator {
     inner: Vec<Token>,
 }
 
+impl TokensIterator {
+    pub(crate) fn new(tokens: Vec<Token>) -> Self {
+        Self { inner: tokens }
+    }
+}
+
 impl Iterator for TokensIterator {
     type Item = Token;
 
@@ -132,37 +144,27 @@ impl Iterator for TokensIterator {
     }
 }
 
+impl From<Vec<Token>> for TokensIterator {
+    fn from(value: Vec<Token>) -> Self {
+        Self::new(value)
+    }
+}
+
 impl<T: Into<Token>> From<T> for TokensIterator {
     fn from(value: T) -> Self {
-        Self {
-            inner: vec![value.into()],
-        }
+        Self::new(vec![value.into()])
     }
 }
 
 impl<const L: usize> From<[Token; L]> for TokensIterator {
     fn from(value: [Token; L]) -> Self {
-        Self {
-            inner: value.into_iter().collect(),
-        }
+        Self::new(value.into_iter().collect())
     }
 }
 
 impl<const L: usize> From<[Self; L]> for TokensIterator {
     fn from(value: [Self; L]) -> Self {
-        Self {
-            inner: value
-                .into_iter()
-                .map(|t| t.collect::<Vec<_>>())
-                .flatten()
-                .collect(),
-        }
-    }
-}
-
-impl From<Vec<Token>> for TokensIterator {
-    fn from(value: Vec<Token>) -> Self {
-        Self { inner: value }
+        Self::new(value.into_iter().map(|t| t.inner).flatten().collect())
     }
 }