source_win_bat 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60ef7f12402da3cef3443161f97eef66b580182aa70c2ea20e2f936dc56f9cd3
-  data.tar.gz: 70f32f56ddb5aa0bdded6e72084bb977af84658b4dcabf3cbdc3e288cdc104e4
+  metadata.gz: 124a161b8c1f79c0be6b1e9093929776da276aa2f6877477887153266929a075
+  data.tar.gz: 832bee8c90c33ba7b4cfbc157b7fbbd4b1727cdac4c6f6e3d2f6a099de9040c1
 SHA512:
-  metadata.gz: 87b0dda50fb66fac4b6c691bebf72d6549561e48092ce04945e083a4dca332ad5530c4bcf91ff43f7d8759d415ffef4789e3ab89f178ab142e00231c1617e698
-  data.tar.gz: 6aa26c86859b485d8033a01ddb5a72b73b5e07306a9b2326e762a63034e6ca11b377719de21694befaa6dd22d4e665b76a913dd87f4e7e97836f36c6ab48a4e6
+  metadata.gz: 8378f7c810a1570633f2f727b4c425f80410e0283b4cdc8cf15ef3ade5f4fa4d9b39c2dd384f72193c704384a459a435805dedea51648e7422b6200064d34be5
+  data.tar.gz: 59325860b1d3fc11828def95aa2735a4cff93142ce96da76c67c380828d4ef023f1929fe8ba73f40d1030351e506831be00007a67429c2f438ca92581c871315

data/lib/source_win_bat.rb

@@ -4,64 +4,57 @@ require 'securerandom'
 require 'tmpdir'
 require_relative 'unixcompatenv'
 
+class CaseSensitiveVariableError < StandardError
+end
+
 class SourceWindowsBatch
   
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
+
+  @args = nil
+  @codepage = nil
+  @file_enc_opts = {}
 
   def main(argv)
-    options = parse_args!(argv)
+    @args = parse_args!(argv)
+    @args.merge!(parse_option_envs())
 
     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%"
