irb 1.15.2 → 1.17.0

data/lib/irb/color.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 require 'reline'
-require 'ripper'
+require 'prism'
 require_relative 'ruby-lex'
 
 module IRB # :nodoc:
@@ -18,65 +18,100 @@ module IRB # :nodoc:
     CYAN      = 36
     WHITE     = 37
 
-    TOKEN_KEYWORDS = {
-      on_kw: ['nil', 'self', 'true', 'false', '__FILE__', '__LINE__', '__ENCODING__'],
-      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_backref:         [[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],
-        on_assign_error:    [[RED, REVERSE],          ALL],
-        on_alias_error:     [[RED, REVERSE],          ALL],
-        on_class_name_error:[[RED, REVERSE],          ALL],
-        on_param_error:     [[RED, REVERSE],          ALL],
-        on___end__:         [[GREEN],                 ALL],
-      }
-    rescue NameError
-      # Give up highlighting Ripper-incompatible older Ruby
-      TOKEN_SEQ_EXPRS = {}
+    # Following pry's colors where possible
+    TOKEN_SEQS = {
+      KEYWORD_NIL:        [CYAN, BOLD],
+      KEYWORD_SELF:       [CYAN, BOLD],
+      KEYWORD_TRUE:       [CYAN, BOLD],
+      KEYWORD_FALSE:      [CYAN, BOLD],
+      KEYWORD___FILE__:   [CYAN, BOLD],
+      KEYWORD___LINE__:   [CYAN, BOLD],
+      KEYWORD___ENCODING__: [CYAN, BOLD],
+      CHARACTER_LITERAL:  [BLUE, BOLD],
+      BACK_REFERENCE:     [GREEN, BOLD],
+      BACKTICK:           [RED, BOLD],
+      COMMENT:            [BLUE, BOLD],
+      EMBDOC_BEGIN:       [BLUE, BOLD],
+      EMBDOC_LINE:        [BLUE, BOLD],
+      EMBDOC_END:         [BLUE, BOLD],
+      CONSTANT:           [BLUE, BOLD, UNDERLINE],
+      EMBEXPR_BEGIN:      [RED],
+      EMBEXPR_END:        [RED],
+      EMBVAR:             [RED],
+      FLOAT:              [MAGENTA, BOLD],
+      GLOBAL_VARIABLE:    [GREEN, BOLD],
+      HEREDOC_START:      [RED],
+      HEREDOC_END:        [RED],
+      FLOAT_IMAGINARY:    [BLUE, BOLD],
+      INTEGER_IMAGINARY:  [BLUE, BOLD],
+      FLOAT_RATIONAL_IMAGINARY:  [BLUE, BOLD],
+      INTEGER_RATIONAL_IMAGINARY:  [BLUE, BOLD],
+      INTEGER:            [BLUE, BOLD],
+      INTEGER_RATIONAL:   [BLUE, BOLD],
+      FLOAT_RATIONAL:     [BLUE, BOLD],
+      KEYWORD_END:        [GREEN],
+      KEYWORD_CLASS:      [GREEN],
+      KEYWORD_MODULE:     [GREEN],
+      KEYWORD_IF:         [GREEN],
+      KEYWORD_IF_MODIFIER: [GREEN],
+      KEYWORD_UNLESS_MODIFIER: [GREEN],
+      KEYWORD_WHILE_MODIFIER: [GREEN],
+      KEYWORD_UNTIL_MODIFIER: [GREEN],
+      KEYWORD_RESCUE_MODIFIER: [GREEN],
+      KEYWORD_THEN:       [GREEN],
+      KEYWORD_UNLESS:     [GREEN],
+      KEYWORD_ELSE:       [GREEN],
+      KEYWORD_ELSIF:      [GREEN],
+      KEYWORD_WHILE:      [GREEN],
+      KEYWORD_UNTIL:      [GREEN],
+      KEYWORD_CASE:       [GREEN],
+      KEYWORD_WHEN:       [GREEN],
+      KEYWORD_IN:         [GREEN],
+      KEYWORD_DEF:        [GREEN],
+      KEYWORD_DO:         [GREEN],
+      KEYWORD_DO_LOOP:    [GREEN],
+      KEYWORD_FOR:        [GREEN],
+      KEYWORD_BEGIN:      [GREEN],
+      KEYWORD_RESCUE:     [GREEN],
+      KEYWORD_ENSURE:     [GREEN],
+      KEYWORD_ALIAS:      [GREEN],
+      KEYWORD_UNDEF:      [GREEN],
+      KEYWORD_BEGIN_UPCASE: [GREEN],
+      KEYWORD_END_UPCASE: [GREEN],
+      KEYWORD_YIELD:      [GREEN],
+      KEYWORD_REDO:       [GREEN],
+      KEYWORD_RETRY:      [GREEN],
+      KEYWORD_NEXT:       [GREEN],
+      KEYWORD_BREAK:      [GREEN],
+      KEYWORD_SUPER:      [GREEN],
+      KEYWORD_RETURN:     [GREEN],
+      KEYWORD_DEFINED:    [GREEN],
+      KEYWORD_NOT:        [GREEN],
+      KEYWORD_AND:        [GREEN],
+      KEYWORD_OR:         [GREEN],
+      LABEL:              [MAGENTA],
+      LABEL_END:          [RED, BOLD],
+      NUMBERED_REFERENCE: [GREEN, BOLD],
+      PERCENT_UPPER_W:    [RED, BOLD],
+      PERCENT_LOWER_W:    [RED, BOLD],
+      PERCENT_LOWER_X:    [RED, BOLD],
+      REGEXP_BEGIN:       [RED, BOLD],
+      REGEXP_END:         [RED, BOLD],
+      STRING_BEGIN:       [RED, BOLD],
+      STRING_CONTENT:     [RED],
+      STRING_END:         [RED, BOLD],
+      __END__:            [GREEN],
+      # tokens from syntax tree traversal
+      method_name:        [BLUE, BOLD],
+      symbol:             [YELLOW],
+      # special colorization
+      error:              [RED, REVERSE],
+      const_env:          [CYAN, BOLD],
+    }.transform_values do |styles|
+      styles.map { |style| "\e[#{style}m" }.join
     end
-    private_constant :TOKEN_SEQ_EXPRS
-
-    ERROR_TOKENS = TOKEN_SEQ_EXPRS.keys.select { |k| k.to_s.end_with?('error') }
-    private_constant :ERROR_TOKENS
+    CLEAR_SEQ = "\e[#{CLEAR}m"
+    private_constant :TOKEN_SEQS, :CLEAR_SEQ
 
     class << self
       def colorable?
@@ -113,14 +148,13 @@ module IRB # :nodoc:
       end
 
       def clear(colorable: colorable?)
-        return '' unless colorable
-        "\e[#{CLEAR}m"
+        colorable ? CLEAR_SEQ : ''
       end
 
       def colorize(text, seq, colorable: colorable?)
         return text unless colorable
         seq = seq.map { |s| "\e[#{const_get(s)}m" }.join('')
-        "#{seq}#{text}#{clear(colorable: colorable)}"
+        "#{seq}#{text}#{CLEAR_SEQ}"
       end
 
       # If `complete` is false (code is incomplete), this does not warn compile_error.
@@ -129,135 +163,132 @@ module IRB # :nodoc:
       def colorize_code(code, complete: true, ignore_error: false, colorable: colorable?, local_variables: [])
         return code unless colorable
 
-        symbol_state = SymbolState.new
-        colored = +''
-        lvars_code = RubyLex.generate_local_variables_assign_code(local_variables)
-        code_with_lvars = lvars_code ? "#{lvars_code}\n#{code}" : code
+        result = Prism.parse_lex(code, scopes: [local_variables])
 
-        scan(code_with_lvars, allow_last_error: !complete) do |token, str, expr|
-          # handle uncolorable code
-          if token.nil?
-            colored << Reline::Unicode.escape_for_print(str)
-            next
-          end
+        # IRB::ColorPrinter skips colorizing syntax invalid fragments
+        return Reline::Unicode.escape_for_print(code) if ignore_error && !result.success?
+
+        errors = result.errors
+        unless complete
+          errors = errors.reject { |error| error.message =~ /\Aexpected a|unexpected end-of-input|unterminated/ }
+        end
+
+        prism_node, prism_tokens = result.value
+        visitor = ColorizeVisitor.new
+        prism_node.accept(visitor)
+
+        error_tokens = errors.map { |e| [e.location.start_line, e.location.start_column, 0, e.location.end_line, e.location.end_column, :error, e.location.slice] }
+        error_tokens.reject! { |t| t.last.match?(/\A\s*\z/) }
+        tokens = prism_tokens.map { |t,| [t.location.start_line, t.location.start_column, 2, t.location.end_line, t.location.end_column, t.type, t.value] }
+        tokens.pop if tokens.last&.[](5) == :EOF
 
-          # IRB::ColorPrinter skips colorizing fragments with any invalid token
-          if ignore_error && ERROR_TOKENS.include?(token)
-            return Reline::Unicode.escape_for_print(code)
+        colored = +''
+        line_index = 0
+        col = 0
+        lines = code.lines
+        flush = -> next_line_index, next_col {
+          return if next_line_index == line_index && next_col == col
+          (line_index...[next_line_index, lines.size].min).each do |ln|
+            colored << Reline::Unicode.escape_for_print(lines[line_index].byteslice(col..))
+            line_index = ln + 1
+            col = 0
+          end
+          unless col == next_col
+            colored << Reline::Unicode.escape_for_print(lines[next_line_index].byteslice(col..next_col - 1))
           end
+        }
+
+        (visitor.tokens + tokens + error_tokens).sort.each do |start_line, start_column, _priority, end_line, end_column, type, value|
+          next if start_line - 1 < line_index || (start_line - 1 == line_index && start_column < col)
 
-          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(colorable: colorable))
-            else
-              colored << line
+          flush.call(start_line - 1, start_column)
+          if type == :CONSTANT && value == 'ENV'
+            color = TOKEN_SEQS[:const_env]
+          elsif type == :__END__
+            color = TOKEN_SEQS[type]
+            end_line = start_line
+            value = '__END__'
+            end_column = start_column + 7
+          else
+            color = TOKEN_SEQS[type]
+          end
+          if color
+            value.split(/(\n)/).each do |s|
+              colored << (s == "\n" ? s : "#{color}#{Reline::Unicode.escape_for_print(s)}#{CLEAR_SEQ}")
             end
