rubyinstaller-build 0.1.0

data/resources/files/reline/version.rb

@@ -0,0 +1,3 @@
+module Reline
+  VERSION = '0.1.3'
+end

data/resources/files/reline/windows.rb

@@ -0,0 +1,273 @@
+require 'fiddle/import'
+
+class Reline::Windows
+  def self.encoding
+    Encoding::UTF_8
+  end
+
+  def self.win?
+    true
+  end
+
+  RAW_KEYSTROKE_CONFIG = {
+    [224, 72] => :ed_prev_history, # ↑
+    [224, 80] => :ed_next_history, # ↓
+    [224, 77] => :ed_next_char,    # →
+    [224, 75] => :ed_prev_char,    # ←
+    [224, 83] => :key_delete,      # Del
+    [224, 71] => :ed_move_to_beg,  # Home
+    [224, 79] => :ed_move_to_end,  # End
+    [  0, 41] => :ed_unassigned,   # input method on/off
+    [  0, 72] => :ed_prev_history, # ↑
+    [  0, 80] => :ed_next_history, # ↓
+    [  0, 77] => :ed_next_char,    # →
+    [  0, 75] => :ed_prev_char,    # ←
+    [  0, 83] => :key_delete,      # Del
+    [  0, 71] => :ed_move_to_beg,  # Home
+    [  0, 79] => :ed_move_to_end   # End
+  }
+
+  if defined? JRUBY_VERSION
+    require 'win32api'
+  else
+    class Win32API
+      DLL = {}
+      TYPEMAP = {"0" => Fiddle::TYPE_VOID, "S" => Fiddle::TYPE_VOIDP, "I" => Fiddle::TYPE_LONG}
+      POINTER_TYPE = Fiddle::SIZEOF_VOIDP == Fiddle::SIZEOF_LONG_LONG ? 'q*' : 'l!*'
+
+      WIN32_TYPES = "VPpNnLlIi"
+      DL_TYPES = "0SSI"
+
+      def initialize(dllname, func, import, export = "0", calltype = :stdcall)
+        @proto = [import].join.tr(WIN32_TYPES, DL_TYPES).sub(/^(.)0*$/, '\1')
+        import = @proto.chars.map {|win_type| TYPEMAP[win_type.tr(WIN32_TYPES, DL_TYPES)]}
+        export = TYPEMAP[export.tr(WIN32_TYPES, DL_TYPES)]
+        calltype = Fiddle::Importer.const_get(:CALL_TYPE_TO_ABI)[calltype]
+
+        handle = DLL[dllname] ||=
+                 begin
+                   Fiddle.dlopen(dllname)
+                 rescue Fiddle::DLError
+                   raise unless File.extname(dllname).empty?
+                   Fiddle.dlopen(dllname + ".dll")
+                 end
+
+        @func = Fiddle::Function.new(handle[func], import, export, calltype)
+      rescue Fiddle::DLError => e
+        raise LoadError, e.message, e.backtrace
+      end
+
+      def call(*args)
+        import = @proto.split("")
+        args.each_with_index do |x, i|
+          args[i], = [x == 0 ? nil : x].pack("p").unpack(POINTER_TYPE) if import[i] == "S"
+          args[i], = [x].pack("I").unpack("i") if import[i] == "I"
+        end
+        ret, = @func.call(*args)
+        return ret || 0
+      end
+    end
+  end
+
+  VK_MENU = 0x12
+  VK_LMENU = 0xA4
+  VK_CONTROL = 0x11
+  VK_SHIFT = 0x10
+  STD_INPUT_HANDLE = -10
+  STD_OUTPUT_HANDLE = -11
+  WINDOW_BUFFER_SIZE_EVENT = 0x04
+  FILE_TYPE_PIPE = 0x0003
+  FILE_NAME_INFO = 2
+  @@getwch = Win32API.new('msvcrt', '_getwch', [], 'I')
+  @@kbhit = Win32API.new('msvcrt', '_kbhit', [], 'I')
+  @@GetKeyState = Win32API.new('user32', 'GetKeyState', ['L'], 'L')
+  @@GetConsoleScreenBufferInfo = Win32API.new('kernel32', 'GetConsoleScreenBufferInfo', ['L', 'P'], 'L')
+  @@SetConsoleCursorPosition = Win32API.new('kernel32', 'SetConsoleCursorPosition', ['L', 'L'], 'L')
+  @@GetStdHandle = Win32API.new('kernel32', 'GetStdHandle', ['L'], 'L')
+  @@FillConsoleOutputCharacter = Win32API.new('kernel32', 'FillConsoleOutputCharacter', ['L', 'L', 'L', 'L', 'P'], 'L')
+  @@ScrollConsoleScreenBuffer = Win32API.new('kernel32', 'ScrollConsoleScreenBuffer', ['L', 'P', 'P', 'L', 'P'], 'L')
+  @@hConsoleHandle = @@GetStdHandle.call(STD_OUTPUT_HANDLE)
+  @@hConsoleInputHandle = @@GetStdHandle.call(STD_INPUT_HANDLE)
+  @@GetNumberOfConsoleInputEvents = Win32API.new('kernel32', 'GetNumberOfConsoleInputEvents', ['L', 'P'], 'L')
+  @@ReadConsoleInput = Win32API.new('kernel32', 'ReadConsoleInput', ['L', 'P', 'L', 'P'], 'L')
+  @@GetFileType = Win32API.new('kernel32', 'GetFileType', ['L'], 'L')
+  @@GetFileInformationByHandleEx = Win32API.new('kernel32', 'GetFileInformationByHandleEx', ['L', 'I', 'P', 'L'], 'I')
+
+  @@input_buf = []
+  @@output_buf = []
+
+  def self.msys_tty?(io=@@hConsoleInputHandle)
+    # check if fd is a pipe
+    if @@GetFileType.call(io) != FILE_TYPE_PIPE
+      return false
+    end
+
+    bufsize = 1024
+    p_buffer = "\0" * bufsize
+    res = @@GetFileInformationByHandleEx.call(io, FILE_NAME_INFO, p_buffer, bufsize - 2)
+    return false if res == 0
+
+    # get pipe name: p_buffer layout is:
+    #   struct _FILE_NAME_INFO {
+    #     DWORD FileNameLength;
+    #     WCHAR FileName[1];
+    #   } FILE_NAME_INFO
+    len = p_buffer[0, 4].unpack("L")[0]
+    name = p_buffer[4, len].encode(Encoding::UTF_8, Encoding::UTF_16LE, invalid: :replace)
+
+    # Check if this could be a MSYS2 pty pipe ('\msys-XXXX-ptyN-XX')
+    # or a cygwin pty pipe ('\cygwin-XXXX-ptyN-XX')
+    name =~ /(msys-|cygwin-).*-pty/ ? true : false
+  end
+
+  def self.getwch
+    unless @@input_buf.empty?
+      return @@input_buf.shift
+    end
+    while @@kbhit.call == 0
+      sleep(0.001)
+    end
+    until @@kbhit.call == 0
+      ret = @@getwch.call
+      if ret == 0 or ret == 0xE0
+        @@input_buf << ret
+        ret = @@getwch.call
+        @@input_buf << ret
+        return @@input_buf.shift
+      end
+      begin
+        bytes = ret.chr(Encoding::UTF_8).bytes
+        @@input_buf.push(*bytes)
+      rescue Encoding::UndefinedConversionError
+        @@input_buf << ret
+        @@input_buf << @@getwch.call if ret == 224
+      end
+    end
+    @@input_buf.shift
+  end
+
+  def self.getc
+    num_of_events = 0.chr * 8
+    while @@GetNumberOfConsoleInputEvents.(@@hConsoleInputHandle, num_of_events) != 0 and num_of_events.unpack('L').first > 0
+      input_record = 0.chr * 18
+      read_event = 0.chr * 4
+      if @@ReadConsoleInput.(@@hConsoleInputHandle, input_record, 1, read_event) != 0
+        event = input_record[0, 2].unpack('s*').first
+        if event == WINDOW_BUFFER_SIZE_EVENT
+          @@winch_handler.()
+        end
+      end
+    end
+    unless @@output_buf.empty?
+      return @@output_buf.shift
+    end
+    input = getwch
+    meta = (@@GetKeyState.call(VK_LMENU) & 0x80) != 0
+    control = (@@GetKeyState.call(VK_CONTROL) & 0x80) != 0
+    shift = (@@GetKeyState.call(VK_SHIFT) & 0x80) != 0
+    force_enter = !input.instance_of?(Array) && (control or shift) && input == 0x0D
+    if force_enter
+      # It's treated as Meta+Enter on Windows
+      @@output_buf.push("\e".ord)
+      @@output_buf.push(input)
+    else
+      case input
+      when 0x00
+        meta = false
+        @@output_buf.push(input)
+        input = getwch
+        @@output_buf.push(*input)
+      when 0xE0
+        @@output_buf.push(input)
+        input = getwch
+        @@output_buf.push(*input)
+      when 0x03
+        @@output_buf.push(input)
+      else
+        @@output_buf.push(input)
+      end
+    end
+    if meta
+      "\e".ord
+    else
+      @@output_buf.shift
+    end
+  end
+
+  def self.ungetc(c)
+    @@output_buf.unshift(c)
+  end
+
+  def self.get_screen_size
+    csbi = 0.chr * 22
+    @@GetConsoleScreenBufferInfo.call(@@hConsoleHandle, csbi)
+    csbi[0, 4].unpack('SS').reverse
+  end
+
+  def self.cursor_pos
+    csbi = 0.chr * 22
+    @@GetConsoleScreenBufferInfo.call(@@hConsoleHandle, csbi)
+    x = csbi[4, 2].unpack('s*').first
+    y = csbi[6, 2].unpack('s*').first
+    Reline::CursorPos.new(x, y)
+  end
+
+  def self.move_cursor_column(val)
+    @@SetConsoleCursorPosition.call(@@hConsoleHandle, cursor_pos.y * 65536 + val)
+  end
+
+  def self.move_cursor_up(val)
+    if val > 0
+      @@SetConsoleCursorPosition.call(@@hConsoleHandle, (cursor_pos.y - val) * 65536 + cursor_pos.x)
+    elsif val < 0
+      move_cursor_down(-val)
+    end
+  end
+
+  def self.move_cursor_down(val)
+    if val > 0
+      @@SetConsoleCursorPosition.call(@@hConsoleHandle, (cursor_pos.y + val) * 65536 + cursor_pos.x)
+    elsif val < 0
+      move_cursor_up(-val)
+    end
+  end
+
+  def self.erase_after_cursor
+    csbi = 0.chr * 24
+    @@GetConsoleScreenBufferInfo.call(@@hConsoleHandle, csbi)
+    cursor = csbi[4, 4].unpack('L').first
+    written = 0.chr * 4
+    @@FillConsoleOutputCharacter.call(@@hConsoleHandle, 0x20, get_screen_size.last - cursor_pos.x, cursor, written)
+  end
+
+  def self.scroll_down(val)
+    return if val.zero?
+    scroll_rectangle = [0, val, get_screen_size.last, get_screen_size.first].pack('s4')
+    destination_origin = 0 # y * 65536 + x
+    fill = [' '.ord, 0].pack('SS')
+    @@ScrollConsoleScreenBuffer.call(@@hConsoleHandle, scroll_rectangle, nil, destination_origin, fill)
+  end
+
+  def self.clear_screen
+    # TODO: Use FillConsoleOutputCharacter and FillConsoleOutputAttribute
+    write "\e[2J"
+    write "\e[1;1H"
+  end
+
+  def self.set_screen_size(rows, columns)
+    raise NotImplementedError
+  end
+
+  def self.set_winch_handler(&handler)
+    @@winch_handler = handler
+  end
+
+  def self.prep
+    # do nothing
+    nil
+  end
+
+  def self.deprep(otio)
+    # do nothing
+  end
+end

