source_win_bat 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 13570792e56f831dce6bdc6c882950bfa681bedeb3e06bc6ef6ad4ef06b7a853
+  data.tar.gz: 0a68d985177b5f751b7fd7ebdf06440cda0269ec03347b261615ac919a80da3b
+SHA512:
+  metadata.gz: db9581bba734ea26bad073cce02811c74ff748037e99165a57f07c81dad7590537b9af04bb445db084e249e7d73fb6e3d500e36ce863eac5778c29373cedfbd9
+  data.tar.gz: 2e8c8d97f2285224a2608dafda5045c36ce67790c30d26a0b70e030f97ba439c20f49657ec6400ee06b16be0493c72ff214596ac15083ebe23057792498f6746

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2019 Takaya Saeki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,132 @@
+# SourceWinBat - Source a Windows Batch in Bash!
+
+`sw`, or SourceWinBat is a CLI utility to run Windows batch files from WSL/MSYS2/Cygwin,
+and sync the shell environments of Bash and the Windows batch files, including
+* Environment variables
+* Doskeys
+* Working directories
+
+By SourceWinBat, you can execute Windows initialization scripts in Bash as if you use `source` 
+command for initialization Bash scripts.  
+SourceWinBat helps you do your daily Windows work in your favorite UNIX-compatible environment.
+
+
+## Usage
+
+After initalization, `sw` function is defined in your Bash environment. 
+Run your Windows batch files or Windows CLI commands by `sw`.
+
+You can run a Windows batch file
+```console
+$ cat winbat.bat
+@echo off
+set ENV1=bar!  ; Environment variables will be synced
+echo foo!      ; Execute Windows echo commands
+ver            ; Execute Windows ver command, which outputs the OS version
+$ sw winbat.bat  # winbat.bat is executed
+foo!
+
+Microsoft Windows [Version 10.0.17763.195]
+$ echo $ENV1     # ENV1 is synced!
+bar!
+```
+
+You can also run a Windows command directly.
+```console
+$ sw ver
+
+Microsoft Windows [Version 10.0.17763.195]
+```
+
+## Examples
+
+### Environment Syncing
+
+SourceWinBat syncs environment variables, doskeys, and working directories of the
+Bash environment with those of the Windows cmd environment where a batch file is executed.
+
+#### 1. Environment variables
+A batch file can see the exported environment variables of Bash.  
+Conversely, Bash has the environment variables defined by the batch file and Windows system
+after the batch file is executed. `PATH` is properly converted.
+
+```console
+$ export UNIXENV="An UNIX environment variable is imported!"
+$ cat syncenv.bat
+echo %UNIXENV%
+set WINENV=A Windows environment variable is imported!
+set PATH=C:\any\path;%PATH%
+$ sw syncenv.bat  # syncenv sees the value of $UNIXENV, which we defined in Bash!
+An UNIX environment variable is imported!
+$ echo $WINENV    # Now we can see $WINENV, which is set in synenv.bat!!
+A Windows environment variable is imported!
+$ echo $PATH      # PATH is converted to the path of WSL
+/mnt/c/any/path:/usr/bin/:/bin:(other paths go on...)
+```
+
+#### 2. Doskeys
+SourceWinBat enables Bash to import doskeys from Windows Batch files as Bash functions.
+
+```console
+$ cat syncdoskey.bat
+doskey echo1stparam=echo $1
+doskey echoallparams=echo $*
+doskey verver=ver
+$ sw syncdoskey.bat
+$ echo1stparam 1st 2nd 3rd  # echo1stparam is imported!
+1st
+$ echo1stparam %OS%         # "echo $1" is executed by cmd.exe, so %OS% is expanded
+Windows_NT
+$ echoallparams 1st 2nd 3rd
+1st 2nd 3rd
+$ verver
+
+Microsoft Windows [Version 10.0.17763.195]
+```
+
+#### 3. Working directories
+As `source` of built-in Bash command syncs working directories, SourceWinBat also syncs them.
+
+```console
+$ cd ~
+$ cat syncwd.bat
+pushd C:\Windows
+pushd C:\Windows\system32
+cd C:\Windows\system32\drivers
+$ sw syncwd.bat
+$ pwd   # The current directory of Bash is changed
+/mnt/c/Windows/System32/drivers
+$ dirs  # The directory stack is synced with that of the batch file
+/mnt/c/Windows/System32/ /mnt/c/Windows /home/nullpo
+```
+
+## Installation
+
+SourceWinBat is written in Ruby. You can install it by Gem.
+```console
+# gem install source_win_bat
+```
+
+Execute the line below to add the initialization in your `.bashrc`.
+```console
+$ echo 'eval "$(init_sw)"' >> ~/.bashrc
+```
+After restarting Bash, you will be able to use `sw` in your shell.  
+Currently, SourceWinBat supports only Bash as a shell.
+
+## Requirements
+
+### 1. For WSL users
+
+October update or later is required. SourceWinBat requires ConPTY API.
+
+### 2. For MSYS2 and Cygwin users
+
+If you use MSYS2 and Cygwin with SourceWinBat, `winpty` command is required.
+Clone it from its GitHub repository and build it from the source. The repository is https://github.com/rprichard/winpty .  
+For MSYS2 users, DO NOT install `winpty` via `pacman`. As of 2019/01/03, Pacman installs the latest released version, 0.4.3-1, but this version does not work anymore.
+
+## TODOs
+
+* Support non-ascii characters in Cygwin and MSYS2. SourceWinBat already supports them in WSL.
+* Support shell operators in doskey such as pipe.