+          else
+            colored << value
           end
+          line_index = end_line - 1
+          col = end_column
         end
-
-        if lvars_code
-          raise "#{lvars_code.dump} should have no \\n" if lvars_code.include?("\n")
-          colored.sub!(/\A.+\n/, '') # delete_prefix lvars_code with colors
-        end
+        flush.call lines.size, 0
         colored
       end
 
-      private
-
-      def without_circular_ref(obj, seen:, &block)
-        return false if seen.key?(obj)
-        seen[obj] = true
-        block.call
-      ensure
-        seen.delete(obj)
-      end
+      class ColorizeVisitor < Prism::Visitor
+        attr_reader :tokens
+        def initialize
+          @tokens = []
+        end
 
-      def scan(code, allow_last_error:)
-        verbose, $VERBOSE = $VERBOSE, nil
-        RubyLex.compile_with_errors_suppressed(code) do |inner_code, line_no|
-          lexer = Ripper::Lexer.new(inner_code, '(ripper)', line_no)
-          byte_pos = 0
-          line_positions = [0]
-          inner_code.lines.each do |line|
-            line_positions << line_positions.last + line.bytesize
+        def dispatch(location, type)
+          if location
+            @tokens << [location.start_line, location.start_column, 1, location.end_line, location.end_column, type, location.slice]
           end
