fix(Parser): 🔥 overwrited help to be able to do a -h

src/main.rs

@@ -66,7 +66,7 @@ fn main() {
 
     let cli = Opts::parse();
 
-    let mut input_paths: Vec<&OsStr> = cli.paths.iter().map(|p| p.as_os_str()).collect();
+    let mut input_paths: Vec<&OsStr> = cli.paths.iter().map(OsString::as_os_str).collect();
     if input_paths.is_empty() {
        input_paths.push(OsStr::new(".")); 
     }

src/options/dir_action.rs

@@ -33,10 +33,10 @@ impl DirAction {
         if tree && can_tree {
             // Tree is only appropriate in details mode, so this has to
             // examine the View, which should have already been deduced by now
-            Ok(Self::Recurse(RecurseOptions::deduce(matches, true)?))
+            Ok(Self::Recurse(RecurseOptions::deduce(matches, true)))
         }
         else if recurse {
-            Ok(Self::Recurse(RecurseOptions::deduce(matches, false)?))
+            Ok(Self::Recurse(RecurseOptions::deduce(matches, false)))
         }
         else if as_file {
             Ok(Self::AsFile)
@@ -54,20 +54,20 @@ impl RecurseOptions {
     /// flag’s value, and whether the `--tree` flag was passed, which was
     /// determined earlier. The maximum level should be a number, and this
     /// will fail with an `Err` if it isn’t.
-    pub fn deduce(matches: &Opts, tree: bool) -> Result<Self, OptionsError> {
+    pub fn deduce(matches: &Opts, tree: bool) -> Self {
         let max_depth = matches.level;
         match max_depth {
             Some(d) => {
-                Ok(Self {
+                Self {
                     tree,
                     max_depth: Some(d),
-                })
+                }
             },
             None => {
-                Ok(Self {
+                Self {
                     tree,
                     max_depth: None,
-                })
+                }
             },
         }
     }
@@ -129,6 +129,7 @@ mod test {
             hyperlink: 0,
             octal: 0,
             security_context: 0,
+            help: false,
         };
 
         assert_eq!(DirAction::deduce(&matches, false, false).unwrap(), DirAction::List);
@@ -186,6 +187,7 @@ mod test {
             hyperlink: 0,
             octal: 0,
             security_context: 0,
+            help: false,
         };
         assert_eq!(DirAction::deduce(&matches, false, false).unwrap(), DirAction::Recurse(RecurseOptions {
             tree: false,
@@ -245,6 +247,7 @@ mod test {
             hyperlink: 0,
             octal: 0,
             security_context: 0,
+            help: false,
         };
         assert_eq!(DirAction::deduce(&matches, true, false).unwrap(), DirAction::Recurse(RecurseOptions {
             tree: true,
@@ -304,6 +307,7 @@ mod test {
             hyperlink: 0,
             octal: 0,
             security_context: 0,
+            help: false,
         };
         assert_eq!(DirAction::deduce(&matches, false, false).unwrap(), DirAction::AsFile);
     }
@@ -360,6 +364,7 @@ mod test {
             hyperlink: 0,
             octal: 0,
             security_context: 0,
+            help: false,
         };
 
         assert!(DirAction::deduce(&matches, false, true).is_err());
@@ -417,6 +422,7 @@ mod test {
             hyperlink: 0,
             octal: 0,
             security_context: 0,
+            help: false,
         };
 
         assert!(DirAction::deduce(&matches, false, true).is_err());
@@ -474,6 +480,7 @@ mod test {
             hyperlink: 0,
             octal: 0,
             security_context: 0,
+            help: false,
         };
 
         assert!(DirAction::deduce(&matches, false, true).is_err());
@@ -531,6 +538,7 @@ mod test {
             hyperlink: 0,
             octal: 0,
             security_context: 0,
+            help: false,
         };
 
         assert_eq!(DirAction::deduce(&matches, true, false).unwrap(), DirAction::Recurse(RecurseOptions {

src/options/error.rs

@@ -45,8 +45,8 @@ pub enum NumberSource {
 impl fmt::Display for NumberSource {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::Var(s) => write!(f, "variable {}", s),
-            Self::Arg(s) => write!(f, "argument {}", s),
+            Self::Var(s) => write!(f, "variable {s}"),
+            Self::Arg(s) => write!(f, "argument {s}"),
         }
     }
 }

src/options/file_name.rs

@@ -7,18 +7,20 @@ use crate::options::parser::Opts;
 
 impl Options {
     pub fn deduce<V: Vars>(matches: &Opts, vars: &V) -> Result<Self, OptionsError> {
-        let classify = Classify::deduce(matches)?;
+        let classify = Classify::deduce(matches);
         let show_icons = ShowIcons::deduce(matches, vars)?;
-        let embed_hyperlinks = EmbedHyperlinks::deduce(matches)?;
+        let embed_hyperlinks = EmbedHyperlinks::deduce(matches);
 
         Ok(Self { classify, show_icons, embed_hyperlinks })
     }
 }
 
 impl Classify {
-    fn deduce(matches: &Opts) -> Result<Self, OptionsError> {
-        if matches.classify > 0 { Ok(Self::AddFileIndicators) }
-              else { Ok(Self::JustFilenames) }
+    fn deduce(matches: &Opts) -> Self {
+        if matches.classify > 0 {
+            return Self::AddFileIndicators;
+        }
+        Self::JustFilenames
     }
 }
 
@@ -45,8 +47,10 @@ impl ShowIcons {
 }
 
 impl EmbedHyperlinks {
-    fn deduce(matches: &Opts) -> Result<Self, OptionsError> {
-        if matches.hyperlink > 0 { Ok(Self::On) }
-              else { Ok(Self::Off) }
+    fn deduce(matches: &Opts) -> Self {
+        if matches.hyperlink > 0 {
+            return Self::On;
+        }
+        Self::Off
     }
 }

src/options/filter.rs

@@ -19,7 +19,7 @@ impl FileFilter {
             sort_field:       SortField::deduce(matches)?,
             dot_filter:       DotFilter::deduce(matches)?,
             ignore_patterns:  IgnorePatterns::deduce(matches)?,
-            git_ignore:       GitIgnore::deduce(matches)?,
+            git_ignore:       GitIgnore::deduce(matches),
         })
     }
 }
@@ -162,7 +162,7 @@ impl DotFilter {
             (0, 0) => Ok(Self::JustFiles),
 
             // either a single --all or at least one --almost-all is given
-            (1, _) | (0, _) => Ok(Self::Dotfiles),
+            (1 | 0, _) => Ok(Self::Dotfiles),
             // more than one --all
             (_, _) => if matches.tree > 0 {
                 Err(OptionsError::TreeAllAll)
@@ -200,13 +200,11 @@ impl IgnorePatterns {
 
 
 impl GitIgnore {
-    pub fn deduce(matches: &Opts) -> Result<Self, OptionsError> {
+    pub fn deduce(matches: &Opts) -> Self {
         if matches.git_ignore > 0 {
-            Ok(Self::CheckAndIgnore)
-        }
-        else {
-            Ok(Self::Off)
+            return Self::CheckAndIgnore;
         }
+        Self::Off
     }
 }
 

src/options/mod.rs

@@ -139,7 +139,7 @@ impl Options {
             )));
         }
 
-        let strictness = match vars.get(&vars::EXA_STRICT) {
+        let strictness = match vars.get(vars::EXA_STRICT) {
             None => false,
             Some(s) => ! s.is_empty()
         };

src/options/parser.rs

@@ -3,6 +3,7 @@ use std::ffi::OsString;
 
 #[derive(Parser)]
 #[command(author, version, about, long_about = None)] // Read from `Cargo.toml`
+#[clap(disable_help_flag = true)]
 pub struct Opts {
     pub paths: Vec<OsString>,
     #[clap(short, long, action = clap::ArgAction::Count)]
@@ -57,7 +58,7 @@ pub struct Opts {
     pub group: u8,
     #[clap(short = 'n', long, action = clap::ArgAction::Count)]
     pub numeric: u8,
-    #[clap(long, action = clap::ArgAction::Count)]
+    #[clap(short = 'h', long, action = clap::ArgAction::Count)]
     pub header: u8,
     #[clap(long, action = clap::ArgAction::Count)]
     pub icons: u8,
@@ -101,4 +102,6 @@ pub struct Opts {
     pub security_context: u8,
     #[clap(short = '@', long, action = clap::ArgAction::Count)]
     pub extended: u8,
+    #[clap(long, action = clap::ArgAction::Help)]
+    pub help: bool,
 }

src/options/theme.rs

@@ -7,7 +7,7 @@ use super::parser::Opts;
 impl Options {
     pub fn deduce<V: Vars>(matches: &Opts, vars: &V) -> Result<Self, OptionsError> {
         let use_colours = UseColours::deduce(matches, vars)?;
-        let colour_scale = ColourScale::deduce(matches)?;
+        let colour_scale = ColourScale::deduce(matches);
 
         let definitions = if use_colours == UseColours::Never {
                 Definitions::default()
@@ -47,13 +47,11 @@ impl UseColours {
 
 
 impl ColourScale {
-    fn deduce(matches: &Opts) -> Result<Self, OptionsError> {
+    fn deduce(matches: &Opts) -> Self {
         if matches.color_scale > 0{
-            Ok(Self::Gradient)
-        }
-        else {
-            Ok(Self::Fixed)
+            return Self::Gradient;
         }
+        Self::Fixed
     }
 }