brew-rs: support some flags for list and search command

Signed-off-by: botantony <antonsm21@gmail.com>

Author: botantony

Library/Homebrew/rust/brew-rs/src/commands/list.rs

@@ -1,48 +1,104 @@
 use crate::BrewResult;
 use crate::delegate;
 use crate::homebrew;
+use anyhow::anyhow;
 use std::fs;
 use std::io;
 use std::path::{Path, PathBuf};
 use std::process::ExitCode;
 
+#[derive(Default)]
+struct Args<'a> {
+    formula: bool,
+    cask: bool,
+    packages: Vec<&'a str>,
+}
+
 pub fn run(args: &[String]) -> BrewResult<ExitCode> {
-    if args[1..]
-        .iter()
-        .any(|arg| arg.starts_with('-') || arg.contains('/'))
-    {
-        return delegate::run(args);
-    }
+    let parsed_args = {
+        let mut result = Args::default();
+        let mut args_iter = args.iter();
+        args_iter.next(); // Skip `list`
+        for arg in args_iter {
+            match arg.as_str() {
+                "--formula" | "--formulae" => {
+                    if result.cask {
+                        return Err(anyhow!(
+                            "Conflicting flags: `{}` and `{}`",
+                            arg,
+                            args.iter()
+                                .find(|s| s.as_str() == "--cask" || s.as_str() == "--casks")
+                                .unwrap()
+                        ));
+                    } else {
+                        result.formula = true;
+                    }
+                }
+                "--cask" | "--casks" => {
+                    if result.formula {
+                        return Err(anyhow!(
+                            "Conflicting flags: `{}` and `{}`",
+                            arg,
+                            args.iter()
+                                .find(|s| s.as_str() == "--formula" || s.as_str() == "--formulae")
+                                .unwrap()
+                        ));
+                    } else {
+                        result.cask = true;
+                    }
+                }
+                s if !s.starts_with('-') && !s.contains('/') => result.packages.push(s),
+                _ => return delegate::run(args),
+            }
+        }
+        if !result.formula && !result.cask {
+            result.formula = true;
+            result.cask = true;
+        }
+        result
+    };
 
     let cellar = homebrew::cellar_path()?;
     let prefix = homebrew::prefix_path()?;
     let caskroom = homebrew::caskroom_path()?;
 
-    if args.len() == 1 {
-        let formulae = homebrew::installed_names(&cellar)?;
-        let casks = homebrew::installed_names(&caskroom)?;
+    if parsed_args.packages.is_empty() {
+        let formulae = if parsed_args.formula {
+            homebrew::installed_names(&cellar)?
+        } else {
+            Vec::new()
+        };
+        let casks = if parsed_args.cask {
+            homebrew::installed_names(&caskroom)?
+        } else {
+            Vec::new()
+        };
         homebrew::print_sections(&formulae, &casks);
         return Ok(ExitCode::SUCCESS);
     }
 
     let mut missing = Vec::new();
     let mut listed_any = false;
 
-    for name in &args[1..] {
-        match list_formula_paths(&cellar, &prefix, name)? {
-            FormulaPaths::Paths(paths) => {
-                if listed_any {
-                    println!();
+    for name in parsed_args.packages {
+        if parsed_args.formula {
+            match list_formula_paths(&cellar, &prefix, name)? {
+                FormulaPaths::Paths(paths) => {
+                    if listed_any {
+                        println!();
+                    }
+                    println!("{}", paths.join("\n"));
+                    listed_any = true;
+                    continue;
                 }
-                println!("{}", paths.join("\n"));
-                listed_any = true;
-                continue;
+                FormulaPaths::Delegate => return delegate::run(args),
+                FormulaPaths::Missing => {}
             }
-            FormulaPaths::Delegate => return delegate::run(args),
-            FormulaPaths::Missing => {}
         }
 
-        if let Some(paths) = list_cask_paths(&caskroom, name)? {
+        if parsed_args.cask
+            && let Some(paths) = list_cask_paths(&caskroom, name)?
+        {
             if listed_any {
                 println!();
             }
@@ -51,12 +107,20 @@ pub fn run(args: &[String]) -> BrewResult<ExitCode> {
             continue;
         }
 
-        missing.push(name.clone());
+        missing.push(name);
     }
 
+    let keg_or_cask = if parsed_args.formula && parsed_args.cask {
+        "keg or cask"
+    } else if parsed_args.formula {
+        "keg"
+    } else {
+        "cask"
+    };
+
     if !missing.is_empty() {
         for name in missing {
-            eprintln!("No such keg or cask: {name}");
+            eprintln!("No such {keg_or_cask}: {name}");
         }
         return Ok(ExitCode::FAILURE);
     }

Library/Homebrew/rust/brew-rs/src/commands/search.rs

@@ -5,10 +5,34 @@ use crate::matcher::Matcher;
 use rust_fuzzy_search::fuzzy_search_threshold;
 use std::process::ExitCode;
 
+#[derive(Default)]
+struct Args<'a> {
+    formula: bool,
+    cask: bool,
+    package_name: Option<&'a str>,
+}
+
 pub fn run(args: &[String]) -> BrewResult<ExitCode> {
-    if args.len() != 2 || args[1].starts_with('-') {
-        return delegate::run(args);
-    }
+    let parsed_args = {
+        let mut result = Args::default();
+        let mut args_iter = args.iter();
+        args_iter.next(); // Skip `search`
+        for arg in args_iter {
+            match arg.as_str() {
+                "--formula" | "--formulae" => result.formula = true,
+                "--cask" | "--casks" => result.cask = true,
+                s if !s.starts_with('-') && result.package_name.is_none() => {
+                    result.package_name = Some(s)
+                }
+                _ => return delegate::run(args),
+            }
+        }
+        if !result.formula && !result.cask {
+            result.formula = true;
+            result.cask = true;
+        }
+        result
+    };
 
     let api_cache = homebrew::cache_api_path()?;
     let formula_names = match homebrew::read_lines(&api_cache.join("formula_names.txt")) {
@@ -20,12 +44,33 @@ pub fn run(args: &[String]) -> BrewResult<ExitCode> {
         Err(_) => return delegate::run(args),
     };
 
-    let matcher = Matcher::try_from(args[1].as_str())?;
-    let matched_formulae = matched_names(&formula_names, &matcher);
-    let matched_casks = matched_names(&cask_names, &matcher);
+    let package_name = match parsed_args.package_name {
+        Some(package_name) => package_name,
+        _ => return delegate::run(args),
+    };
+
+    let matcher = Matcher::try_from(package_name)?;
+    let matched_formulae = if parsed_args.formula {
+        matched_names(&formula_names, &matcher)
+    } else {
+        Vec::new()
+    };
+    let matched_casks = if parsed_args.cask {
+        matched_names(&cask_names, &matcher)
+    } else {
+        Vec::new()
+    };
+
+    let formulae_or_casks = if parsed_args.formula && parsed_args.cask {
+        "formulae or casks"
+    } else if parsed_args.formula {
+        "formulae"
+    } else {
+        "casks"
+    };
 
     if matched_formulae.is_empty() && matched_casks.is_empty() {
-        eprintln!("No formulae or casks found for {:?}.", args[1]);
+        eprintln!("No {formulae_or_casks} found for {:?}.", package_name);
         return Ok(ExitCode::FAILURE);
     }