+        end
 
-          on_scan = proc do |elem|
-            start_pos = line_positions[elem.pos[0] - 1] + elem.pos[1]
+        def visit_array_node(node)
+          if node.opening&.match?(/\A%[iI]/)
+            dispatch node.opening_loc, :symbol
+            dispatch node.closing_loc, :symbol
+          end
+          super
+        end
 
-            # yield uncolorable code
-            if byte_pos < start_pos
-              yield(nil, inner_code.byteslice(byte_pos...start_pos), nil)
-            end
+        def visit_def_node(node)
+          dispatch node.name_loc, :method_name
+          super
+        end
 
-            if byte_pos <= start_pos
-              str = elem.tok
-              yield(elem.event, str, elem.state)
-              byte_pos = start_pos + str.bytesize
+        def visit_interpolated_symbol_node(node)
+          dispatch node.opening_loc, :symbol
+          node.parts.each do |part|
+            case part
+            when Prism::StringNode
+              dispatch part.content_loc, :symbol
+            when Prism::EmbeddedStatementsNode
+              dispatch part.opening_loc, :symbol
+              dispatch part.closing_loc, :symbol
+            when Prism::EmbeddedVariableNode
+              dispatch part.operator_loc, :symbol
             end
           end
+          dispatch node.closing_loc, :symbol
+          super
+        end
 
