irb 1.1.0.pre.4

data/lib/irb/cmd/chws.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: false
+#
+#   change-ws.rb -
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+require_relative "nop"
+require_relative "../ext/change-ws"
+
+# :stopdoc:
+module IRB
+  module ExtendCommand
+
+    class CurrentWorkingWorkspace < Nop
+      def execute(*obj)
+        irb_context.main
+      end
+    end
+
+    class ChangeWorkspace < Nop
+      def execute(*obj)
+        irb_context.change_workspace(*obj)
+        irb_context.main
+      end
+    end
+  end
+end
+# :startdoc:

data/lib/irb/cmd/fork.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: false
+#
+#   fork.rb -
+#   	$Release Version: 0.9.6 $
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+
+# :stopdoc:
+module IRB
+  module ExtendCommand
+    class Fork < Nop
+      def execute
+        pid = send ExtendCommand.irb_original_method_name("fork")
+        unless pid
+          class << self
+            alias_method :exit, ExtendCommand.irb_original_method_name('exit')
+          end
+          if block_given?
+            begin
+              yield
+            ensure
+              exit
+            end
+          end
+        end
+        pid
+      end
+    end
+  end
+end
+# :startdoc:
+
+

data/lib/irb/cmd/help.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: false
+#
+#   help.rb - helper using ri
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#
+# --
+#
+#
+#
+
+require_relative "nop"
+
+# :stopdoc:
+module IRB
+  module ExtendCommand
+    class Help < Nop
+      def execute(*names)
+        require 'rdoc/ri/driver'
+        IRB::ExtendCommand::Help.const_set(:Ri, RDoc::RI::Driver.new)
+      rescue LoadError, SystemExit
+        IRB::ExtendCommand::Help.remove_method(:execute)
+        # raise NoMethodError in ensure
+      else
+        def execute(*names)
+          if names.empty?
+            Ri.interactive
+            return
+          end
+          names.each do |name|
+            begin
+              Ri.display_name(name.to_s)
+            rescue RDoc::RI::Error
+              puts $!.message
+            end
+          end
+          nil
+        end
+        nil
+      ensure
+        execute(*names)
+      end
+    end
+  end
+end
+# :startdoc:

data/lib/irb/cmd/load.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: false
+#
+#   load.rb -
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+require_relative "nop"
+require_relative "../ext/loader"
+
+# :stopdoc:
+module IRB
+  module ExtendCommand
+    class Load < Nop
+      include IrbLoader
+
+      def execute(file_name, priv = nil)
+        return irb_load(file_name, priv)
+      end
+    end
+
+    class Require < Nop
+      include IrbLoader
+
+      def execute(file_name)
+
+        rex = Regexp.new("#{Regexp.quote(file_name)}(\.o|\.rb)?")
+        return false if $".find{|f| f =~ rex}
+
+        case file_name
+        when /\.rb$/
+          begin
+            if irb_load(file_name)
+              $".push file_name
+              return true
+            end
+          rescue LoadError
+          end
+        when /\.(so|o|sl)$/
+          return ruby_require(file_name)
+        end
+
+        begin
+          irb_load(f = file_name + ".rb")
+          $".push f
+          return true
+        rescue LoadError
+          return ruby_require(file_name)
+        end
+      end
+    end
+
+    class Source < Nop
+      include IrbLoader
+      def execute(file_name)
+        source_file(file_name)
+      end
+    end
+  end
+
+end
+# :startdoc:

data/lib/irb/cmd/nop.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: false
+#
+#   nop.rb -
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+# :stopdoc:
+module IRB
+  module ExtendCommand
+    class Nop
+
+
+      def self.execute(conf, *opts)
+        command = new(conf)
+        command.execute(*opts)
+      end
+
+      def initialize(conf)
+        @irb_context = conf
+      end
+
+      attr_reader :irb_context
+
+      def irb
+        @irb_context.irb
+      end
+
+      def execute(*opts)
+        #nop
+      end
+    end
+  end
+end
+# :startdoc:

data/lib/irb/cmd/pushws.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: false
+#
+#   change-ws.rb -
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+require_relative "nop"
+require_relative "../ext/workspaces"
+
+# :stopdoc:
+module IRB
+  module ExtendCommand
+    class Workspaces < Nop
+      def execute(*obj)
+        irb_context.workspaces.collect{|ws| ws.main}
+      end
+    end
+
+    class PushWorkspace < Workspaces
+      def execute(*obj)
+        irb_context.push_workspace(*obj)
+        super
+      end
+    end
+
+    class PopWorkspace < Workspaces
+      def execute(*obj)
+        irb_context.pop_workspace(*obj)
+        super
+      end
+    end
+  end
+end
+# :startdoc:
+

