irb 1.14.0 → 1.18.0

data/lib/irb/context.rb

@@ -13,6 +13,10 @@ module IRB
   # A class that wraps the current state of the irb session, including the
   # configuration of IRB.conf.
   class Context
+    KERNEL_PUBLIC_METHOD = ::Kernel.instance_method(:public_method)
+    KERNEL_METHOD = ::Kernel.instance_method(:method)
+
+    ASSIGN_OPERATORS_REGEXP = Regexp.union(%w[= += -= *= /= %= **= &= |= &&= ||= ^= <<= >>=])
     # Creates a new IRB context.
     #
     # The optional +input_method+ argument:
@@ -148,26 +152,9 @@ module IRB
         @newline_before_multiline_output = true
       end
 
-      @user_aliases = IRB.conf[:COMMAND_ALIASES].dup
-      @command_aliases = @user_aliases.merge(KEYWORD_ALIASES)
-    end
-
-    private def term_interactive?
-      return true if ENV['TEST_IRB_FORCE_INTERACTIVE']
-      STDIN.tty? && ENV['TERM'] != 'dumb'
+      @command_aliases = IRB.conf[:COMMAND_ALIASES].dup
     end
 
-    # because all input will eventually be evaluated as Ruby code,
-    # command names that conflict with Ruby keywords need special workaround
-    # we can remove them once we implemented a better command system for IRB
-    KEYWORD_ALIASES = {
-      :break => :irb_break,
-      :catch => :irb_catch,
-      :next => :irb_next,
-    }.freeze
-
-    private_constant :KEYWORD_ALIASES
-
     def use_tracer=(val)
       require_relative "ext/tracer" if val
       IRB.conf[:USE_TRACER] = val
@@ -185,39 +172,6 @@ module IRB
       __send__(__method__, val)
     end
 
-    private def build_completor
-      completor_type = IRB.conf[:COMPLETOR]
-      case completor_type
-      when :regexp
-        return RegexpCompletor.new
-      when :type
-        completor = build_type_completor
-        return completor if completor
-      else
-        warn "Invalid value for IRB.conf[:COMPLETOR]: #{completor_type}"
-      end
-      # Fallback to RegexpCompletor
-      RegexpCompletor.new
-    end
-
-    private def build_type_completor
-      if RUBY_ENGINE == 'truffleruby'
-        # Avoid SyntaxError. truffleruby does not support endless method definition yet.
-        warn 'TypeCompletor is not supported on TruffleRuby yet'
-        return
-      end
-
-      begin
-        require 'repl_type_completor'
-      rescue LoadError => e
-        warn "TypeCompletor requires `gem repl_type_completor`: #{e.message}"
-        return
-      end
-
-      ReplTypeCompletor.preload_rbs
-      TypeCompletor.new(self)
-    end
-
     def save_history=(val)
       IRB.conf[:SAVE_HISTORY] = val
     end
@@ -310,6 +264,8 @@ module IRB
     attr_reader :use_autocomplete
     # A copy of the default <code>IRB.conf[:INSPECT_MODE]</code>
     attr_reader :inspect_mode
+    # Inspector for the current context
+    attr_reader :inspect_method
 
     # A copy of the default <code>IRB.conf[:PROMPT_MODE]</code>
     attr_reader :prompt_mode
@@ -602,6 +558,8 @@ module IRB
         set_last_value(result)
       when Statement::Command
         statement.command_class.execute(self, statement.arg)
+      when Statement::IncorrectAlias
+        warn statement.message
       end
 
       nil
@@ -635,8 +593,78 @@ module IRB
       result
     end
 
