split args

src/adapters/mod.rs

@@ -9,7 +9,7 @@ use crate::preproc::PreprocConfig;
 use failure::*;
 use log::*;
 use regex::{Regex, RegexSet};
-use std::borrow::Borrow;
+
 use std::borrow::Cow;
 use std::collections::HashMap;
 use std::io::prelude::*;
@@ -203,8 +203,8 @@ pub fn adapter_matcher<T: AsRef<str>>(
                 eprintln!(" - {}", fname_regexes[*fmatch].1.metadata().name);
             }
         }
-        if mime_matches.len() == 0 {
-            if fname_matches.len() == 0 {
+        if mime_matches.is_empty() {
+            if fname_matches.is_empty() {
                 None
             } else {
                 Some(fname_regexes[fname_matches[0]].1.clone())

src/args.rs

@@ -123,3 +123,41 @@ where
         }
     }
 }
+
+/// Split arguments into the ones we care about and the ones rg cares about
+pub fn split_args() -> Fallible<(RgaArgs, Vec<OsString>)> {
+    let mut app = RgaArgs::clap();
+
+    app.p.create_help_and_version();
+    let mut firstarg = true;
+    // debug!("{:#?}", app.p.flags);
+    let (our_args, mut passthrough_args): (Vec<OsString>, Vec<OsString>) = std::env::args_os()
+        .partition(|os_arg| {
+            if firstarg {
+                // hacky, but .enumerate() would be ugly because partition is too simplistic
+                firstarg = false;
+                return true;
+            }
+            if let Some(arg) = os_arg.to_str() {
+                arg.starts_with("--rga-")
+                    || arg.starts_with("--rg-")
+                    || arg == "--help"
+                    || arg == "-h"
+                    || arg == "--version"
+                    || arg == "-V"
+            } else {
+                // args that are not unicode can only be filenames, pass them to rg
+                false
+            }
+        });
+    debug!("our_args: {:?}", our_args);
+    let matches = parse_args(our_args)?;
+    if matches.rg_help {
+        passthrough_args.insert(0, "--help".into());
+    }
+    if matches.rg_version {
+        passthrough_args.insert(0, "--version".into());
+    }
+    debug!("passthrough_args: {:?}", passthrough_args);
+    Ok((matches, passthrough_args))
+}

src/bin/rga.rs

@@ -1,62 +1,12 @@
 use failure::Fallible;
-use log::*;
+
 use rga::adapters::spawning::map_exe_error;
 use rga::adapters::*;
 use rga::args::*;
 
-use std::ffi::OsString;
-use std::process::Command;
-use structopt::StructOpt;
 
-fn split_args() -> Fallible<(RgaArgs, Vec<OsString>)> {
-    let mut app = RgaArgs::clap();
+use std::process::Command;
 
-    app.p.create_help_and_version();
-    let mut firstarg = true;
-    // debug!("{:#?}", app.p.flags);
-    let (our_args, mut passthrough_args): (Vec<OsString>, Vec<OsString>) = std::env::args_os()
-        .partition(|os_arg| {
-            if firstarg {
-                // hacky, but .enumerate() would be ugly because partition is too simplistic
-                firstarg = false;
-                return true;
-            }
-            if let Some(arg) = os_arg.to_str() {
-                for flag in app.p.flags() {
-                    if let Some(s) = flag.s.short {
-                        if arg == format!("-{}", s) {
-                            return true;
-                        }
-                    }
-                    if let Some(l) = flag.s.long {
-                        if arg == format!("--{}", l) {
-                            return true;
-                        }
-                    }
-                    // println!("{}", flag.s.long);
-                }
-                for opt in app.p.opts() {
-                    // only parse --x=... for now
-                    if let Some(l) = opt.s.long {
-                        if arg.starts_with(&format!("--{}", l)) {
-                            return true;
-                        }
-                    }
-                }
-            }
-            false
-        });
-    debug!("our_args: {:?}", our_args);
-    let matches = parse_args(our_args)?;
-    if matches.rg_help {
-        passthrough_args.insert(0, "--help".into());
-    }
-    if matches.rg_version {
-        passthrough_args.insert(0, "--version".into());
-    }
-    debug!("passthrough_args: {:?}", passthrough_args);
-    Ok((matches, passthrough_args))
-}
 
 fn main() -> Fallible<()> {
     env_logger::init();