data/Rakefile

@@ -0,0 +1,76 @@
+require_relative './lib/unixcompatenv'
+
+task default: %w[test]
+
+task :test do
+
+  # Get all compatibility environments to test
+  all_compat_envs = [:wsl, :msys, :cygwin]
+  installed_compat_envs = UnixCompatEnv.detect_installed_compat_envs
+  ignored_compat_envs = (ENV['IGNORED_COMPATENV'] || '').split(',')
+                                                        .map(&:chomp)
+  env_to_readablestr = {wsl: "WSL", msys: "MSYS2", cygwin: "Cygwin"}
+
+  compat_envs = {}
+  all_compat_envs.each do |env|
+    next if ignored_compat_envs.include?(env_to_readablestr[env])
+    if installed_compat_envs.has_key?(env)
+      compat_envs[env] = installed_compat_envs[env]
+      next
+    end
+    path_env_name = "#{env_to_readablestr[env].upcase}_BASH_PATH"
+    if ENV[path_env_name] and File.exists?(ENV[path_env_name])
+      compat_envs[env] = ENV[path_env_name]
+      next
+    end
+    STDERR.puts "#{env_to_readablestr[env]} is not found. Set #{path_env_name} or add #{env_to_readablestr[env]} to IGNORED_COMPATENV environment variable. (Comma sepearated values)"
+    exit 1
+  end
+
+  # Test
+  unix_double_quote = -> str {
+    '"' + str.gsub('\\') {|_| '\\\\'}.gsub('"') {|_| '\\"'}.gsub('$') {|_| '\\$'} + '"'
+  }
+  cmd_double_quote = -> str {
+    '"' + str.gsub('\\') {|_| '\\\\'}.gsub('"') {|_| '\\"'} + '"'
+  }
+  ok_results = {}
+  succeeded = true
+  tests_winpath = UnixCompatEnv.to_win_path(File.realpath("./test"))
+  lib_winpath = UnixCompatEnv.to_win_path(File.realpath("./lib"))
+  compat_envs.each do |env, path|
+    case env
+    when :wsl
+      convpath_win2compat = "wslpath"
+    when :msys, :cygwin
+      convpath_win2compat = "cygpath -u"
+    end
+    cd2test = "cd \"$(#{convpath_win2compat} '#{tests_winpath}')\"; "
+    rubylib = "RUBYLIB=\"$(#{convpath_win2compat} '#{lib_winpath}')\" "
+    prove = "prove -e /bin/bash -j4 test_*.bash; "
+
+    cmd_in_env = cd2test + rubylib + prove
+    if env == UnixCompatEnv.compat_env
+      cmd = "bash -lc #{unix_double_quote.call(cmd_in_env)}"
+    elsif [UnixCompatEnv.compat_env, env].include?(:wsl)
+      cmd = "#{path} -lc #{unix_double_quote.call(cmd_in_env)}"
+    else
+      # Cygwin and MSYS2 cannot launch each other's applications directly due to DLL conflict.
+      # Solve that by wrapping a command by cmd.exe.
+      cmd_env_launch = "#{UnixCompatEnv.to_win_path(path)} -lc #{cmd_double_quote.call(cmd_in_env)}"
+      cmd = "cmd.exe /C #{unix_double_quote.call(cmd_env_launch)}"
+    end
+    puts "\e[1m\e[33m===#{env_to_readablestr[env]}===\e[0m\e[22m"
+    sh cmd do |ok, _|
+      ok_results[env] = ok
+      succeeded &&= ok
+    end
+  end
+  
+  puts "\e[1m\e[33m===Summary===\e[0m\e[22m"
+  compat_envs.each do |env, _|
+    puts "#{env_to_readablestr[env]}: #{ok_results[env] ? "PASSED" : "FAILED"}"
+  end
+
+  exit succeeded ? 0 : 1
+end

