Version 0.2.0, featuring more robust path handling

This version uses base64 to encode commands that will be sent to bash
to avoid escaping madness that makes certain command line escaping
impossible on Windows

The practical effect of this is that, instead of certain commands
confusing bash due to cmd limitations, anything should be runnable now

Also, updated the README to make it a little clearer

Author: Archenoth

Cargo.toml

@@ -1,14 +1,15 @@
 [package]
 name = "wsl_proxy"
 description = "A WSL binary Windowsifier, so you can use WSL programs as Windows executables"
-version = "0.1.1"
+version = "0.2.0"
 authors = ["Archenoth <archenoth@gmail.com>"]
 edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 regex = "1"
+base64 = "0.11.0"
 
 [profile.release]
 opt-level = 'z'

README.md

@@ -1,30 +1,22 @@
-# wsl_proxy: A way to use your WSL Linux binaries as Windows programs
+# wsl_proxy: Use your WSL binaries as Windows programs
 
-Have you ever made an `ls.bat`? Or maybe even something that looked a little like this?
+Have you ever written `ls.bat`? Maybe something that looks similar to this?
 
 ```batch
 @echo off
 bash -c 'git %*'
 ```
 
-Thankfully, these batch files work pretty nicely if you don't want to install two versions of every tool you have; one for Linux, and one for Windows. But unfortunately, you can't set `.bat` files as the default program you open certain files with, and you can't readily use a lot of these with IDEs since they often simply don't accept `.bat` files in place of, for example, `git.exe`.
+Thankfully, these batch files work pretty nicely if you don't want to install two versions of every tool you have; one for Linux, and one for Windows. But unfortunately, you can't set `.bat` files as the default program to open files with, and you can't readily use a lot of these with IDEs since they often simply don't accept `.bat` files. You might also encounter path translation issues between systems.
 
 Enter wsl_proxy!
 
-[![](https://asciinema.org/a/KMItxCIV03k7uXEyMRy6qjD6P.png)](https://asciinema.org/a/KMItxCIV03k7uXEyMRy6qjD6P)
+![wsl_proxy being used to call a bunch of WSL programs as if they were normal Windows command line programs, understanding Windows paths and everything!](./screenshot.png)
 
 If you rename it to `git.exe`, it will be WSL git. If you name it `emacs.exe`, it's gonna be WSL Emacs! You can put these in your path, give them to IDEs to use, and even assign your favorite Linux text editors as your default editor program, in Windows!
 
 There is the added bonus that you don't need to configure multiple versions of things twice either! So if you have, for example, a fancy SSH configuration, not only can you still `ssh hostBehindProxyJumps` with your configs and your keys, your `git.exe` will also use them!
 
-If you give wsl_proxy Windows paths, it will even translate them with `wslpath`, so you can run things like `git -C E:\SomePath\ log` and you'll get the result you probably intended. (IE: It Actually Working)
+If you give wsl_proxy Windows paths, it will even translate them with `wslpath`, so you can run things like `git -C E:\SomePath\ log` and have it just work as expected.
 
-If you are space conscious of the binary size, but want a mirror of everything you have in Windows, you can even just hardlink everything you like in several WSL folders. (Yes, WSL hadlinking works on NTFS)
-
-```bash
-for bin in ls emacs vim nano git ssh; do
-  ln wsl_proxy.exe $bin.exe
-done
-```
-
-*Note:* `wsl_proxy.exe` needs to be somewhere Windows can see it. The binaries however, do not.
+*Note:* The WSL binaries wsl_proxy runs need to be on your path after `.bashrc` is run.

screenshot.png

@@ -1,3 +1,6 @@
+extern crate base64;
+
+use base64::encode;
 use regex::Regex;
 use std::process::{exit, Command};
 
@@ -9,15 +12,15 @@ use std::process::{exit, Command};
 /// * `args` - The arguments to string-escape, and wrap in wslpath subshells when applicable
 fn get_args(args: std::env::Args) -> String {
     let windrive_regex = Regex::new(r"^[a-zA-Z]:[/\\]").unwrap();
-    let escape_regex = Regex::new(r#"([ \\'()"])"#).unwrap();
+    let escape_regex = Regex::new(r#"([\\'])"#).unwrap();
 
     args.fold(String::from(""), |acc, next| {
-        let next = escape_regex.replace_all(&next, r"\$1");
+        let escaped = "$'".to_owned() + &escape_regex.replace_all(&next, r"\$1") + "'";
 
         if windrive_regex.is_match(&next) {
-            acc + r#" "$(wslpath "# + &next + r#")""#
+            acc + r#" "$(wslpath "# + &escaped + r#")""#
         } else {
-            acc + " " + &next
+            acc + " " + &escaped
         }
     })
 }
@@ -47,18 +50,22 @@ fn get_program_name(program: &str) -> Result<&str, &str> {
     }
 }
 
+/// We base64 everything after escaping it because escaping things for Windows is a minor nightmare
 fn main() {
     let mut args = std::env::args();
     let program = args.nth(0).expect("Program needs to have a name!");
 
     let exit_status = match get_program_name(&program) {
-        Ok(program) => Command::new("bash")
-            .arg("-ic")
-            .arg(program.to_owned() + &get_args(args))
-            .status()
-            .expect("Failed to run program")
-            .code()
-            .expect("No exit status"),
+        Ok(program) => {
+            let command = program.to_owned() + &get_args(args);
+            Command::new("bash")
+                .arg("-ic")
+                .arg(format!("$(echo {} | base64 --decode)", encode(&command)))
+                .status()
+                .expect("Failed to run program")
+                .code()
+                .expect("No exit status")
+        }
         Err(err) => {
             eprintln!("{}", err);
             1