-          lexer.scan.each do |elem|
-            next if allow_last_error and /meets end of file|unexpected end-of-input/ =~ elem.message
-            on_scan.call(elem)
+        def visit_symbol_node(node)
+          if (node.opening_loc.nil? && node.closing == ':') || node.closing&.match?(/\A['"]:\z/)
+            # Colorize { symbol: 1 } and { 'symbol': 1 } as label
+            dispatch node.location, :LABEL
+          else
+            dispatch node.opening_loc, :symbol
+            dispatch node.value_loc, :symbol
+            dispatch node.closing_loc, :symbol
           end
-          # yield uncolorable DATA section
-          yield(nil, inner_code.byteslice(byte_pos...inner_code.bytesize), nil) if byte_pos < inner_code.bytesize
         end
-      ensure
-        $VERBOSE = verbose
       end
 
-      def dispatch_seq(token, expr, str, in_symbol:)
-        if ERROR_TOKENS.include?(token)
-          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
+      private
 
-      # 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, :on_backtick
-          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
+      def without_circular_ref(obj, seen:, &block)
+        return false if seen.key?(obj)
+        seen[obj] = true
+        block.call
+      ensure
+        seen.delete(obj)
       end
     end
-    private_constant :SymbolState
   end
 end

data/lib/irb/command/copy.rb

@@ -54,6 +54,8 @@ module IRB
       def clipboard_program
         @clipboard_program ||= if IRB.conf[:COPY_COMMAND]
                                  IRB.conf[:COPY_COMMAND]
+                               elsif executable?("clip.exe")
+                                 "clip.exe"
                                elsif executable?("pbcopy")
                                  "pbcopy"
                                elsif executable?("xclip")
@@ -62,12 +64,20 @@ module IRB
       end
 
       def executable?(command)
-        system("which #{command} > /dev/null 2>&1")
+        if windows?
+          system("where #{command} > NUL 2>&1")
+        else
+          system("which #{command} > /dev/null 2>&1")
+        end
       end
 
       def clipboard_available?
         !!clipboard_program
       end
+
+      def windows?
+        /mingw|mswin/.match?(RUBY_PLATFORM)
+      end
     end
   end
 end

data/lib/irb/completion.rb

@@ -12,26 +12,6 @@ module IRB
 
     # Set of reserved words used by Ruby, you should not use these for
     # constants or variables
-    ReservedWords = %w[
-      __ENCODING__ __LINE__ __FILE__
-      BEGIN END
-      alias and
-      begin break
-      case class
-      def defined? do
-      else elsif end ensure
-      false for
-      if in
-      module
-      next nil not
-      or
-      redo rescue retry return
-      self super
-      then true
-      undef unless until
-      when while
-      yield
-    ]
 
     HELP_COMMAND_PREPOSING = /\Ahelp\s+/
 
@@ -60,13 +40,13 @@ module IRB
 
     def retrieve_gem_and_system_load_path
       candidates = (GEM_PATHS | $LOAD_PATH)
-      candidates.map do |p|
+      candidates.filter_map do |p|
         if p.respond_to?(:to_path)
           p.to_path
         else
           String(p) rescue nil
         end
-      end.compact.sort
+      end.sort
     end
 
     def retrieve_files_to_require_from_load_path
@@ -127,7 +107,14 @@ module IRB
 
       return commands unless result
 
-      commands | result.completion_candidates.map { target + _1 }
+      encoded_candidates = result.completion_candidates.filter_map do |i|
+        encoded = i.encode(Encoding.default_external)
+        target + encoded
+      rescue Encoding::UndefinedConversionError
+        # If the string cannot be converted, we just ignore it
+        nil
+      end
+      commands | encoded_candidates
     end
 
     def doc_namespace(preposing, matched, _postposing, bind:)
@@ -179,7 +166,7 @@ module IRB
       else
         return nil # It's not String literal
       end
-      tokens = RubyLex.ripper_lex_without_warning(preposing.gsub(/\s*\z/, ''))
+      tokens = RubyLex.ripper_lex_without_warning(preposing.rstrip)
       tok = nil
       tokens.reverse_each do |t|
         unless [:on_lparen, :on_sp, :on_ignored_sp, :on_nl, :on_ignored_nl, :on_comment].include?(t.event)
@@ -191,16 +178,12 @@ module IRB
 
       case tok.tok
       when 'require'
-        retrieve_files_to_require_from_load_path.select { |path|
-          path.start_with?(actual_target)
-        }.map { |path|
-          quote + path
+        retrieve_files_to_require_from_load_path.filter_map { |path|
+          quote + path if path.start_with?(actual_target)
         }
       when 'require_relative'
-        retrieve_files_to_require_relative_from_current_dir.select { |path|
-          path.start_with?(actual_target)
-        }.map { |path|
-          quote + path
+        retrieve_files_to_require_relative_from_current_dir.filter_map { |path|
+          quote + path if path.start_with?(actual_target)
         }
       end
     end
@@ -218,7 +201,12 @@ module IRB
       # It doesn't make sense to propose commands with other preposing
       commands = [] unless preposing.empty?
 
-      completion_data = retrieve_completion_data(target, bind: bind, doc_namespace: false).compact.map{ |i| i.encode(Encoding.default_external) }
+      completion_data = retrieve_completion_data(target, bind: bind, doc_namespace: false).compact.filter_map do |i|
+        i.encode(Encoding.default_external)
+      rescue Encoding::UndefinedConversionError
+        # If the string cannot be converted, we just ignore it
+        nil
+      end
       commands | completion_data
     end
 
@@ -287,7 +275,7 @@ module IRB
           nil
         else
           sym = $1
-          candidates = Symbol.all_symbols.collect do |s|
+          candidates = Symbol.all_symbols.filter_map do |s|
             s.inspect
           rescue EncodingError
             # ignore
@@ -459,12 +447,19 @@ module IRB
             eval("#{perfect_match_var}.class.name", bind) rescue nil
           else
             candidates = (bind.eval_methods | bind.eval_private_methods | bind.local_variables | bind.eval_instance_variables | bind.eval_class_constants).collect{|m| m.to_s}
-            candidates |= ReservedWords
+            candidates |= RubyLex::RESERVED_WORDS.map(&:to_s)
             candidates.find{ |i| i == input }
           end
         else
           candidates = (bind.eval_methods | bind.eval_private_methods | bind.local_variables | bind.eval_instance_variables | bind.eval_class_constants).collect{|m| m.to_s}
-          candidates |= ReservedWords
+          candidates |= RubyLex::RESERVED_WORDS.map(&:to_s)
+
+          target_encoding = Encoding.default_external
+          candidates = candidates.compact.filter_map do |candidate|
+            candidate.encoding == target_encoding ? candidate : candidate.encode(target_encoding)
+          rescue EncodingError
+            nil
+          end
           candidates.grep(/^#{Regexp.quote(input)}/).sort
         end
       end

data/lib/irb/context.rb

@@ -632,14 +632,15 @@ module IRB
         command_class = Command.load_command(command)
       end
 
-      # Check visibility
-      public_method = !!KERNEL_PUBLIC_METHOD.bind_call(main, command) rescue false
-      private_method = !public_method && !!KERNEL_METHOD.bind_call(main, command) rescue false
-      if command_class && Command.execute_as_command?(command, public_method: public_method, private_method: private_method)
-        Statement::Command.new(code, command_class, arg)
-      else
-        Statement::Expression.new(code, is_assignment_expression)
+      if command_class
+        # Check whether the command conflicts with existing methods
+        public_method = !!KERNEL_PUBLIC_METHOD.bind_call(main, command) rescue false
+        private_method = !public_method && !!KERNEL_METHOD.bind_call(main, command) rescue false
+        if Command.execute_as_command?(command, public_method: public_method, private_method: private_method)
+          return Statement::Command.new(code, command_class, arg)
+        end
       end
+      Statement::Expression.new(code, is_assignment_expression)
     end
 
     def colorize_input(input, complete:)
@@ -648,7 +649,7 @@ module IRB
         parsed_input = parse_input(input, false)
         if parsed_input.is_a?(Statement::Command)
           name, sep, arg = input.split(/(\s+)/, 2)
-          arg = IRB::Color.colorize_code(arg, complete: complete, local_variables: lvars)
+          arg = IRB::Color.colorize_code(arg, complete: complete, local_variables: lvars) if arg
           "#{IRB::Color.colorize(name, [:BOLD])}\e[m#{sep}#{arg}"
         else
           IRB::Color.colorize_code(input, complete: complete, local_variables: lvars)

data/lib/irb/debug.rb

@@ -49,7 +49,7 @@ module IRB
           def DEBUGGER__.capture_frames(*args)
             frames = capture_frames_without_irb(*args)
             frames.reject! do |frame|
-              frame.realpath&.start_with?(IRB_DIR) || frame.path == "<internal:prelude>"
+              frame.realpath&.start_with?(IRB_DIR) || frame.path&.start_with?("<internal:")
             end
             frames
           end
@@ -60,7 +60,7 @@ module IRB
         if !DEBUGGER__::CONFIG[:no_hint] && irb.context.io.is_a?(RelineInputMethod)
           Reline.output_modifier_proc = proc do |input, complete:|
             unless input.strip.empty?
-              cmd = input.split(/\s/, 2).first
+              cmd = input[/\S+/]
 
               if !complete && DEBUGGER__.commands.key?(cmd)
                 input = input.sub(/\n$/, " # debug command\n")
@@ -87,7 +87,7 @@ module IRB
       module SkipPathHelperForIRB
         def skip_internal_path?(path)
           # The latter can be removed once https://github.com/ruby/debug/issues/866 is resolved
-          super || path.match?(IRB_DIR) || path.match?('<internal:prelude>')
+          super || path&.match?(IRB_DIR) || path&.match?('<internal:prelude>')
         end
       end
 

data/lib/irb/easter-egg.rb

@@ -121,12 +121,13 @@ module IRB
           interrupted = false
           prev_trap = trap("SIGINT") { interrupted = true }
           canvas = Canvas.new(Reline.get_screen_size)
+          otio = Reline::IOGate.prep
           Reline::IOGate.set_winch_handler do
             canvas = Canvas.new(Reline.get_screen_size)
           end
           ruby_model = RubyModel.new
           print "\e[?25l" # hide cursor
-          0.step do |i| # TODO (0..).each needs Ruby 2.6 or later
+          (0..).each do |i|
             buff = canvas.draw do
               ruby_model.render_frame(i) do |p1, p2|
                 canvas.line(p1, p2)
@@ -139,6 +140,7 @@ module IRB
           end
         rescue Interrupt
         ensure
+          Reline::IOGate.deprep(otio)
           print "\e[?25h" # show cursor
           trap("SIGINT", prev_trap)
         end