-    if options[:show_cmd]
-      STDERR.puts "SW: " + win_cmd
-    end
+    load_codepage()
+    win_cmd, outfiles, proc_env = make_envsync_cmd(@args[: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,
+      # * Use an absolute path since SWB overwrites PATH with Windows-style PATH in WSL
+      pid = Process.spawn(proc_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)
+      pid = Process.spawn(proc_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)
+      pid = Process.spawn(prov_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)
-      if !options[:preserve_dump]
-        [env_tmp_file_in, macro_tmp_file_in, cwd_tmp_file_in].each do |f|
-          File.delete f
-        end
-      end
-    rescue Errno::ENOENT
-      # ignore
-    end
+    conv_setenv_stmts(outfiles[:env_windump_file], @args[:env_sync_file])
+    conv_doskey_stmts(outfiles[:macro_windump_file], @args[:macro_sync_file])
+    gen_chdir_cmds(outfiles[:cwd_windump_file], @args[:cwd_sync_file])
+
+    delete_tmpfiles(outfiles)
 
     exit(status.exitstatus)
   end
@@ -69,19 +62,19 @@ class SourceWindowsBatch
   private
 
   def parse_args!(argv)
-    options = {}
+    args = {}
     while argv.length > 0 && argv[0].start_with?("-")
       arg = argv.shift
       case arg 
       when "--"
         next
-      when "--show-cmd"
-        options[:show_cmd] = true
+      when "--show-tmpfiles"
+        args[:show_tmpfiles] = true
       when "--preserve-dump"
-        options[:preserve_dump] = true
+        args[:preserve_dump] = true
       when "--debug"
-        options[:show_cmd] = true
-        options[:preserve_dump] = true
+        args[:preserve_dump] = true
+        args[:show_tmpfiles] = true
       when "--help", "-h"
         puts help
         exit
@@ -98,65 +91,39 @@ class SourceWindowsBatch
       STDERR.puts help
       exit 1
     end
+    
+    args[:env_sync_file] = argv[0] 
+    args[:macro_sync_file] = argv[1]
+    args[:cwd_sync_file] = argv[2]
+    args[:win_cmd] = argv[3..-1].join(" ")
 
-    options
+    args
   end
 
-  def help
-    <<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:
-    -h --help           Show this help message
-    -v --version        Show the version information
-    --preserve-dump     Preserve the environment dump files of cmd.exe for
-                        debugging
-    --show-cmd          Show the command executed in cmd.exe for debugging
-    --debug             Enable '--preserve-dump' and '--show-cmd' options
-
-  Examples:
-    sw echo test
-    sw somebat.bat
-
-You can control some behavior of SourceWinBat by defining following environment
-variables.
-
-  Blacklisting and Whitelisting Environment Variable Not to be Synced:
-
-    SWB_BLACKLIST       Define comma-separated environment variable names with 
-                        regular expressions. All environment variables included
-                        in this list will not be synced by SourceWinBat.
-
-    SWB_WHITELIST       Define variable names in the same manner as that of 
-                        SWB_BLACKLIST. All environment variables that are NOT
-                        included in the list will NOT be synced by SourceWinBat.
-
-    Examples:
-
-      export SWB_BLACKLIST="foo:bar:baz_.*"
-
-        "foo", "bar", and any variables name of which start with "baz_" will not
-        be synced
-
-      export SWB_BLACKLIST="sync_taboo"
-      export SWB_WHITELIST="sync_.*"
+  def parse_option_envs()
+    options = {}
+    if ENV["SWB_DEBUG"] == "1"
+      options[:show_tmpfiles] = true
+      options[:preserve_dump] = true
+    end
 
-        Only variables name of which start with "sync_" will be synced,
-        except "sync_taboo".
-EOS
+    options
   end
 
-  def detect_ansi_codepage
+  def detect_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?
+      # 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
 
+    return ENV['SWB_CODEPAGE_CACHE'] if ENV['SWB_CODEPAGE_CACHE']
+
+    # You cannot detect the codepage by chcp because
+    #   1. chcp always retuns 65001 if it's not in a tty
+    #   2. you cannot get the output of a windows exe by Ruby's PTY module
+    #      for some reason.
+    # So, we use powershell instead here.
     posh_cmd = <<-EOS
       Get-WinSystemLocale | Select-Object Name, DisplayName,
                                           @{ n='OEMCP'; e={ $_.TextInfo.OemCodePage } },
@@ -165,9 +132,22 @@ EOS
     posh_res = `powershell.exe "#{posh_cmd.gsub("$", "\\$")}"`
     locale = posh_res.lines.select {|line| !(line =~ /^\s*$/)}[-1].chomp
     ansi_cp = locale.split(" ")[-1]
+
+    ENV['SWB_CODEPAGE_CACHE'] = ansi_cp
+
     ansi_cp
   end
 
+  def load_codepage
+    @codepage = detect_codepage()
+    @file_enc_opts = {
+       invalid: :replace,
+       undef: :replace,
+       replace: "?",
+       encoding: "CP#{@codepage}:UTF-8"
+    }
+  end
+
   def serialize_wslenvs(wslenvs)
     wslenvs.map {|varname, opt| "#{varname}#{opt.empty? ? "" : "/#{opt}"}"}.join(":")
   end
@@ -197,22 +177,72 @@ EOS
     false
   end
 
+  def detect_diffcase_vars(var_hash)
+    same_names = Hash[]
+    var_hash.each do |name, val|
+      same_names[name.upcase] ||= []
+      same_names[name.upcase].push(name)
+    end
+    same_names.select! {|name, val| val.length > 1}
+    
+    same_names
+  end
+
+  ###
+  #  Handling of environment variable in WSL is tricky due to WSLENV's strange behavior.
+  #  SWB has several rules to pass UNIX environment variables to Windows.
+  #  1. Normally, pass a variable by running initialization batch script before 
+  #     executing the target user batch file. The initialization script contains
+  #     `set` statements generated by SWB.
+  #
+  #  2. If a variable contains characters that need escaping, such as '|', '>',
+  #     pass it by WSLENV.
+  #     Why not passing all variables by WSLENV?
+  #     a. It's because WSLENV has strange bahavior about case-sensitiveness.
+  #     WSLENV syncs variables in a case-sensitive manner, even though Windows
+  #     apps handle environment variables do not.
+  #     For example, PATH variable is sometimes 'Path' in Windows. So, WSLENV fails
+  #     to sync Path with Unix's PATH. Syncing by running initialization batch script
+  #     in Windows environment can avoid this. 
+  #     b. However, I couldn't find a complete way to escape a value of a variable.
+  #     Without escaping, set statements gets crazy like `set hoge=foo | bar`, when
+  #     variable `hoge` has a value of `foo | bar`. So, we cannot fully depend on
+  #     initialization batch script. That's why SWB uses combination of initialization
+  #     script and WSLENV.
+  #
+  #  3. If a variable exists in WSLENV in the first place, sync it by WSLENV.
+  #     A user may set some flags in WSLENV.
+  #
+  #  Additionally, after completing execution of the target user batch file, if SWB
+  #  finds some variables the names of which differ only in case, SWB shows warning.
+  #  
+  #  Handling of environment variable in MSYS2 and Cygwin is simple.
+  #  They sync environment variables without any effort.
+  ###
   def prepare_env_vars
-    return {} if UnixCompatEnv.compat_env != :wsl
+    env = Hash[ENV]
+    return [{}, env] if UnixCompatEnv.compat_env != :wsl
 
-    wslenvs = Hash[]
-    ENV.each do |envvar_name, _|
+    chars_to_escape = /[><|&^%]/
+    vars = Hash[]
+    wslenvs = parse_wslenv(ENV['WSLENV'] || "")
+    ENV.each do |envvar_name, val|
       next if whitelist_block?(envvar_name) || blacklist_block?(envvar_name)
-      wslenvs[envvar_name] = ""
+      next if wslenvs.has_key?(envvar_name)
+      if chars_to_escape =~ val
+	wslenvs[envvar_name] = ""
+      else
+	vars[envvar_name] = val
+      end
     end
-    wslenvs.merge!(parse_wslenv(ENV['WSLENV'])) if 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)
+    # We don't use WSLENV for Path, but convert paths by ourselves instead.
+    # So, set it to empty. WSLENV is restored to the original value in Windows
+    # environment by the initialization script
+    wslenvs['PATH'] = "" if wslenvs['PATH']
+    env['WSLENV'] = serialize_wslenvs(wslenvs) if !wslenvs.empty?
 
     paths = []
-    ENV['PATH'].split(":").each do |path|
+    ENV['PATH'].split(':').each do |path|
       begin
         rpath = File.realpath(path)
         if rpath.start_with?(UnixCompatEnv.win_root_in_compat)
@@ -222,28 +252,92 @@ EOS
       end
       paths.push(path)
     end
-    var_path = paths.join(';')
+    vars['PATH'] = paths.join(';')
+
+    if !(same_names = detect_diffcase_vars(vars.merge(wslenvs))).empty?
+      error_mes = <<-EOS
+SWB Error:
+  You have environment variables the names of which differ only in case.
+  SWB cannot preserve and restore them due to case insensitiveness of Windows.
+  Please undefine them or add either to SWB_BLACKLIST to prevent ambiguity.
+Ambiguous variables:
+      EOS
+      same_names.each do |_, vals|
+	error_mes += "  - " + vals.join(", ") + "\n"
+      end
+      raise CaseSensitiveVariableError.new(error_mes)
+    end
 
-    {"WSLENV" => var_wslenv, "PATH" => var_path}
+    [vars, env]
   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))}"