data/resources/files/ridk.cmd

@@ -0,0 +1,39 @@
+@echo off
+
+if "x%~1" == "xenable" (
+  goto :setvars
+)
+if "x%~1" == "xdisable" (
+  goto :setvars
+)
+if "x%~1" == "xexec" (
+  goto :exec
+)
+if "x%~1" == "xuse" (
+  goto :use
+)
+
+"%~dp0ruby" -x "%~f0" %*
+@exit /b %ERRORLEVEL%
+
+:exec
+rem pass the command to a bash shell
+setlocal
+for /f "delims=" %%x in ('"%~dp0ruby" --disable-gems -x '%~f0' %1') do set "%%x"
+shift
+shift
+%0 %1 %2 %3 %4 %5 %6 %7 %8 %9
+@exit /b %ERRORLEVEL%
+
+:setvars
+@echo on
+@for /f "delims=" %%x in ('"%~dp0ruby" --disable-gems -x '%~f0' %*') do set "%%x"
+@exit /b %ERRORLEVEL%
+
+:use
+"%~dp0../ridk_use/ridk.cmd" %*
+@exit /b %ERRORLEVEL%
+
+#!/mingw64/bin/ruby
+require "ruby_installer/runtime"
+RubyInstaller::Runtime::Ridk.run!(ARGV)