data/bin/init_sw

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+puts <<BASH
+#!/bin/bash
+
+which winpty > /dev/null
+if [[ `uname` != Linux && $? != 0 ]]; then
+    echo "winpty is required to run 'sw'. Please install winpty." >&2
+    echo "Please note that you have to build the latest winpty from the git repository since 4.3 has a fatal bug." >&2
+else
+    sw () {
+        local arg
+        local tmp_env tmp_macro tmp_cwd
+        local exitstatus
+
+        for arg in "$@"; do
+            if [[ "$arg" = "--" ]]; then
+                shift 1
+                break
+            elif [[ "$arg" =~ ^-+.+ ]]; then
+                case "$arg" in
+                    "--help" | "-h" )
+                        cat <<EOS
+sw, or SourceWinBat, is a utility to run Windows batch files from WSL /
+MSYS2 / Cygwin and sync environment variables, and working directories 
+between batch files and their UNIX Bash shell.
+
+  Usage:
+    sw [ [sw_options] -- ] win_bat_file [args...]
+
+  Sw options:
+    -help --help        Show this help message
+
+  Examples:
+    sw echo test
+    sw somebat.bat
+                        
+EOS
+                        return ;;
+                    * )
+                        echo "Unknown option '$1'" >&2
+                        return 1 ;;
+                esac
+                shift 1
+            else
+                break
+            fi
+        done
+
+        tmp_env="$(mktemp)"
+        tmp_macro="$(mktemp)"
+        tmp_cwd="$(mktemp)"
+        ruby -W0 -e "require 'source_win_bat'; SourceWindowsBatch.new.main(ARGV)" "${tmp_env}" "${tmp_macro}" "${tmp_cwd}" "$@"
+        exitstatus=$?
+        if [[ -e "${tmp_env}" ]]; then
+            source "${tmp_env}"
+        fi
+        if [[ -e "${tmp_macro}" ]]; then
+            source "${tmp_macro}"
+        fi
+        if [[ -e "${tmp_cwd}" ]]; then
+            source "${tmp_cwd}"
+        fi
+
+        ruby -e "begin; File.delete('${tmp_env}', '${tmp_macro}', '${tmp_cwd}'); rescue Errno::ENOENT; end"
+        return $exitstatus
+    }
+fi
+
+BASH

data/lib/source_win_bat.rb