data/lib/irb/cmd/subirb.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: false
+#   multi.rb -
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+require_relative "nop"
+require_relative "../ext/multi-irb"
+
+# :stopdoc:
+module IRB
+  module ExtendCommand
+    class IrbCommand < Nop
+      def execute(*obj)
+        IRB.irb(nil, *obj)
+      end
+    end
+
+    class Jobs < Nop
+      def execute
+        IRB.JobManager
+      end
+    end
+
+    class Foreground < Nop
+      def execute(key)
+        IRB.JobManager.switch(key)
+      end
+    end
+
+    class Kill < Nop
+      def execute(*keys)
+        IRB.JobManager.kill(*keys)
+      end
+    end
+  end
+end
+# :startdoc:

data/lib/irb/color.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+require 'reline'
+require 'ripper'
+
+module IRB # :nodoc:
+  module Color
+    CLEAR     = 0
+    BOLD      = 1
+    UNDERLINE = 4
+    REVERSE   = 7
+    RED       = 31
+    GREEN     = 32
+    YELLOW    = 33
+    BLUE      = 34
+    MAGENTA   = 35
+    CYAN      = 36
+
+    TOKEN_KEYWORDS = {
+      on_kw: ['nil', 'self', 'true', 'false', '__FILE__', '__LINE__'],
+      on_const: ['ENV'],
+    }
+    private_constant :TOKEN_KEYWORDS
+
+    # A constant of all-bit 1 to match any Ripper's state in #dispatch_seq
+    ALL = -1
+    private_constant :ALL
+
+    begin
+      # Following pry's colors where possible, but sometimes having a compromise like making
+      # backtick and regexp as red (string's color, because they're sharing tokens).
+      TOKEN_SEQ_EXPRS = {
+        on_CHAR:            [[BLUE, BOLD],            ALL],
+        on_backtick:        [[RED, BOLD],             ALL],
+        on_comment:         [[BLUE, BOLD],            ALL],
+        on_const:           [[BLUE, BOLD, UNDERLINE], ALL],
+        on_embexpr_beg:     [[RED],                   ALL],
+        on_embexpr_end:     [[RED],                   ALL],
+        on_embvar:          [[RED],                   ALL],
+        on_float:           [[MAGENTA, BOLD],         ALL],
+        on_gvar:            [[GREEN, BOLD],           ALL],
+        on_heredoc_beg:     [[RED],                   ALL],
+        on_heredoc_end:     [[RED],                   ALL],
+        on_ident:           [[BLUE, BOLD],            Ripper::EXPR_ENDFN],
+        on_imaginary:       [[BLUE, BOLD],            ALL],
+        on_int:             [[BLUE, BOLD],            ALL],
+        on_kw:              [[GREEN],                 ALL],
+        on_label:           [[MAGENTA],               ALL],
+        on_label_end:       [[RED, BOLD],             ALL],
+        on_qsymbols_beg:    [[RED, BOLD],             ALL],
+        on_qwords_beg:      [[RED, BOLD],             ALL],
+        on_rational:        [[BLUE, BOLD],            ALL],
+        on_regexp_beg:      [[RED, BOLD],             ALL],
+        on_regexp_end:      [[RED, BOLD],             ALL],
+        on_symbeg:          [[YELLOW],                ALL],
+        on_symbols_beg:     [[RED, BOLD],             ALL],
+        on_tstring_beg:     [[RED, BOLD],             ALL],
+        on_tstring_content: [[RED],                   ALL],
+        on_tstring_end:     [[RED, BOLD],             ALL],
+        on_words_beg:       [[RED, BOLD],             ALL],
+        on_parse_error:     [[RED, REVERSE],          ALL],
+        compile_error:      [[RED, REVERSE],          ALL],
+      }
+    rescue NameError
+      # Give up highlighting Ripper-incompatible older Ruby
+      TOKEN_SEQ_EXPRS = {}
+    end
+    private_constant :TOKEN_SEQ_EXPRS
+
+    class << self
+      def colorable?
+        $stdout.tty? && supported? && (/mswin|mingw/ =~ RUBY_PLATFORM || (ENV.key?('TERM') && ENV['TERM'] != 'dumb'))
+      end
+
+      def inspect_colorable?(obj, seen: {})
+        case obj
+        when String, Symbol, Regexp, Integer, Float, FalseClass, TrueClass, NilClass
+          true
+        when Hash
+          without_circular_ref(obj, seen: seen) do
+            obj.all? { |k, v| inspect_colorable?(k, seen: seen) && inspect_colorable?(v, seen: seen) }
+          end
+        when Array
+          without_circular_ref(obj, seen: seen) do
+            obj.all? { |o| inspect_colorable?(o, seen: seen) }
+          end
+        when Range
+          inspect_colorable?(obj.begin, seen: seen) && inspect_colorable?(obj.end, seen: seen)
+        when Module
+          !obj.name.nil?
+        else
+          false
+        end
+      end
+
+      def clear
+        return '' unless colorable?
+        "\e[#{CLEAR}m"
+      end
+
+      def colorize(text, seq)
+        return text unless colorable?
+        seq = seq.map { |s| "\e[#{const_get(s)}m" }.join('')
+        "#{seq}#{text}#{clear}"
+      end
+
+      # If `complete` is false (code is incomplete), this does not warn compile_error.
+      # This option is needed to avoid warning a user when the compile_error is happening
+      # because the input is not wrong but just incomplete.
+      def colorize_code(code, complete: true)
+        return code unless colorable?
+
+        symbol_state = SymbolState.new
+        colored = +''
+        length = 0
+
+        scan(code, allow_last_error: !complete) do |token, str, expr|
+          in_symbol = symbol_state.scan_token(token)
+          str.each_line do |line|
+            line = Reline::Unicode.escape_for_print(line)
+            if seq = dispatch_seq(token, expr, line, in_symbol: in_symbol)
+              colored << seq.map { |s| "\e[#{s}m" }.join('')
+              colored << line.sub(/\Z/, clear)
+            else
+              colored << line
+            end
+          end
+          length += str.bytesize
+        end
+
+        # give up colorizing incomplete Ripper tokens
+        if length != code.bytesize
+          return Reline::Unicode.escape_for_print(code)
+        end
+
+        colored
+      end
+
+      private
+
+      def without_circular_ref(obj, seen:, &block)
+        return false if seen.key?(obj.object_id)
+        seen[obj.object_id] = true
+        block.call
+      ensure
+        seen.delete(obj.object_id)
+      end
+
+      # Ripper::Lexer::Elem#state is supported on Ruby 2.5+
+      def supported?
+        return @supported if defined?(@supported)
+        @supported = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.5.0')
+      end
+
+      def scan(code, allow_last_error:)
+        pos = [1, 0]
+
+        verbose, $VERBOSE = $VERBOSE, nil
+        lexer = Ripper::Lexer.new(code)
+        if lexer.respond_to?(:scan) # Ruby 2.7+
+          lexer.scan.each do |elem|
+            str = elem.tok
+            next if allow_last_error and /meets end of file|unexpected end-of-input/ =~ elem.message
+            next if ([elem.pos[0], elem.pos[1] + str.bytesize] <=> pos) <= 0
+
+            str.each_line do |line|
+              if line.end_with?("\n")
+                pos[0] += 1
+                pos[1] = 0
+              else
+                pos[1] += line.bytesize
+              end
+            end
+
+            yield(elem.event, str, elem.state)
+          end
+        else
+          lexer.parse.each do |elem|
+            yield(elem.event, elem.tok, elem.state)
+          end
+        end
+        $VERBOSE = verbose
+      end
+
+      def dispatch_seq(token, expr, str, in_symbol:)
+        if token == :on_parse_error or token == :compile_error
+          TOKEN_SEQ_EXPRS[token][0]
+        elsif in_symbol
+          [YELLOW]
+        elsif TOKEN_KEYWORDS.fetch(token, []).include?(str)
+          [CYAN, BOLD]
+        elsif (seq, exprs = TOKEN_SEQ_EXPRS[token]; (expr & (exprs || 0)) != 0)
+          seq
+        else
+          nil
+        end
+      end
+    end
+
+    # A class to manage a state to know whether the current token is for Symbol or not.
+    class SymbolState
+      def initialize
+        # Push `true` to detect Symbol. `false` to increase the nest level for non-Symbol.
+        @stack = []
+      end
+
+      # Return true if the token is a part of Symbol.
+      def scan_token(token)
+        prev_state = @stack.last
+        case token
+        when :on_symbeg, :on_symbols_beg, :on_qsymbols_beg
+          @stack << true
+        when :on_ident, :on_op, :on_const, :on_ivar, :on_cvar, :on_gvar, :on_kw
+          if @stack.last # Pop only when it's Symbol
+            @stack.pop
+            return prev_state
+          end
+        when :on_tstring_beg
+          @stack << false
+        when :on_embexpr_beg
+          @stack << false
+          return prev_state
+        when :on_tstring_end # :on_tstring_end may close Symbol
+          @stack.pop
+          return prev_state
+        when :on_embexpr_end
+          @stack.pop
+        end
+        @stack.last
+      end
+    end
+    private_constant :SymbolState
+  end
+end