+  def make_envsync_cmd(cmd)
+    files = {}
+
+    begin
+      wrapper_batch_file = mk_tmpname(".cmd")
+      File.write(wrapper_batch_file, "@" + cmd)
+      files[:wrapper_batch_file] = wrapper_batch_file
+
+      statements = ["@call " + dq_win_path(UnixCompatEnv.to_win_path(wrapper_batch_file))]
+
+      statements.push("@set SWB_EXITSTATUS=%errorlevel%")
+      proc_env = concat_env_init!(statements, files)
+      concat_env_dump!(statements, files)
+      concat_macro_dump!(statements, files)
+      concat_cwd_dump!(statements, files)
+      statements.push("@exit %SWB_EXITSTATUS%")
+
+      internal_command_file = mk_tmpname(".cmd")
+      File.write(internal_command_file, statements.join("\r\n"))
+      files[:internal_command_file] = internal_command_file
+      internal_command = "@" + dq_win_path(UnixCompatEnv.to_win_path(internal_command_file))
+
+      [internal_command, files, proc_env]
+    rescue CaseSensitiveVariableError => e
+      STDERR.puts e.message
+      delete_tmpfiles(files)
+      exit(1)
+    end
   end
 
-  def concat_macrodump(cmd, tmpfile)
+  def concat_env_init!(statements, outfiles)
+    vars_to_sync, proc_env = prepare_env_vars
+
+    env_init_file = mk_tmpname(".cmd")
+    File.write(env_init_file,
+	       vars_to_sync.map {|var, val| "@set #{var}=#{val}"}.join("\r\n"),
+	       opt=@file_enc_opts)
+    outfiles[:env_init_file] = env_init_file
+
+    statements.unshift("@call " + dq_win_path(UnixCompatEnv.to_win_path(env_init_file)))
+
+    proc_env
+  end
+
+  def concat_env_dump!(statements, outfiles)
+    env_windump_file = mk_tmpname(".env")
+    statements.push("@set > #{dq_win_path(UnixCompatEnv.to_win_path(env_windump_file))}")
+    outfiles[:env_windump_file] = env_windump_file
+  end
+
+  def concat_macro_dump!(statements, outfiles)
+    macro_windump_file = mk_tmpname(".doskey")
     #TODO: escape