data/resources/files/ridk.ps1

@@ -0,0 +1,26 @@
+$rubydir = split-path $MyInvocation.MyCommand.Definition -parent
+
+# Execute 'enable' and 'disable' in the context of the current powershell session, so that env vars are effective for subsequent commands.
+if ($args[0] -eq "enable" -or $args[0] -eq "disable") {
+  $rubyfile = $rubydir + "/ruby"
+  $op = $args[0] + "ps1"
+  $vars = & $rubyfile --disable-gems -x $MyInvocation.MyCommand.Definition $op
+  Invoke-Expression $vars
+  exit $LastExitCode
+}
+
+# Forward 'use' to the script in ridk_use 
+if ($args[0] -eq "use") {
+  $ridkfile = $rubydir + "/../ridk_use/ridk.ps1"
+  . $ridkfile @args
+  exit $LastExitCode
+}
+
+# Pass all other commands through to ridk.cmd, so that a separate context for env vars is used.
+$cmdfile = $rubydir + "/ridk.cmd"
+& $cmdfile @args
+exit $LastExitCode
+
+#!/mingw64/bin/ruby
+require "ruby_installer/runtime"
+RubyInstaller::Runtime::Ridk.run!(ARGV)

data/resources/files/ridk_use/ridk.cmd

@@ -0,0 +1,13 @@
+@echo off
+
+if "x%~1" == "xuse" (
+  @echo on
+  @for /f "delims=" %%x in ('%~dp0../bin/ruby --disable-gems '%~dp0ridk_use.rb' %*') do @set "%%x"
+  @exit /b %ERRORLEVEL%
+)
+
+:: Forward any other ridk call to ridk.cmd of the active ruby version
+@for /f "delims=" %%x in ('ruby -rrbconfig -e "puts RbConfig::TOPDIR"') do set "RPATH=%%x"
+"%RPATH%\bin\ridk.cmd" %*
+@exit /b %ERRORLEVEL%
+#%/