-    def inspect_last_value # :nodoc:
-      @inspect_method.inspect_value(@last_value)
+    def parse_input(code, is_assignment_expression)
+      command_name, arg = code.strip.split(/\s+/, 2)
+      arg ||= ''
+
+      # command can only be 1 line
+      if code.lines.size != 1 ||
+        # command name is required
+        command_name.nil? ||
+        # local variable have precedence over command
+        local_variables.include?(command_name.to_sym) ||
+        # assignment expression is not a command
+        (is_assignment_expression ||
+        (arg.start_with?(ASSIGN_OPERATORS_REGEXP) && !arg.start_with?(/==|=~/)))
+        return Statement::Expression.new(code, is_assignment_expression)
+      end
+
+      command = command_name.to_sym
+
+      # Check command aliases
+      if aliased_name = command_aliases[command]
+        if command_class = Command.load_command(aliased_name)
+          command = aliased_name
+        elsif HelperMethod.helper_methods[aliased_name]
+          message = <<~MESSAGE
+            Using command alias `#{command}` for helper method `#{aliased_name}` is not supported.
+            Please check the value of `IRB.conf[:COMMAND_ALIASES]`.
+          MESSAGE
+          return Statement::IncorrectAlias.new(message)
+        else
+          message = <<~MESSAGE
+            You're trying to use command alias `#{command}` for command `#{aliased_name}`, but `#{aliased_name}` does not exist.
+            Please check the value of `IRB.conf[:COMMAND_ALIASES]`.
+          MESSAGE
+          return Statement::IncorrectAlias.new(message)
+        end
+      else
+        command_class = Command.load_command(command)
+      end
+
+      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:)
+      if IRB.conf[:USE_COLORIZE] && IRB::Color.colorable?
+        lvars = local_variables || []
+        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) if arg
+          "#{IRB::Color.colorize(name, [:BOLD])}\e[m#{sep}#{arg}"
+        else
+          IRB::Color.colorize_code(input, complete: complete, local_variables: lvars)
+        end
+      else
+        Reline::Unicode.escape_for_print(input)
+      end
+    end
+
+    def inspect_last_value(output = +'') # :nodoc:
+      @inspect_method.inspect_value(@last_value, output)
+    end
+
+    def inspector_support_stream_output?
+      @inspect_method.support_stream_output?
     end
 
     NOPRINTING_IVARS = ["@last_value"] # :nodoc:
@@ -669,5 +697,56 @@ module IRB
     def local_variables # :nodoc:
       workspace.binding.local_variables
     end
+
+    def safe_method_call_on_main(method_name)
+      main_object = main
+      Object === main_object ? main_object.__send__(method_name) : Object.instance_method(method_name).bind_call(main_object)
+    end
+
+    private
+
+    def term_interactive?
+      return true if ENV['TEST_IRB_FORCE_INTERACTIVE']
+      STDIN.tty? && ENV['TERM'] != 'dumb'
+    end
+
+    def build_completor
+      completor_type = IRB.conf[:COMPLETOR]
+
+      # Gem repl_type_completor is added to bundled gems in Ruby 3.4.
+      # Use :type as default completor only in Ruby 3.4 or later.
+      verbose = !!completor_type
+      completor_type ||= RUBY_VERSION >= '3.4' ? :type : :regexp
+
+      case completor_type
+      when :regexp
+        return RegexpCompletor.new
+      when :type
+        completor = build_type_completor(verbose: verbose)
+        return completor if completor
+      else
+        warn "Invalid value for IRB.conf[:COMPLETOR]: #{completor_type}"
+      end
+      # Fallback to RegexpCompletor
+      RegexpCompletor.new
+    end
+
+    def build_type_completor(verbose:)
+      if RUBY_ENGINE == 'truffleruby'
+        # Avoid SyntaxError. truffleruby does not support endless method definition yet.
+        warn 'TypeCompletor is not supported on TruffleRuby yet' if verbose
+        return
+      end
+
+      begin
+        require 'repl_type_completor'
+      rescue LoadError => e
+        warn "TypeCompletor requires `gem repl_type_completor`: #{e.message}" if verbose
+        return
+      end
+
+      ReplTypeCompletor.preload_rbs
+      TypeCompletor.new(self)
+    end
   end
 end

data/lib/irb/debug/ui.rb

@@ -45,9 +45,7 @@ module IRB
             $stdout.puts line.chomp
           }
         when String
-          str.each_line{|line|
-            $stdout.puts line.chomp
-          }
+          Pager.page_content(str, retain_content: true)
         when nil
           $stdout.puts
         end
@@ -56,7 +54,7 @@ module IRB
       def readline _
         setup_interrupt do
           tc = DEBUGGER__::SESSION.instance_variable_get(:@tc)
-          cmd = @irb.debug_readline(tc.current_frame.binding || TOPLEVEL_BINDING)
+          cmd = @irb.debug_readline(tc.current_frame.eval_binding || TOPLEVEL_BINDING)
 
           case cmd
           when nil # when user types C-d

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
@@ -57,22 +57,18 @@ module IRB
           DEBUGGER__::ThreadClient.prepend(SkipPathHelperForIRB)
         end
 
-        if !@output_modifier_defined && !DEBUGGER__::CONFIG[:no_hint]
-          irb_output_modifier_proc = Reline.output_modifier_proc
-
-          Reline.output_modifier_proc = proc do |output, complete:|
-            unless output.strip.empty?
-              cmd = output.split(/\s/, 2).first
+        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[/\S+/]
 
               if !complete && DEBUGGER__.commands.key?(cmd)