-    cmd + " & doskey /macros > #{dq_win_path(UnixCompatEnv.to_win_path(tmpfile))}"
+    statements.push("@doskey /macros > #{dq_win_path(UnixCompatEnv.to_win_path(macro_windump_file))}")
+    outfiles[:macro_windump_file] = macro_windump_file
   end
 
-  def concat_cwddump(cmd, tmpfile)
+  def concat_cwd_dump!(statements, outfiles)
+    cwd_windump_file = mk_tmpname(".cwd")
     #TODO: escape
-    winpath = dq_win_path(UnixCompatEnv.to_win_path(tmpfile))
-    cmd + " & cd > #{winpath} & pushd >> #{winpath}"
+    winpath = dq_win_path(UnixCompatEnv.to_win_path(cwd_windump_file))
+    statements.push("@ cd > #{winpath} & pushd >> #{winpath}")
+    outfiles[:cwd_windump_file] = cwd_windump_file
   end
 
   def dq_win_path(str)
@@ -257,78 +351,65 @@ EOS
     str.gsub(/'/, '"\'"')
   end
 
-  def to_compat_pathlist(path, shell)
-    raise "Unsupporeted" unless shell == :bash
+  def to_compat_pathlist(path)
     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
+  def conv_setenv_stmts(setenvfile, outfile)
+    return if !File.exist?(setenvfile)
 
+    vars = Hash[]
+    envs_casemap = Hash[ENV.keys.map {|k| [k.upcase, k]}]
     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]
+      File.read(setenvfile, opt=@file_enc_opts).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
         next if whitelist_block?(var) || blacklist_block?(var)
+	vars[var] = val
 
-        if var == "PATH"
-          val = to_compat_pathlist(val, shell)
+	if var.upcase == "PATH"
+          val = to_compat_pathlist(val)
         end
 
-        envs.push(var)
+	var = envs_casemap[var.upcase] || 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 ENV['WSLENV']
-
-        if wslenvs.length > 0
-          f_out.puts("export WSLENV='#{serialize_wslenvs(wslenvs)}'")
-        end
+    end
+
+    if !(same_names = detect_diffcase_vars(vars)).empty?
+      STDERR.puts <<-EOS
+SWB Warning:
+  You've synced the environment variables the names of which differ only 
+  in case. That means one of the following.
+  1. You define a variable in your WSLENV, and your Windows environment
+     has another variable the name of which differ only in case.
+  2. SWB synced a variable by WSLENV, and your Windows command defined
+     another variable the name of which differ only in case from that of
+     the variable SWB synced.
+     SWB normally syncs variables by initialization script. However, if 
+     a variable's value contains special character to be escaped, SWB
+     syncs it by WSLENV instead. That is the case here.
+     
+  To solve this warning, please undefine those variables, or add them, except
+  one variable, to SWB_BLACKLIST to prevent ambiguity.
+Ambiguous variables:
+      EOS
+      same_names.each do |_, vals|
+	STDERR.puts("  - " + vals.join(", "))
       end
     end