@@ -0,0 +1,287 @@
+#!/usr/bin/ruby
+
+require 'securerandom'
+require 'tmpdir'
+require_relative 'unixcompatenv'
+
+class SourceWindowsBatch
+  
+  VERSION = "0.1.0"
+
+  def main(argv)
+    if argv.length < 4 || argv[3].chomp.empty?
+      STDERR.puts <<-EOS
+Usage: sw windows_cmd_or_batch [options_for_the_cmd]
+
+Internal Ruby command Usage:
+      #{File.basename(__FILE__)} env_out macro_out cwd_out windows_cmd_or_batch [options_for_the_cmd]
+      EOS
+      exit
+    end
+
+    unless [:cygwin, :msys, :wsl].include? UnixCompatEnv.compat_env
+      raise "You're in an unsupported UNIX compatible environment"
+    end
+
+    env = prepare_env_vars
+    env_tmp_file_in = mk_tmpname(".env")
+    macro_tmp_file_in = mk_tmpname(".doskey")
+    cwd_tmp_file_in = mk_tmpname(".cwd")
+    win_cmd = argv[3..-1].map {|v| "#{v}"}.join(" ")
+    win_cmd += " & call set SW_EXITSTATUS=%^ERRORLEVEL% "
+    win_cmd = concat_envdump(win_cmd, env_tmp_file_in)
+    win_cmd = concat_macrodump(win_cmd, macro_tmp_file_in)
+    win_cmd = concat_cwddump(win_cmd, cwd_tmp_file_in)
+    win_cmd += " & call exit %^SW_EXITSTATUS%"
+    # puts win_cmd
+    Signal.trap(:INT, "SIG_IGN")
+    if UnixCompatEnv.compat_env == :wsl
+      # * Skip winpty, assuming the system's WSL supports ConPTY
+      # * Use an absolute path since EC overwrites PATH with Windows-style PATH in WSL
+      pid = Process.spawn(env,
+                          UnixCompatEnv.to_compat_path('C:\\Windows\\System32\\cmd.exe'),
+                          '/C', win_cmd, :in => 0, :out => 1, :err => 2)
+    elsif !STDOUT.isatty
+      pid = Process.spawn(env, 'cmd.exe', '/C', win_cmd, :in => 0, :out => 1, :err => 2)
+    else
+      pid = Process.spawn(env, 'winpty', '--', 'cmd.exe', '/C', win_cmd, :in => 0, :out => 1, :err => 2)
+    end
+    Signal.trap(:INT) do
+      Process.signal("-KILL", pid)
+    end
+    status = nil
+    loop do
+      _, status = Process.wait2(pid)
+      break if status.exited?
+    end
+    
+    begin
+      codepage = detect_ansi_codepage
+      conv_setenv_stmts(env_tmp_file_in, argv[0], :bash, codepage)
+      conv_doskey_stmts(macro_tmp_file_in, argv[1], :bash, codepage)
+      gen_chdir_cmds(cwd_tmp_file_in, argv[2], :bash, codepage)
+      [env_tmp_file_in, macro_tmp_file_in, cwd_tmp_file_in].each do |f|
+        File.delete f
+      end
+    rescue Errno::ENOENT
+      # ignore
+    end
+
+    exit(status.exitstatus)
+  end
+
+  private
+
+  def detect_ansi_codepage
+    if !STDOUT.isatty && UnixCompatEnv.compat_env == :wsl
+      # cmd.exe seems to use UTF-8 when Stdout is redirected in WSL. TODO: Is it always fixed?
+      return "65001"  # CP65001 is UTF-8
+    end
+
+    posh_cmd = <<-EOS
+      Get-WinSystemLocale | Select-Object Name, DisplayName,
+                                          @{ n='OEMCP'; e={ $_.TextInfo.OemCodePage } },
+                                          @{ n='ACP';   e={ $_.TextInfo.AnsiCodePage } }
+    EOS
+    posh_res = `powershell.exe "#{posh_cmd.gsub("$", "\\$")}"`
+    locale = posh_res.lines.select {|line| !(line =~ /^\s*$/)}[-1].chomp
+    ansi_cp = locale.split(" ")[-1]
+    ansi_cp
+  end
+
+  def serialize_wslenvs(wslenvs)
+    wslenvs.map {|varname, opt| "#{varname}#{opt.empty? ? "" : "/#{opt}"}"}.join(":")
+  end
+
+  def parse_wslenv(wslenv_str)
+    wslenvs = Hash[]
+    wslenv_str.split(":").each do |wslenvvar|
+      envvar_name, envvar_opt = wslenvvar.split('/')
+      wslenvs[envvar_name] = envvar_opt || ""
+    end
+    wslenvs
+  end
+
+  def prepare_env_vars
+    return {} if UnixCompatEnv.compat_env != :wsl
+
+    wslenvs = Hash[]
+    ENV.each do |envvar_name, _|
+      wslenvs[envvar_name] = ""
+    end
+    wslenvs.merge!(parse_wslenv(ENV['WSLENV']))
+    # We don't use '/l' option, but convert paths by ourselves instead.
+    # See the comment that starts with 'How PATH in WSLENV is handled'
+    wslenvs['PATH'] = ""
+    var_wslenv = serialize_wslenvs(wslenvs)
+
+    paths = []
+    ENV['PATH'].split(":").each do |path|
+      begin
+        rpath = File.realpath(path)
+        if rpath.start_with?(UnixCompatEnv.win_root_in_compat)
+          path = UnixCompatEnv.to_win_path(rpath)
+        end
+      rescue Errno::ENOENT
+      end
+      paths.push(path)
+    end
+    var_path = paths.join(';')
+
+    {"WSLENV" => var_wslenv, "PATH" => var_path}
+  end
+
+  def mk_tmpname(suffix)
+    "#{UnixCompatEnv.win_tmp_in_compat}#{SecureRandom.uuid + suffix}"
+  end
+
+  def concat_envdump(cmd, tmpfile)
+    cmd + " & set > #{dq_win_path(UnixCompatEnv.to_win_path(tmpfile))}"
+  end
+
+  def concat_macrodump(cmd, tmpfile)
+    #TODO: escape
+    cmd + " & doskey /macros > #{dq_win_path(UnixCompatEnv.to_win_path(tmpfile))}"
+  end
+
+  def concat_cwddump(cmd, tmpfile)
+    #TODO: escape
+    winpath = dq_win_path(UnixCompatEnv.to_win_path(tmpfile))
+    cmd + " & cd > #{winpath} & pushd >> #{winpath}"
+  end
+
+  def dq_win_path(str)
+    str.gsub(/\//, '\\')
+      .split("\\")
+      .map {|dir| dir.include?(" ") ? "\"#{dir}\"" : dir}
+      .join("\\")
+  end
+
+  def escape_singlequote(str)
+    str.gsub(/'/, '"\'"')
+  end
+
+  def conv_to_host_cmds(in_file, out_file, conv_method, env)
+    unless File.exist?(in_file)
+      return
+    end
+    File.open(out_file, "w") do |out|
+      File.open(in_file) do |f|
+        f.each_line do |line|
+          line.force_encoding("ASCII-8BIT")
+          converted = conv_method.call(line, env)
+          out.puts converted if converted
+        end
+      end
+    end
+  end
+
+
+  def to_compat_pathlist(path, shell)
+    raise "Unsupporeted" unless shell == :bash
+    path.split(";")
+      .map {|p| UnixCompatEnv.to_compat_path(p)}
+      .join(":")
+  end
+
+  def to_env_stmt(set_stmt, shell)
+    raise "Unsupporeted" unless shell == :bash
+    var, val = /([^=]*)=(.*)$/.match(set_stmt)[1..2]
+
+    is_var_valid = /^[a-zA-Z_][_0-9a-zA-Z]*$/ =~ var
+    return nil unless is_var_valid
+
+    if var == "PATH" && UnixCompatEnv.compat_env != :wsl
+      val = to_compat_pathlist(val, :bash)
+    end
+
+    stmt = "export #{var}='#{escape_singlequote(val.chomp)}'"
+    return stmt if UnixCompatEnv.compat_env != :wsl
+
+    if var == "PATH"
+      stmt += "\nexport WSLENV=PATH/l:${WSLENV:-__EC_DUMMY_ENV}"
+    else
+      stmt += "\nexport WSLENV=#{var}:${WSLENV:-__EC_DUMMY_ENV}"
+    end
+    stmt
+  end
+
+  def conv_setenv_stmts(setenvfile, outfile, shell, codepage)
+    raise "Unsupporeted" if shell != :bash
+
+    File.open(outfile, "w") do |f_out|
+      envs = []
+      File.read(setenvfile, encoding: "CP#{codepage}:UTF-8").lines.each do |set_stmt|
+        var, val = /([^=]*)=(.*)$/.match(set_stmt)[1..2]
+
+        is_var_valid = /^[a-zA-Z_][_0-9a-zA-Z]*$/ =~ var
+        next if !is_var_valid
+
+        if var == "PATH"
+          val = to_compat_pathlist(val, shell)
+        end
+
+        envs.push(var)
+        f_out.puts("export #{var}='#{escape_singlequote(val.chomp)}'")
+      end
+      if UnixCompatEnv.compat_env == :wsl
+        # How PATH in WSLENV is handled:
+        # EC configures PATH's WSLENV flag as follows
+        #   A. When EC internally launches a Windows bat file
+        #     Set the PATH's flag to '' (nothing) since EC converts each Unix 
+        #     path to a corresponding Windows path.
+        #   B. When EC syncs environment variables with the result of a bat file
+        #     Leave the PATH's WSLENV flag as is
+        wslenvs = Hash[*envs.flat_map {|env| [env, ""]}]
+        wslenvs.delete('PATH')
+        wslenvs.merge!(parse_wslenv(ENV['WSLENV']))
+
+        if wslenvs.length > 0
+          f_out.puts("export WSLENV='#{serialize_wslenvs(wslenvs)}'")
+        end
+      end
+    end
+  end
+
+  def conv_doskey_stmts(doskeyfile, outfile, shell, codepage)
+    raise "Unsupporeted" unless shell == :bash
+
+    File.open(outfile, "w") do |f_out|
+      File.open(doskeyfile, encoding: "CP#{codepage}:UTF-8") do |f_in|
+       f_in.each_line do |doskey_stmt|
+          key, body = /([^=]*)=(.*)$/.match(doskey_stmt)[1..2]
+
+          is_key_valid = /^[a-zA-Z][0-9a-zA-Z]*$/ =~ key
+          return nil unless is_key_valid
+
+          body_substituted = escape_singlequote(body.chomp)
+            .gsub(/(?<param>\$[1-9]|\$\$|\$\*)/, '\'"\k<param>"\'')
+
+          f_out.puts <<-"EOS"
+          #{key} () {
+            sw '#{body_substituted}'
+          }
+          EOS
+        end
+      end
+    end
+  end
+
+  def gen_chdir_cmds(dirs, outfile, shell, codepage)
+    raise "Unsupporeted" unless shell == :bash
+    return unless File.exist?(dirs)
+
+    lines = File.read(dirs, encoding:"CP#{codepage}:UTF-8").lines.select {|line| !line.empty?}
+    cwd = lines[0]
+    dirs = lines[1..-1]
+
+    res = []
+    dirs.reverse.each do |dir|
+      res.push "cd '#{escape_singlequote(UnixCompatEnv.to_compat_path(dir.chomp))}'"
+      res.push "pushd . > /dev/null"
+    end
+    res.push "cd '#{escape_singlequote(UnixCompatEnv.to_compat_path(cwd.chomp))}'"
+    File.write(outfile, res.join("\n"))
+  end
+
+end

data/lib/unixcompatenv.rb

@@ -0,0 +1,107 @@
+require 'pathname'
+
+module UnixCompatEnv
+
+  @@compat_env = nil
+  @@compat_root = nil
+  @@win_root = nil
+  @@win_tmp = nil
+
+  def self.detect_installed_compat_envs
+    res = {}
+
+    default_paths = {
+      wsl: "/c/Windows/System32/bash.exe",
+      msys: "/c/tools/msys64/usr/bin/bash.exe",
+      cygwin: "/c/tools/cygwin/bin/bash.exe"
+    }
+
+    default_paths.each do |env, path|
+      path = win_root_in_compat[0..-2] + path
+      if File.exists?(path)
+        res[env] = path
+      end
+    end
+
+    res
+  end
+
+  def self.compat_env
+    @@compat_env ||=
+      case RUBY_PLATFORM
+      when /msys/
+        :msys
+      when /linux/
+        :wsl
+      when /cygwin/
+        :cygwin
+      else
+        :win
+      end
+  end
+
+  def self.compat_root_in_win
+    return @@compat_root if @@compat_root || compat_env == :wsl  # @@compat_root should be nil for :wsl
+    case compat_env
+    when :msys, :cygwin
+      path = `cygpath -w /`.chomp
+      if !path.end_with?("\\")
+        path += "\\"
+      end
+      @@compat_root = path
+    when :wsl
+      @@compat_root = nil
+    end
+    @@compat_root
+  end
+
+  def self.win_root_in_compat
+    return @@win_root if @@win_root
+    case compat_env
+    when :msys, :cygwin
+      root = `cygpath -u c:/`.chomp
+    when :wsl
+      root = `wslpath c:/`.chomp
+    end
+    raise "unexpected win root path" unless root.end_with?("c/")
+    @@win_root = root[0...-2]
+  end
+
+  def self.win_tmp_in_compat
+    return @@win_tmp if @@win_tmp
+    case compat_env
+    when :wsl, :cygwin
+      @@win_tmp = to_compat_path(`cmd.exe /C "echo %TEMP%"`.chomp) + '/'
+    when :msys
+      @@win_tmp = to_compat_path(ENV['temp'])
+    end
+    @@win_tmp
+  end
+
+  def self.to_win_path(path)
+    path = Pathname.new(path).cleanpath.to_s
+    raise "Abs path is expected: #{path}" if path[0] != "/"
+
+    if path.start_with?(win_root_in_compat)
+      drive = path[win_root_in_compat.length]
+      "#{drive.upcase}:\\" + (path[(win_root_in_compat.length + 2)..-1] || '').gsub('/', '\\')
+    elsif compat_env == :wsl
+      raise "A WSL path which cannot be accessed from Windows: #{path}"
+    else
+      # [0...-1] trims trailing '/'
+      compat_root_in_win[0...-1] + path.gsub('/', '\\')
+    end
+  end
+
+  def self.to_compat_path(path)
+    if !compat_root_in_win.nil? && path.start_with?(compat_root_in_win)
+      path = path[compat_root_in_win.length - 1 .. -1]
+    end
+    if /^[a-zA-Z]:/ =~ path
+      drive = path[0]
+      path = win_root_in_compat + drive.downcase + (path[2..-1] || "")
+    end
+    path.gsub('\\', '/')
+  end
+
+end

data/source_win_bat.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name        = 'source_win_bat'
+  s.version     = '0.1.0'
+  s.date        = '2019-01-05'
+  s.summary     = "'source' Windows bat files in your UNIX compatible shell in Windows"
+  s.description = <<EOS
+sw, or SourceWinBat, is a utility to run Windows batch files from WSL /
+MSYS2 / Cygwin and sync environment variables, doskeys, and working 
+directories between batch files and their UNIX shell environments.
+EOS
+  s.authors     = ["Takaya Saeki"]
+  s.email       = 'abc.tkys+pub@gmail.com'
+  s.files       = `git ls-files`.split("\n")
+  s.executables = ["init_sw"]
+  s.homepage    = 'http://rubygems.org/gems/source_win_bat'
+  s.license     = 'MIT'
+end

data/test/exit.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+exit /B 42

data/test/setcwd.cmd

@@ -0,0 +1,6 @@
+@echo off
+
+cd C:\
+pushd C:\Windows
+pushd C:\Windows\system32
+cd C:\Windows\system32\drivers

data/test/setdoskey.cmd

@@ -0,0 +1,7 @@
+@echo off
+
+doskey foo=echo bar
+doskey echo1stparam=echo $1
+doskey echoallparams=echo $*
+doskey verver=ver
+REM other special characters are not supported currently

data/test/setenv.cmd

@@ -0,0 +1,6 @@
+@echo off
+
+SET WINENV1=FOO
+SET WINENV2=BAR
+SET PATH=C:;%PATH%
+

data/test/setup_test.bash

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+eval "$("$(dirname "$(realpath "${BASH_SOURCE:-0}")")/../bin/init_sw")"
+source ./tap.bash
+
+to_unix_path () {
+  if [[ $(uname) = Linux ]]; then
+    wslpath "$@"
+  else
+    cygpath "$@"
+  fi
+}
+
+to_win_path () {
+  if [[ $(uname) = Linux ]]; then
+    wslpath -w "$@"
+  else
+    cygpath -w "$@"
+  fi
+}
+
+strip () {
+  sed -e 's/[ \r]*$//'
+}

data/test/tap.bash

@@ -0,0 +1,37 @@
+tap_tests () {
+  echo 1..$1
+}
+
+declare -i tap_test_counter=0
+_tap_echo_result () {
+  local mes
+
+  tap_test_counter=tap_test_counter+1
+  if [[ -n $2 ]]; then
+    mes=" - $2"
+  else
+    mes=""
+  fi
+
+  if [[ $1 == 0 ]]; then
+    echo ok $tap_test_counter$mes 
+  else
+    echo not ok $tap_test_counter$mes 
+  fi
+  
+}
+
+tap_ok () {
+  _tap_echo_result 0 "$1"
+}
+
+tap_notok() {
+  _tap_echo_result 1 "$1"
+}
+
+tap_okif() {
+  _tap_echo_result $1 "$2"
+}
+
+
+

data/test/test_ansicpchars.bash

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+source ./setup_test.bash
+tap_tests 6
+
+export jp=日本語
+[[ $(sw echo %jp% | strip) = "日本語" ]]; tap_okif $?
+sw echo %jp% > /dev/null  # Re-import $jp from Windows
+[[ $(echo $jp) = "日本語" ]]; tap_okif $? "Test a varible with Japanese value keeps its value after sw"
+sw set jp2=あいうえお > /dev/null
+[[ $(echo $jp2) = "あいうえお" ]]; tap_okif $?
+
+
+tmp="$(to_unix_path "$(sw echo %TEMP% | strip)")/sw_日本語ディレクトリ"
+rm -rf "$tmp"
+mkdir "$tmp"
+win_tmp="$(to_win_path "$tmp")"
+sw cd "$win_tmp"
+[[ `pwd` = "$tmp" ]]; tap_okif $?
+[[ $(sw echo %jp% | strip) = "日本語" ]]; tap_okif $?
+[[ $(sw cd | strip) = "$win_tmp" ]]; tap_okif $?
+rm -rf "$tmp"

data/test/test_exit.bash

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+source ./setup_test.bash
+tap_tests 3
+
+sw exit 0
+[[ $? = 0 ]]; tap_okif $? "Test exitcode is propagated 1"
+
+sw exit 42
+[[ $? = 42 ]]; tap_okif $? "Test exitcode is propagated 2"
+
+sw exit.cmd
+[[ $? = 42 ]]; tap_okif $? "Test exitcode is propagated 3"

data/test/test_optionparsebug.bash

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+source ./setup_test.bash
+tap_tests 1
+
+expected="^test-test \r?"
+[[ $(sw "echo test-test") =~ $expected ]]; tap_okif $? "Test the bug is fixed that sw misunderstoods hyphens in a commad as an option"

data/test/test_setcwd.bash

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+source ./setup_test.bash
+tap_tests 2
+
+sw setcwd.cmd
+
+expected="[cC]/Windows/System32/drivers /.*[cC]/Windows .*/[cC]\$"
+[[ $(dirs) =~ $expected ]]; tap_okif $? "test if pushd works"
+[[ $(pwd) =~ [cC]/Windows/System32/drivers$ ]]; tap_okif $? "test if cd works"

data/test/test_setdoskey.bash

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+source ./setup_test.bash
+tap_tests 4
+
+sw setdoskey.cmd
+
+expected="bar \r?"
+[[ $(foo) =~ $expected ]]; tap_okif $?
+expected="foo \r?"
+[[ $(echo1stparam foo bar) =~ $expected ]]; tap_okif $?
+expected="foo bar \r?"
+[[ $(echoallparams foo bar) =~ $expected ]]; tap_okif $?
+expected="Microsoft Windows"
+[[ $(verver) =~ $expected ]]; tap_okif $?
+

data/test/test_setenv.bash

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+source ./setup_test.bash
+tap_tests 5
+
+sw setenv.cmd
+
+[[ "$WINENV1" = FOO ]]; tap_okif $? "Test a variable is imported from a bat file 1"
+[[ "$WINENV2" = BAR ]]; tap_okif $? "Test a variable is imported from a bat file 2"
+[[ "$PATH" =~ ^/[^:]*[cC]/?: ]]; tap_okif $? "Test PATH is imported from a bat file and converted to UNIX-style"
+[[ $(sw echo %WINENV1%) =~ FOO ]]; tap_okif $? "Test a variable is exported to a bat file 1"
+export UNIXENV1=BUZ
+[[ $(sw echo %UNIXENV1%) =~ BUZ ]]; tap_okif $? "Test a variable is exported to a bat file 2"

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: source_win_bat
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Takaya Saeki
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-01-05 00:00:00.000000000 Z
+dependencies: []
+description: "sw, or SourceWinBat, is a utility to run Windows batch files from WSL
+  /\nMSYS2 / Cygwin and sync environment variables, doskeys, and working \ndirectories
+  between batch files and their UNIX shell environments.\n"
+email: abc.tkys+pub@gmail.com
+executables:
+- init_sw
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- bin/init_sw
+- lib/source_win_bat.rb
+- lib/unixcompatenv.rb
+- source_win_bat.gemspec
+- test/exit.cmd
+- test/setcwd.cmd
+- test/setdoskey.cmd
+- test/setenv.cmd
+- test/setup_test.bash
+- test/tap.bash
+- test/test_ansicpchars.bash
+- test/test_exit.bash
+- test/test_optionparsebug.bash
+- test/test_setcwd.bash
+- test/test_setdoskey.bash
+- test/test_setenv.bash
+homepage: http://rubygems.org/gems/source_win_bat
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: "'source' Windows bat files in your UNIX compatible shell in Windows"
+test_files: []