-                output = output.sub(/\n$/, " # debug command\n")
+                input = input.sub(/\n$/, " # debug command\n")
               end
             end
 
-            irb_output_modifier_proc.call(output, complete: complete)
+            irb.context.colorize_input(input, complete: complete)
           end
-
-          @output_modifier_defined = true
         end
 
         true
@@ -85,12 +81,13 @@ module IRB
         IRB.instance_variable_set(:@debugger_irb, irb)
         irb.context.with_debugger = true
         irb.context.irb_name += ":rdbg"
+        irb.context.io.load_history if irb.context.io.class < HistorySavingAbility
       end
 
       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/default_commands.rb

@@ -9,6 +9,7 @@ require_relative "command/cd"
 require_relative "command/chws"
 require_relative "command/context"
 require_relative "command/continue"
+require_relative "command/copy"
 require_relative "command/debug"
 require_relative "command/delete"
 require_relative "command/disable_irb"
@@ -181,9 +182,15 @@ module IRB
       [:edit, NO_OVERRIDE]
     )
 
-    _register_with_aliases(:irb_break, Command::Break)
-    _register_with_aliases(:irb_catch, Command::Catch)
-    _register_with_aliases(:irb_next, Command::Next)
+    _register_with_aliases(:irb_break, Command::Break,
+      [:break, OVERRIDE_ALL]
+    )
+    _register_with_aliases(:irb_catch, Command::Catch,
+      [:catch, OVERRIDE_PRIVATE_ONLY]
+    )
+    _register_with_aliases(:irb_next, Command::Next,
+      [:next, OVERRIDE_ALL]
+    )
     _register_with_aliases(:irb_delete, Command::Delete,
       [:delete, NO_OVERRIDE]
     )
@@ -212,7 +219,8 @@ module IRB
     )
 
     _register_with_aliases(:irb_show_doc, Command::ShowDoc,
-      [:show_doc, NO_OVERRIDE]
+      [:show_doc, NO_OVERRIDE],
+      [:ri, NO_OVERRIDE]
     )
 
     _register_with_aliases(:irb_info, Command::IrbInfo)
@@ -243,6 +251,7 @@ module IRB
     )
 
     register(:cd, Command::CD)
+    register(:copy, Command::Copy)
   end
 
   ExtendCommand = Command
@@ -259,10 +268,12 @@ module IRB
     # Deprecated. Doesn't have any effect.
     @EXTEND_COMMANDS = []
 
-    # Drepcated. Use Command.regiser instead.
-    def self.def_extend_command(cmd_name, cmd_class, _, *aliases)
-      Command._register_with_aliases(cmd_name, cmd_class, *aliases)
-      Command.class_variable_set(:@@command_override_policies, nil)
+    class << self
+      # Drepcated. Use Command.regiser instead.
+      def def_extend_command(cmd_name, cmd_class, _, *aliases)
+        Command._register_with_aliases(cmd_name, cmd_class, *aliases)
+        Command.class_variable_set(:@@command_override_policies, nil)
+      end
     end
   end
 end

data/lib/irb/easter-egg.rb

@@ -100,31 +100,34 @@ module IRB
 
     private def easter_egg_logo(type)
       @easter_egg_logos ||= File.read(File.join(__dir__, 'ruby_logo.aa'), encoding: 'UTF-8:UTF-8')
-        .split(/TYPE: ([A-Z]+)\n/)[1..]
+        .split(/TYPE: ([A-Z_]+)\n/)[1..]
         .each_slice(2)
         .to_h
       @easter_egg_logos[type.to_s.upcase]
     end
 
     private def easter_egg(type = nil)
+      print "\e[?1049h"
       type ||= [:logo, :dancing].sample
       case type
       when :logo