data/resources/files/ridk_use/ridk.ps1

@@ -0,0 +1,17 @@
+$rubydir = split-path $MyInvocation.MyCommand.Definition -parent
+$rubyfile = $rubydir + "/../bin/ruby"
+
+# Execute 'use' in the context of the current powershell session, so that env vars are effective for subsequent commands.
+if ($args[0] -eq "use") {
+  $op, $rest = $args
+  $op = $op + "ps1"
+  $vars = & $rubyfile --disable-gems $rubydir/ridk_use.rb $op $rest
+  if ($vars){ Invoke-Expression $vars }
+  exit $LastExitCode
+}
+
+# Forward any other ridk call to ridk.ps1 of the active ruby version
+$rpath = & ruby -rrbconfig -e "puts RbConfig::TOPDIR" $op
+$ps1file = $rpath + "/bin/ridk.ps1"
+. $ps1file @args
+exit $LastExitCode

data/resources/files/ridk_use/ridk_use.rb

@@ -0,0 +1,221 @@
+require "yaml"
+
+def ridkuse_dirname
+  File.expand_path("..", __FILE__)
+end
+
+def rubies_filename
+  ENV['RIDK_USE_RUBIES'] || File.join(ridkuse_dirname, "rubies.yml")
+end
+
+def backslachs(path)
+  path.gsub("/", "\\")
+end
+
+def forwardslachs(path)
+  path.gsub("\\", "/")
+end
+
+RUBY_INSTALL_KEY = "SOFTWARE/Microsoft/Windows/CurrentVersion/Uninstall/"
+
+def find_each_ruby_from_registry
+  return to_enum(:find_each_ruby_from_registry) unless block_given?
+  
+  require "win32/registry"
+  begin
+    Win32::Registry::HKEY_CURRENT_USER.open(backslachs(RUBY_INSTALL_KEY)) do |reg|
+      reg.each_key do |subkey|
+        subreg = reg.open(subkey)
+        begin
+          if subreg['DisplayName'] =~ /^Ruby / && File.directory?(il=subreg['InstallLocation'])
+            yield il
+          end
+        rescue Encoding::InvalidByteSequenceError
+          # Ignore entries with broken character encoding
+        end
+      end
+    end
+  rescue Win32::Registry::Error
+  end
+end
+
+def find_each_ruby_from_yml
+  return to_enum(:find_each_ruby_from_yml) unless block_given?
+  YAML.load_file(rubies_filename).each do |rubypath|
+    yield rubypath
+  end
+end
+
+def find_each_ruby(&block)
+  return to_enum(:find_each_ruby) unless block_given?
+  
+  if File.exist?(rubies_filename)
+    find_each_ruby_from_yml(&block)
+  else
+    find_each_ruby_from_registry(&block)
+  end
+end
+
+def each_ruby
+  return to_enum(:each_ruby) unless block_given?
+  
+  find_each_ruby.each_with_index do |rubypath, idx|
+    yield(idx + 1, File.expand_path(rubypath))
+  end
+end
+  
+def list_rubies
+  each_ruby do |idx, rubypath|
+    rubyver = begin
+      `#{File.join(rubypath, "bin/ruby")} -v`
+    rescue => err
+      err.to_s
+    end
+    $stderr.puts "#{idx} - #{rubypath} \t#{rubyver}"
+  end
+end
+
+def update_rubies
+  if File.exist?(rubies_filename)
+    rubies = YAML.load_file(rubies_filename)
+  else
+    rubies = []
+  end
+  
+  find_each_ruby_from_registry do |rubypath|
+    rubypath = File.expand_path(rubypath)
+    unless rubies.find{|r| File.expand_path(r) == rubypath }
+      rubies << rubypath
+    end
+  end
+  
+  $stderr.puts "Update #{rubies_filename}"
+  File.write(rubies_filename, YAML.dump(rubies))
+end
+
+def in_path_regex(path)
+  pathregex = Regexp.escape(forwardslachs(path)).gsub(/\//, "[\\/\\\\\\\\]")
+  /(^|;)#{pathregex}[^;]*(;|$)/i
+end
+
+def remove_rubies_from_path(vars, rubies)
+  if path=vars['PATH']
+    rubies.each do |rubypath|
+      path = path.gsub(in_path_regex(rubypath)) do |a|
+        res = $1.empty? || $2.empty? ? "" : ";"
+        $stderr.puts "Disable #{rubypath}"
+        res
+      end
+    end
+    vars['PATH'] = path
+  end
+end
+
+def ensure_ridk_use_in_path(vars)
+  if path=vars['PATH']
+    ridkusepath = ridkuse_dirname
+    unless in_path_regex(ridkusepath).match(path)
+      path = backslachs(ridkusepath) + ";" + path
+    end
+    vars['PATH'] = path
+  end
+end
+
+def enable_ruby_in_path(vars, rubypath)
+  if (path=vars["PATH"]) && !in_path_regex(rubypath).match(path)
+    $stderr.puts "Enable #{rubypath}"
+    vars['PATH'] = backslachs(File.join(rubypath, "bin")) + ";" + vars['PATH']
+  end
+end
+
+def switch_ruby_per_cmd(rubypath, rubies, ps1)
+  vars = {
+    "PATH" => ENV['PATH'],
+  }
+  remove_rubies_from_path(vars, rubies)
+  enable_ruby_in_path(vars, rubypath)
+  ensure_ridk_use_in_path(vars)
+  
+  if ps1
+    vars.map do |key, val|
+      "$env:#{key}=\"#{val.gsub('"', '`"')}\""
+    end.join(";")
+  else
+    vars.map do |key, val|
+      "#{key}=#{val}"
+    end.join("\n")
+  end
+end
+
+def select_ruby(rubies, selector)
+  ridx = selector.to_i
+  if ridx > 0
+    rubies = each_ruby.to_h
+    selpath = rubies[ridx]
+  end
+  return selpath if selpath
+
+  if selector =~ /^\/(.*)\/$/
+    regex = $1
+    _, selpath = rubies.find do |idx, rubypath|
+      /#{regex}/i.match(rubypath)
+    end
+    return selpath
+  end
+end
+
+def print_help
+  $stderr.puts <<-EOT
+Usage:
+    ridk use [<option>]
+
+Option:
+                  Start interactive version selection
+    list          Search and list installed ruby versions
+    update        Save or update the found ruby versions to rubies.yml
+    <number>      Change the active ruby version by index
+    /<regex>/     Change the active ruby version by regex
+    help          Display this help and exit
+EOT
+end
+      
+def run!(args)
+  case args[0]
+    when "use", "useps1"
+      ps1 = args[0] == "useps1"
+      case args[1]
+        when 'help'
+          print_help
+        when 'list'
+          list_rubies
+        when 'update'
+          update_rubies
+        when String
+          rubies = each_ruby.to_h
+          rubypath = select_ruby(rubies, args[1])
+          unless rubypath
+            $stderr.print "Invalid ruby: #{args[1].inspect}"
+            exit 1
+          end
+          puts switch_ruby_per_cmd(rubypath, rubies.values, ps1)
+        else
+          list_rubies
+          rubies = each_ruby.to_h
+
+          loop do
+            $stderr.print "Select ruby version to enable: "
+            selector = $stdin.gets.strip
+            rubypath = select_ruby(rubies, selector)
+            next unless rubypath
+            puts switch_ruby_per_cmd(rubypath, rubies.values, ps1)
+            break
+          end
+      end
+    else
+      $stderr.puts "Invalid option #{args[0].inspect}"
+  end
+end
+
+if $0 == __FILE__
+  run!(ARGV)
+end