+
   end
 
-  def conv_doskey_stmts(doskeyfile, outfile, shell, codepage)
-    raise "Unsupporeted" unless shell == :bash
+  def conv_doskey_stmts(doskeyfile, outfile)
+    return if !File.exist?(doskeyfile)
 
     File.open(outfile, "w") do |f_out|
-      File.open(doskeyfile, encoding: "CP#{codepage}:UTF-8") do |f_in|
+      File.open(doskeyfile, opt=@file_enc_opts) do |f_in|
        f_in.each_line do |doskey_stmt|
           key, body = /([^=]*)=(.*)$/.match(doskey_stmt)[1..2]
 
@@ -348,11 +429,10 @@ EOS
     end
   end
 
-  def gen_chdir_cmds(dirs, outfile, shell, codepage)
-    raise "Unsupporeted" unless shell == :bash
-    return unless File.exist?(dirs)
+  def gen_chdir_cmds(dirs, outfile)
+    return if !File.exist?(dirs)
 
-    lines = File.read(dirs, encoding:"CP#{codepage}:UTF-8").lines.select {|line| !line.empty?}
+    lines = File.read(dirs, opt=@file_enc_opts).lines.select {|line| !line.empty?}
     cwd = lines[0]
     dirs = lines[1..-1]
 
@@ -365,4 +445,91 @@ EOS
     File.write(outfile, res.join("\n"))
   end
 
+  def log_file_content(file_type, filename)
+    STDERR.puts("=== begin: #{file_type} ===\n")
+    if File.exist?(filename)
+      STDERR.puts("=== - CP#{@codepage}:'#{filename}' ===\n")
+      STDERR.puts(File.read(filename, opt=@file_enc_opts))
+    else
+      STDERR.puts("This file doesn't exist.")
+      STDERR.puts("Maybe Windows command terminated by exit command")
+    end
+    STDERR.puts("=== end: #{file_type} ===\n")
+  end
+
+  def delete_tmpfiles(tmpfiles)
+    tmpfiles.each do |k, f|
+      if @args[:show_tmpfiles]
+	log_file_content(k, f)
+      end
+      if !@args[:preserve_dump]
+	File.delete(f) if File.exist?(f)
+      end
+    end
+  end
+
+  def help
+    <<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:
+    -h --help           Show this help message
+    -v --version        Show the version information
+    --preserve-dump     Preserve the environment dump files of cmd.exe for
+                        debugging
+    --show-tmpfiles     Show the contents of the temporary files such as 
+                        the environment dump files
+    --debug             Enable '--preserve-dump', '--show-tmpfiles' options
+
+  Examples:
+    sw echo test
+    sw somebat.bat
+
+You can control some behavior of SourceWinBat by defining following environment
+variables.
+
+  Blacklisting and Whitelisting Environment Variable Not to be Synced:
+
+    SWB_BLACKLIST       Define comma-separated environment variable names with 
+                        regular expressions. All environment variables included
+                        in this list will not be synced by SourceWinBat.
+
+    SWB_WHITELIST       Define variable names in the same manner as that of 
+                        SWB_BLACKLIST. All environment variables that are NOT
+                        included in the list will NOT be synced by SourceWinBat.
+
+    Examples:
+
+      export SWB_BLACKLIST="foo:bar:baz_.*"
+
+        "foo", "bar", and any variables name of which start with "baz_" will not
+        be synced
+
+      export SWB_BLACKLIST="sync_taboo"
+      export SWB_WHITELIST="sync_.*"
+
+        Only variables name of which start with "sync_" will be synced,
+        except "sync_taboo".
+	
+## Several things to keep in mind:
+
+1. SourceWinBat executes the given Windows command in "Batch file mode".
+
+Windows cmd.exe has a few different behaviors in the interactive 
+"command line mode" and the "batch file mode". For example, expansion 
+result of an empty variable, or variable expansion in for command.
+SourceWinBat executes the given command always in the batch file mode.
+
+2. `exit` command prevents SourceWinBat from synciny environment variables.
+
+If you can fix the batch file you run, please replace `exit` with `exit /B`
+
+EOS
+  end
+
 end

