Fixed: Support Windows #30

* replaced `touch` in windows context with `copy nul file.txt`
* replaced `touch` in with `regex::Regex`
* replaced `xargs` by giving multiple branch names to `git -d/-D'
* tested on Windows and WSL Ubuntu

Author: jsinger67

Cargo.lock

@@ -11,6 +11,7 @@ autotests = false
 
 [dependencies]
 clap = "2.33.1"
+regex = "1.6"
 
 [dev-dependencies]
 tempdir = "0.3"

Cargo.toml

@@ -1,7 +1,8 @@
 use commands::*;
 use error::Error;
 use options::*;
-use std::io::{stdin, stdout, Read, Write};
+use regex::Regex;
+use std::io::{stdin, stdout, Write};
 
 pub const COLUMN_SPACER_LENGTH: usize = 30;
 
@@ -42,84 +43,63 @@ impl Branches {
         println!("Updating remote {}", options.remote);
         run_command_with_no_output(&["git", "remote", "update", &options.remote, "--prune"]);
 
-        let merged_branches_regex =
-            format!("\\*{branch}|\\s{branch}", branch = &options.base_branch);
-        let merged_branches_filter = spawn_piped(&["grep", "-vE", &merged_branches_regex]);
+        let merged_branches_regex = format!("^\\*?\\s*{}$", options.base_branch);
+        let merged_branches_filter =  Regex::new(&merged_branches_regex).unwrap();
         let merged_branches_cmd = run_command(&["git", "branch", "--merged"]);
+        let merged_branches_output = std::str::from_utf8(&merged_branches_cmd.stdout).unwrap();
 
-        {
-            merged_branches_filter
-                .stdin
-                .unwrap()
-                .write_all(&merged_branches_cmd.stdout)
-                .unwrap();
-        }
+        let merged_branches = merged_branches_output
+            .lines()
+            .fold(Vec::<String>::new(), |mut acc, line| {
+                if !merged_branches_filter.is_match(line) {
+                    acc.push(line.trim().to_string());
+                }
+                acc
+            });
 
-        let mut merged_branches_output = String::new();
-        merged_branches_filter
-            .stdout
-            .unwrap()
-            .read_to_string(&mut merged_branches_output)
-            .unwrap();
-        let mut merged_branches = merged_branches_output.split('\n').map(|b| b.trim().into());
-
-        let local_branches_regex =
-            format!("\\*{branch}|\\s{branch}", branch = &options.base_branch);
-        let local_branches_filter = spawn_piped(&["grep", "-vE", &local_branches_regex]);
+        let local_branches_regex = format!("^\\*?\\s*{}$", options.base_branch);
+        let local_branches_filter = Regex::new(&local_branches_regex).unwrap();
         let local_branches_cmd = run_command(&["git", "branch"]);
-
-        {
-            local_branches_filter
-                .stdin
-                .unwrap()
-                .write_all(&local_branches_cmd.stdout)
-                .unwrap();
-        }
-
-        let mut local_branches_output = String::new();
-        local_branches_filter
-            .stdout
-            .unwrap()
-            .read_to_string(&mut local_branches_output)
-            .unwrap();
+        let local_branches_output = std::str::from_utf8(&local_branches_cmd.stdout).unwrap();
 
         let local_branches = local_branches_output
-            .split('\n')
-            .map(|b| b.trim().into())
+            .lines()
+            .fold(Vec::<String>::new(), |mut acc, line| {
+                if !local_branches_filter.is_match(line) {
+                    acc.push(line.trim().to_string());
+                }
+                acc
+            })
+            .iter()
             .filter(|branch| !options.ignored_branches.contains(branch))
+            .cloned()
             .collect::<Vec<String>>();
 
-        let remote_branches_regex = format!("(HEAD|{})", &options.base_branch);
-        let remote_branches_filter = spawn_piped(&["grep", "-vE", &remote_branches_regex]);
+        let remote_branches_regex = format!("\\b(HEAD|{})\\b", &options.base_branch);
+        let remote_branches_filter = Regex::new(&remote_branches_regex).unwrap();
         let remote_branches_cmd = run_command(&["git", "branch", "-r"]);
+        let remote_branches_output = std::str::from_utf8(&remote_branches_cmd.stdout).unwrap();
 
-        {
-            remote_branches_filter
-                .stdin
-                .unwrap()
-                .write_all(&remote_branches_cmd.stdout)
-                .unwrap();
-        }
-
-        let mut remote_branches_output = String::new();
-        remote_branches_filter
-            .stdout
-            .unwrap()
-            .read_to_string(&mut remote_branches_output)
-            .unwrap();
-        let mut remote_branches = remote_branches_output.split('\n').map(|b| b.trim().into());
+        let remote_branches = remote_branches_output
+            .lines()
+            .fold(Vec::<String>::new(), |mut acc, line| {
+                if !remote_branches_filter.is_match(line) {
+                    acc.push(line.trim().to_string());
+                }
+                acc
+            });
 
         for branch in local_branches {
             // First check if the local branch doesn't exist in the remote, it's the cheapest and easiest
             // way to determine if we want to suggest to delete it.
-            if !remote_branches.any(|b: String| b == format!("{}/{}", &options.remote, branch)) {
+            if !remote_branches.iter().any(|b: &String| *b == format!("{}/{}", &options.remote, branch)) {
                 branches.push(branch.to_owned());
                 continue;
             }
 
             // If it does exist in the remote, check to see if it's listed in git branches --merged. If
             // it is, that means it wasn't merged using Github squashes, and we can suggest it.
-            if merged_branches.any(|b: String| b == branch) {
+            if merged_branches.iter().any(|b: &String| *b == branch) {
                 branches.push(branch.to_owned());
                 continue;
             }

src/branches.rs

@@ -1,21 +1,11 @@
 use std::collections::BTreeSet;
-use std::io::{Error as IOError, Read, Write};
-use std::process::{Child, Command, ExitStatus, Output, Stdio};
+use std::io::Error as IOError;
+use std::process::{Command, ExitStatus, Output, Stdio};
 
 use branches::Branches;
 use error::Error;
 use options::Options;
 
-pub fn spawn_piped(args: &[&str]) -> Child {
-    Command::new(&args[0])
-        .args(&args[1..])
-        .stdin(Stdio::piped())
-        .stdout(Stdio::piped())
-        .stderr(Stdio::piped())
-        .spawn()
-        .unwrap_or_else(|e| panic!("Error with child process: {}", e))
-}
-
 pub fn run_command_with_no_output(args: &[&str]) {
     Command::new(&args[0])
         .args(&args[1..])
@@ -56,27 +46,25 @@ pub fn validate_git_installation() -> Result<(), Error> {
 }
 
 pub fn delete_local_branches(branches: &Branches) -> String {
-    let xargs = spawn_piped(&["xargs", "git", "branch", "-D"]);
-
-    {
-        xargs
-            .stdin
-            .unwrap()
-            .write_all(branches.string.as_bytes())
-            .unwrap()
+    // https://git-scm.com/docs/git-branch
+    // With a -d or -D option, <branchname> will be deleted. You may specify more than one branch
+    // for deletion.
+    //
+    // So we can work without xargs.
+    if branches.vec.is_empty() {
+        String::default()
+    } else {
+        let delete_branches_args =
+            branches.vec.iter().fold(vec!["git", "branch", "-D"], |mut acc, b| {
+                acc.push(b);
+                acc
+            });
+        let delete_branches_cmd = run_command(&delete_branches_args);
+        String::from_utf8(delete_branches_cmd.stdout).unwrap()
     }
-
-    let mut branches_delete_result = String::new();
-    xargs
-        .stdout
-        .unwrap()
-        .read_to_string(&mut branches_delete_result)
-        .unwrap();
-    branches_delete_result
 }
 
 pub fn delete_remote_branches(branches: &Branches, options: &Options) -> String {
-    let xargs = spawn_piped(&["xargs", "git", "push", &options.remote, "--delete"]);
 
     let remote_branches_cmd = run_command(&["git", "branch", "-r"]);
 
@@ -99,16 +87,17 @@ pub fn delete_remote_branches(branches: &Branches, options: &Options) -> String
         .cloned()
         .collect();
 
-    {
-        xargs
-            .stdin
-            .unwrap()
-            .write_all(intersection.join("\n").as_bytes())
-            .unwrap()
-    }
-
-    let mut stderr = String::new();
-    xargs.stderr.unwrap().read_to_string(&mut stderr).unwrap();
+    let stderr = if intersection.is_empty() {
+        String::default()
+    } else {
+        let delete_branches_args =
+            intersection.iter().fold(vec!["git", "push", &options.remote, "--delete"], |mut acc, b| {
+                acc.push(b);
+                acc
+            });
+        let delete_remote_branches_cmd = run_command(&delete_branches_args);
+        String::from_utf8(delete_remote_branches_cmd.stderr).unwrap()
+    };
 
     // Everything is written to stderr, so we need to process that
     let split = stderr.split('\n');
@@ -131,24 +120,18 @@ pub fn delete_remote_branches(branches: &Branches, options: &Options) -> String
 
 #[cfg(test)]
 mod test {
-    use super::spawn_piped;
 
-    use std::io::{Read, Write};
+    use regex::Regex;
 
+    // `spawn_piped` was removed so this test is somewhat outdated.
+    // It now tests the match operation for which `grep` was used before.
     #[test]
     fn test_spawn_piped() {
-        let echo = spawn_piped(&["grep", "foo"]);
-
-        {
-            echo.stdin
-                .unwrap()
-                .write_all("foo\nbar\nbaz".as_bytes())
-                .unwrap()
-        }
-
-        let mut stdout = String::new();
-        echo.stdout.unwrap().read_to_string(&mut stdout).unwrap();
-
-        assert_eq!(stdout, "foo\n");
+        let echo = Regex::new("foo\n").unwrap();
+        assert_eq!(echo.captures_iter("foo\nbar\nbaz")
+            .fold(String::new(), |mut acc, e| {
+                acc.push_str(&e[0]);
+                acc
+            }), "foo\n");
     }
 }

src/commands.rs

@@ -2,6 +2,8 @@
 
 extern crate clap;
 
+extern crate regex;
+
 pub mod cli;
 
 use clap::ArgMatches;

src/lib.rs

@@ -1,7 +1,7 @@
 use clap::ArgMatches;
-use commands::{output, run_command, spawn_piped};
+use commands::{output, run_command};
 use error::Error;
-use std::io::{Read, Write};
+use regex::Regex;
 
 const DEFAULT_REMOTE: &str = "origin";
 const DEFAULT_BRANCH: &str = "main";
@@ -77,18 +77,16 @@ impl Options {
     }
 
     fn validate_remote(&self) -> Result<(), Error> {
-        let grep = spawn_piped(&["grep", &self.remote]);
+        let remote_rx = Regex::new(&self.remote).unwrap();
         let remotes = run_command(&["git", "remote"]);
-
-        {
-            grep.stdin.unwrap().write_all(&remotes.stdout).unwrap();
-        }
-
-        let mut remote_result = String::new();
-        grep.stdout
-            .unwrap()
-            .read_to_string(&mut remote_result)
-            .unwrap();
+        let remotes_output = std::str::from_utf8(&remotes.stdout).unwrap();
+
+        let remote_result = remote_rx
+            .captures_iter(remotes_output)
+            .fold(String::new(), |mut acc, e| {
+                acc.push_str(&e[0]);
+                acc
+            });
 
         if remote_result.is_empty() {
             return Err(Error::InvalidRemote);