-        require "rdoc"
-        RDoc::RI::Driver.new.page do |io|
-          io.write easter_egg_logo(:large)
+        Pager.page do |io|
+          logo_type = STDOUT.external_encoding == Encoding::UTF_8 ? :unicode_large : :ascii_large
+          io.write easter_egg_logo(logo_type)
+          STDIN.raw { STDIN.getc } if io == STDOUT
         end
       when :dancing
         STDOUT.cooked do
           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[?1049h"
-          0.step do |i| # TODO (0..).each needs Ruby 2.6 or later
+          print "\e[?25l" # hide cursor
+          (0..).each do |i|
             buff = canvas.draw do
               ruby_model.render_frame(i) do |p1, p2|
                 canvas.line(p1, p2)
@@ -137,10 +140,13 @@ module IRB
           end
         rescue Interrupt
         ensure
-          print "\e[0m\e[?1049l"
+          Reline::IOGate.deprep(otio)
+          print "\e[?25h" # show cursor
           trap("SIGINT", prev_trap)
         end
       end
+    ensure
+      print "\e[0m\e[?1049l"
     end
   end
 end

data/lib/irb/ext/multi-irb.rb

@@ -65,6 +65,7 @@ module IRB
       @current_job = irb
       th.run
       Thread.stop
+      Thread.pass
       @current_job = irb(Thread.current)
     end
 
@@ -220,6 +221,7 @@ module IRB
       end
     end
     Thread.stop
+    Thread.pass
     @JobManager.current_job = @JobManager.irb(Thread.current)
   end
 

data/lib/irb/history.rb

@@ -1,6 +1,36 @@
 require "pathname"
 
 module IRB
+  module History
+    DEFAULT_ENTRY_LIMIT = 1000
+
+    class << self
+      # Integer representation of <code>IRB.conf[:HISTORY_FILE]</code>.
+      def save_history
+        return 0 if IRB.conf[:SAVE_HISTORY] == false
+        return DEFAULT_ENTRY_LIMIT if IRB.conf[:SAVE_HISTORY] == true
+        IRB.conf[:SAVE_HISTORY].to_i
+      end
+
+      def save_history?
+        !save_history.zero?
+      end
+
+      def infinite?
+        save_history.negative?
+      end
+
+      # Might be nil when HOME and XDG_CONFIG_HOME are not available.
+      def history_file
+        if (history_file = IRB.conf[:HISTORY_FILE])
+          File.expand_path(history_file)
+        else
+          IRB.rc_file("_history")
+        end
+      end
+    end
+  end
+
   module HistorySavingAbility # :nodoc:
     def support_history_saving?
       true
@@ -11,76 +41,75 @@ module IRB
     end
 
     def load_history
+      history_file = History.history_file
+      return unless File.exist?(history_file.to_s)
+
       history = self.class::HISTORY
 
-      if history_file = IRB.conf[:HISTORY_FILE]
-        history_file = File.expand_path(history_file)
-      end
-      history_file = IRB.rc_file("_history") unless history_file
-      if history_file && File.exist?(history_file)
-        File.open(history_file, "r:#{IRB.conf[:LC_MESSAGES].encoding}") do |f|
-          f.each { |l|
-            l = l.chomp
-            if self.class == RelineInputMethod and history.last&.end_with?("\\")
-              history.last.delete_suffix!("\\")
-              history.last << "\n" << l
-            else
-              history << l
-            end
-          }
-        end
-        @loaded_history_lines = history.size
-        @loaded_history_mtime = File.mtime(history_file)
+      File.open(history_file, "r:#{IRB.conf[:LC_MESSAGES].encoding}") do |f|
+        f.each { |l|
+          l = l.chomp
+          if self.class == RelineInputMethod and history.last&.end_with?("\\")
+            history.last.delete_suffix!("\\")
+            history.last << "\n" << l
+          else
+            history << l
+          end
+        }
       end
+      @loaded_history_lines = history.size
+      @loaded_history_mtime = File.mtime(history_file)
     end
 
     def save_history
+      return unless History.save_history?
+      return unless (history_file = History.history_file)
+      unless ensure_history_file_writable(history_file)
+        warn <<~WARN
+          Can't write history to #{History.history_file.inspect} due to insufficient permissions.
+          Please verify the value of `IRB.conf[:HISTORY_FILE]`. Ensure the folder exists and that both the folder and file (if it exists) are writable.
+        WARN
+        return
+      end
+
       history = self.class::HISTORY.to_a
 
-      if num = IRB.conf[:SAVE_HISTORY] and (num = num.to_i) != 0
-        if history_file = IRB.conf[:HISTORY_FILE]
-          history_file = File.expand_path(history_file)
-        end
-        history_file = IRB.rc_file("_history") unless history_file
+      if File.exist?(history_file) &&
+          File.mtime(history_file) != @loaded_history_mtime
+        history = history[@loaded_history_lines..-1] if @loaded_history_lines
+        append_history = true
+      end
 
-        # When HOME and XDG_CONFIG_HOME are not available, history_file might be nil
-        return unless history_file
+      File.open(history_file, (append_history ? "a" : "w"), 0o600, encoding: IRB.conf[:LC_MESSAGES]&.encoding) do |f|
+        hist = history.map { |l| l.scrub.split("\n").join("\\\n") }
 
-        # Change the permission of a file that already exists[BUG #7694]
-        begin
-          if File.stat(history_file).mode & 066 != 0
-            File.chmod(0600, history_file)
-          end
-        rescue Errno::ENOENT
-        rescue Errno::EPERM
-          return
-        rescue
-          raise
+        unless append_history || History.infinite?
+          # Check size before slicing because array.last(huge_number) raises RangeError.
+          hist = hist.last(History.save_history) if hist.size > History.save_history
         end
 
-        if File.exist?(history_file) &&
-           File.mtime(history_file) != @loaded_history_mtime
-          history = history[@loaded_history_lines..-1] if @loaded_history_lines
-          append_history = true
-        end
+        f.puts(hist)
+      end
+    end
 
-        pathname = Pathname.new(history_file)
-        unless Dir.exist?(pathname.dirname)
-          warn "Warning: The directory to save IRB's history file does not exist. Please double check `IRB.conf[:HISTORY_FILE]`'s value."
-          return
-        end
+    private
 
-        File.open(history_file, (append_history ? 'a' : 'w'), 0o600, encoding: IRB.conf[:LC_MESSAGES]&.encoding) do |f|
-          hist = history.map{ |l| l.scrub.split("\n").join("\\\n") }
-          unless append_history
-            begin
-              hist = hist.last(num) if hist.size > num and num > 0
-            rescue RangeError # bignum too big to convert into `long'
-              # Do nothing because the bignum should be treated as infinity
-            end
-          end
-          f.puts(hist)
+    # Returns boolean whether writing to +history_file+ will be possible.
+    # Permissions of already existing +history_file+ are changed to
+    # owner-only-readable if necessary [BUG #7694].
+    def ensure_history_file_writable(history_file)
+      history_file = Pathname.new(history_file)
+
+      return false unless history_file.dirname.writable?
+      return true unless history_file.exist?
+
+      begin
+        if history_file.stat.mode & 0o66 != 0
+          history_file.chmod 0o600
         end
+        true
+      rescue Errno::EPERM # no permissions
+        false
       end
     end
   end

data/lib/irb/init.rb

@@ -80,20 +80,21 @@ module IRB # :nodoc:
     @CONF[:USE_SINGLELINE] = false unless defined?(ReadlineInputMethod)
     @CONF[:USE_COLORIZE] = (nc = ENV['NO_COLOR']).nil? || nc.empty?
     @CONF[:USE_AUTOCOMPLETE] = ENV.fetch("IRB_USE_AUTOCOMPLETE", "true") != "false"
-    @CONF[:COMPLETOR] = ENV.fetch("IRB_COMPLETOR", "regexp").to_sym
+    @CONF[:COMPLETOR] = ENV["IRB_COMPLETOR"]&.to_sym
     @CONF[:INSPECT_MODE] = true
     @CONF[:USE_TRACER] = false
     @CONF[:USE_LOADER] = false
     @CONF[:IGNORE_SIGINT] = true
     @CONF[:IGNORE_EOF] = false
     @CONF[:USE_PAGER] = true
+    @CONF[:SHOW_BANNER] = true
     @CONF[:EXTRA_DOC_DIRS] = []
     @CONF[:ECHO] = nil
     @CONF[:ECHO_ON_ASSIGNMENT] = nil
     @CONF[:VERBOSE] = nil
 
     @CONF[:EVAL_HISTORY] = nil
-    @CONF[:SAVE_HISTORY] = 1000
+    @CONF[:SAVE_HISTORY] = History::DEFAULT_ENTRY_LIMIT
 
     @CONF[:BACK_TRACE_LIMIT] = 16
 
@@ -194,6 +195,8 @@ module IRB # :nodoc:
       :'$' => :show_source,
       :'@' => :whereami,
     }
+
+    @CONF[:COPY_COMMAND] = ENV.fetch("IRB_COPY_COMMAND", nil)
   end
 
   def IRB.set_measure_callback(type = nil, arg = nil, &block)
@@ -343,6 +346,8 @@ module IRB # :nodoc:
         opt = $1 || argv.shift
         prompt_mode = opt.upcase.tr("-", "_").intern
         @CONF[:PROMPT_MODE] = prompt_mode
+      when "--nobanner"
+        @CONF[:SHOW_BANNER] = false
       when "--noprompt"
         @CONF[:PROMPT_MODE] = :NULL
       when "--script"