data/source_win_bat.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'source_win_bat'
-  s.version     = '0.3.0'
+  s.version     = '0.4.0'
   s.date        = '2019-02-06'
   s.summary     = "'source' Windows bat files in your UNIX compatible shell in Windows"
   s.description = <<EOS

data/test/set_diff_case_env.cmd

@@ -0,0 +1,5 @@
+@echo off
+
+set DiffCase1=BAR
+set DIFFCASE2=BAR
+set DiffCase3=BAR

data/test/test_diffrent_case_envvar_bug.bash

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+source ./setup_test.bash
+tap_tests 12
+
+export DIFFCASE1=FOO
+[[ $(sw echo %DiffCase1%) =~ FOO ]]; tap_okif $? "Test a variable of different cases can be read in Windows 1"
+export DiffCase2=FOO
+[[ $(sw echo %DIFFCASE2%) =~ FOO ]]; tap_okif $? "Test a variable of different cases can be read in Windows 2"
+[[ -z "$DIFFCASE3" ]]; tap_okif $? "Test a variable is undefined 1"
+[[ -z "$DiffCase3" ]]; tap_okif $? "Test a variable is undefined 2"
+
+sw set_diff_case_env.cmd
+
+[[ "$DIFFCASE1" =~ BAR ]]; tap_okif $? "Test a variable of different cases is modified in Windows 1"
+[[ -z "$DiffCase1" ]]; tap_okif $? "Test a variable of different cases merges 1"
+[[ "$DiffCase2" =~ BAR ]]; tap_okif $? "Test a variable of different cases is modified in Windows 2"
+[[ "$DiffCase3" =~ BAR ]]; tap_okif $? "Test a variable of different cases is modified in Windows 3"
+[[ -z "$DIFFCASE3" ]]; tap_okif $? "Test a variable is undefined 3"
+
+unset DiffCase3
+export DIFFCASE3=BAZ
+[[ $(sw echo %DiffCase3%) =~ BAZ ]]; tap_okif $? "Test a variable of different cases merges 1"
+[[ $(echo $DIFFCASE3) =~ BAZ ]]; tap_okif $? "Test a variable of different cases merges 2"
+[[ -z "$DiffCase3" ]]; tap_okif $? "Test a variable of different cases merges 3"
+

data/test/test_optionparsebug.bash

@@ -3,5 +3,5 @@
 source ./setup_test.bash
 tap_tests 1
 
-expected="^test-test \r?"
+expected="^test-test"
 [[ $(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_setdoskey.bash

@@ -5,11 +5,11 @@ tap_tests 4
 
 sw setdoskey.cmd
 
-expected="bar \r?"
+expected="bar"
 [[ $(foo) =~ $expected ]]; tap_okif $?
-expected="foo \r?"
+expected="foo"
 [[ $(echo1stparam foo bar) =~ $expected ]]; tap_okif $?
-expected="foo bar \r?"
+expected="foo bar"
 [[ $(echoallparams foo bar) =~ $expected ]]; tap_okif $?
 expected="Microsoft Windows"
 [[ $(verver) =~ $expected ]]; tap_okif $?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: source_win_bat
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Takaya Saeki
@@ -25,15 +25,16 @@ files:
 - bin/init_sw
 - lib/source_win_bat.rb
 - lib/unixcompatenv.rb
-- source_win_bat-0.1.0.gem
 - source_win_bat.gemspec
 - test/exit_42.cmd
+- test/set_diff_case_env.cmd
 - test/setcwd.cmd
 - test/setdoskey.cmd
 - test/setenv.cmd
 - test/setup_test.bash
 - test/tap.bash
 - test/test_ansicpchars.bash
+- test/test_diffrent_case_envvar_bug.bash
 - test/test_exit.bash
 - test/test_optionparsebug.bash
 - test/test_setcwd.bash