irb 1.6.4 → 1.8.0

data/lib/irb/source_finder.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "ruby-lex"
+
+module IRB
+  class SourceFinder
+    Source = Struct.new(
+      :file,       # @param [String] - file name
+      :first_line, # @param [String] - first line
+      :last_line,  # @param [String] - last line
+      keyword_init: true,
+    )
+    private_constant :Source
+
+    def initialize(irb_context)
+      @irb_context = irb_context
+    end
+
+    def find_source(signature)
+      context_binding = @irb_context.workspace.binding
+      case signature
+      when /\A[A-Z]\w*(::[A-Z]\w*)*\z/ # Const::Name
+        eval(signature, context_binding) # trigger autoload
+        base = context_binding.receiver.yield_self { |r| r.is_a?(Module) ? r : Object }
+        file, line = base.const_source_location(signature)
+      when /\A(?<owner>[A-Z]\w*(::[A-Z]\w*)*)#(?<method>[^ :.]+)\z/ # Class#method
+        owner = eval(Regexp.last_match[:owner], context_binding)
+        method = Regexp.last_match[:method]
+        if owner.respond_to?(:instance_method)
+          methods = owner.instance_methods + owner.private_instance_methods
+          file, line = owner.instance_method(method).source_location if methods.include?(method.to_sym)
+        end
+      when /\A((?<receiver>.+)(\.|::))?(?<method>[^ :.]+)\z/ # method, receiver.method, receiver::method
+        receiver = eval(Regexp.last_match[:receiver] || 'self', context_binding)
+        method = Regexp.last_match[:method]
+        file, line = receiver.method(method).source_location if receiver.respond_to?(method, true)
+      end
+      if file && line && File.exist?(file)
+        Source.new(file: file, first_line: line, last_line: find_end(file, line))
+      end
+    end
+
+    private
+
+    def find_end(file, first_line)
+      lex = RubyLex.new(@irb_context)
+      lines = File.read(file).lines[(first_line - 1)..-1]
+      tokens = RubyLex.ripper_lex_without_warning(lines.join)
+      prev_tokens = []
+
+      # chunk with line number
+      tokens.chunk { |tok| tok.pos[0] }.each do |lnum, chunk|
+        code = lines[0..lnum].join
+        prev_tokens.concat chunk
+        continue = lex.should_continue?(prev_tokens)
+        syntax = lex.check_code_syntax(code)
+        if !continue && syntax == :valid
+          return first_line + lnum
+        end
+      end
+      first_line
+    end
+  end
+end

data/lib/irb/statement.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module IRB
+  class Statement
+    attr_reader :code
+
+    def is_assignment?
+      raise NotImplementedError
+    end
+
+    def suppresses_echo?
+      raise NotImplementedError
+    end
+
+    def should_be_handled_by_debugger?
+      raise NotImplementedError
+    end
+
+    def evaluable_code
+      raise NotImplementedError
+    end
+
+    class Expression < Statement
+      def initialize(code, is_assignment)
+        @code = code
+        @is_assignment = is_assignment
+      end
+
+      def suppresses_echo?
+        @code.match?(/;\s*\z/)
+      end
+
+      def should_be_handled_by_debugger?
+        true
+      end
+
+      def is_assignment?
+        @is_assignment
+      end
+
+      def evaluable_code
+        @code
+      end
+    end
+
+    class Command < Statement
+      def initialize(code, command, arg, command_class)
+        @code = code
+        @command = command
+        @arg = arg
+        @command_class = command_class
+      end
+
+      def is_assignment?
+        false
+      end
+
+      def suppresses_echo?
+        false
+      end
+
+      def should_be_handled_by_debugger?
+        require_relative 'cmd/help'
+        require_relative 'cmd/debug'
+        IRB::ExtendCommand::DebugCommand > @command_class || IRB::ExtendCommand::Help == @command_class
+      end
+
+      def evaluable_code
+        # Hook command-specific transformation to return valid Ruby code
+        if @command_class.respond_to?(:transform_args)
+          arg = @command_class.transform_args(@arg)
+        else
+          arg = @arg
+        end
+
+        [@command, arg].compact.join(' ')
+      end
+    end
+  end
+end

data/lib/irb/version.rb

@@ -5,7 +5,7 @@
 #
 
 module IRB # :nodoc:
-  VERSION = "1.6.4"
+  VERSION = "1.8.0"
   @RELEASE_VERSION = VERSION
-  @LAST_UPDATE_DATE = "2023-04-07"
+  @LAST_UPDATE_DATE = "2023-08-30"
 end

data/lib/irb/workspace.rb

@@ -108,6 +108,10 @@ EOF
     # <code>IRB.conf[:__MAIN__]</code>
     attr_reader :main
 
+    def load_commands_to_main
+      main.extend ExtendCommandBundle
+    end
+
     # Evaluate the given +statements+ within the  context of this workspace.
     def evaluate(statements, file = __FILE__, line = __LINE__)
       eval(statements, @binding, file, line)

data/lib/irb.rb

@@ -12,12 +12,14 @@ require_relative "irb/context"
 require_relative "irb/extend-command"
 
 require_relative "irb/ruby-lex"
+require_relative "irb/statement"
 require_relative "irb/input-method"
 require_relative "irb/locale"
 require_relative "irb/color"
 
 require_relative "irb/version"
 require_relative "irb/easter-egg"
+require_relative "irb/debug"
 
 # IRB stands for "interactive Ruby" and is a tool to interactively execute Ruby
 # expressions read from the standard input.
@@ -154,7 +156,7 @@ require_relative "irb/easter-egg"
 #
 #     IRB.conf[:EVAL_HISTORY] = <number>
 #
-# See IRB::Context#eval_history= and History class. The history of command
+# See IRB::Context#eval_history= and EvalHistory class. The history of command
 # results is not permanently saved in any file.
 #
 # == Customizing the IRB Prompt
@@ -194,10 +196,9 @@ require_relative "irb/easter-egg"
 # For instance, the default prompt mode is defined as follows:
 #
 #     IRB.conf[:PROMPT_MODE][:DEFAULT] = {
-#       :PROMPT_I => "%N(%m):%03n:%i> ",
-#       :PROMPT_N => "%N(%m):%03n:%i> ",
-#       :PROMPT_S => "%N(%m):%03n:%i%l ",
-#       :PROMPT_C => "%N(%m):%03n:%i* ",
+#       :PROMPT_I => "%N(%m):%03n> ",
+#       :PROMPT_S => "%N(%m):%03n%l ",
+#       :PROMPT_C => "%N(%m):%03n* ",
 #       :RETURN => "%s\n" # used to printf
 #     }
 #
@@ -205,35 +206,30 @@ require_relative "irb/easter-egg"
 #
 #   # :NULL:
 #   #   :PROMPT_I:
-#   #   :PROMPT_N:
 #   #   :PROMPT_S:
 #   #   :PROMPT_C:
 #   #   :RETURN: |
 #   #     %s
 #   # :DEFAULT:
-#   #   :PROMPT_I: ! '%N(%m):%03n:%i> '
-#   #   :PROMPT_N: ! '%N(%m):%03n:%i> '
-#   #   :PROMPT_S: ! '%N(%m):%03n:%i%l '
-#   #   :PROMPT_C: ! '%N(%m):%03n:%i* '
+#   #   :PROMPT_I: ! '%N(%m):%03n> '
+#   #   :PROMPT_S: ! '%N(%m):%03n%l '
+#   #   :PROMPT_C: ! '%N(%m):%03n* '
 #   #   :RETURN: |
 #   #     => %s
 #   # :CLASSIC:
 #   #   :PROMPT_I: ! '%N(%m):%03n:%i> '
-#   #   :PROMPT_N: ! '%N(%m):%03n:%i> '
 #   #   :PROMPT_S: ! '%N(%m):%03n:%i%l '
 #   #   :PROMPT_C: ! '%N(%m):%03n:%i* '
 #   #   :RETURN: |
 #   #     %s
 #   # :SIMPLE:
 #   #   :PROMPT_I: ! '>> '
-#   #   :PROMPT_N: ! '>> '
 #   #   :PROMPT_S:
 #   #   :PROMPT_C: ! '?> '
 #   #   :RETURN: |
 #   #     => %s
 #   # :INF_RUBY:
-#   #   :PROMPT_I: ! '%N(%m):%03n:%i> '
-#   #   :PROMPT_N:
+#   #   :PROMPT_I: ! '%N(%m):%03n> '
 #   #   :PROMPT_S:
 #   #   :PROMPT_C:
 #   #   :RETURN: |
@@ -241,7 +237,6 @@ require_relative "irb/easter-egg"
 #   #   :AUTO_INDENT: true
 #   # :XMP:
 #   #   :PROMPT_I:
-#   #   :PROMPT_N:
 #   #   :PROMPT_S:
 #   #   :PROMPT_C:
 #   #   :RETURN: |2
@@ -373,8 +368,6 @@ module IRB
   class Abort < Exception;end
 
   @CONF = {}
-
-
   # Displays current configuration.
   #
   # Modifying the configuration is achieved by sending a message to IRB.conf.
@@ -429,30 +422,6 @@ module IRB
   end
 
   class Irb
-    ASSIGNMENT_NODE_TYPES = [
-      # Local, instance, global, class, constant, instance, and index assignment:
-      #   "foo = bar",
-      #   "@foo = bar",
-      #   "$foo = bar",
-      #   "@@foo = bar",
-      #   "::Foo = bar",
-      #   "a::Foo = bar",
-      #   "Foo = bar"
-      #   "foo.bar = 1"
-      #   "foo[1] = bar"
-      :assign,
-
-      # Operation assignment:
-      #   "foo += bar"
-      #   "foo -= bar"
-      #   "foo ||= bar"
-      #   "foo &&= bar"
-      :opassign,
-
-      # Multiple assignment:
-      #   "foo, bar = 1, 2
-      :massign,
-    ]
     # Note: instance and index assignment expressions could also be written like:
     # "foo.bar=(1)" and "foo.[]=(1, bar)", when expressed that way, the former
     # be parsed as :assign and echo will be suppressed, but the latter is
@@ -465,14 +434,14 @@ module IRB
     # Creates a new irb session
     def initialize(workspace = nil, input_method = nil)
       @context = Context.new(self, workspace, input_method)
-      @context.main.extend ExtendCommandBundle
+      @context.workspace.load_commands_to_main
       @signal_status = :IN_IRB
       @scanner = RubyLex.new(@context)
     end
 
-    # A hook point for `debug` command's TracePoint after :IRB_EXIT as well as its clean-up
+    # A hook point for `debug` command's breakpoint after :IRB_EXIT as well as its clean-up
     def debug_break
-      # it means the debug command is executed
+      # it means the debug integration has been activated
       if defined?(DEBUGGER__) && DEBUGGER__.respond_to?(:capture_frames_without_irb)
         # after leaving this initial breakpoint, revert the capture_frames patch
         DEBUGGER__.singleton_class.send(:alias_method, :capture_frames, :capture_frames_without_irb)
@@ -481,10 +450,49 @@ module IRB
       end
     end
 
+    def debug_readline(binding)
+      workspace = IRB::WorkSpace.new(binding)
+      context.workspace = workspace
+      context.workspace.load_commands_to_main
+      scanner.increase_line_no(1)
+
+      # When users run:
+      # 1. Debugging commands, like `step 2`
+      # 2. Any input that's not irb-command, like `foo = 123`
+      #
+      # Irb#eval_input will simply return the input, and we need to pass it to the debugger.
+      input = if IRB.conf[:SAVE_HISTORY] && context.io.support_history_saving?
+        # Previous IRB session's history has been saved when `Irb#run` is exited
+        # We need to make sure the saved history is not saved again by reseting the counter
+        context.io.reset_history_counter
+
+        begin
+          eval_input
+        ensure
+          context.io.save_history
+        end
+      else
+        eval_input
+      end
+
+      if input&.include?("\n")
+        scanner.increase_line_no(input.count("\n") - 1)
+      end
+
+      input
+    end
+
     def run(conf = IRB.conf)
+      in_nested_session = !!conf[:MAIN_CONTEXT]
       conf[:IRB_RC].call(context) if conf[:IRB_RC]
       conf[:MAIN_CONTEXT] = context
 
+      save_history = !in_nested_session && conf[:SAVE_HISTORY] && context.io.support_history_saving?
+
+      if save_history
+        context.io.load_history
+      end
+
       prev_trap = trap("SIGINT") do
         signal_handle
       end
@@ -496,6 +504,7 @@ module IRB
       ensure
         trap("SIGINT", prev_trap)
         conf[:AT_EXIT].each{|hook| hook.call}
+        context.io.save_history if save_history
       end
     end
 
@@ -506,16 +515,12 @@ module IRB
 
     # Evaluates input for this session.
     def eval_input
-      exc = nil
-
       @scanner.set_prompt do
         |ltype, indent, continue, line_no|
         if ltype
           f = @context.prompt_s
         elsif continue
           f = @context.prompt_c
-        elsif indent > 0
-          f = @context.prompt_n
         else
           f = @context.prompt_i
         end
@@ -530,58 +535,26 @@ module IRB
             prompt_i = @context.prompt_i.nil? ? "" : @context.prompt_i
             ind = prompt(prompt_i, ltype, indent, line_no)[/.*\z/].size +
               indent * 2 - p.size
-            ind += 2 if continue
             @context.io.prompt = p + " " * ind if ind > 0
           end
         end
         @context.io.prompt
       end
 
-      @scanner.set_input(@context.io) do
-        signal_status(:IN_INPUT) do
-          if l = @context.io.gets
-            print l if @context.verbose?
-          else
-            if @context.ignore_eof? and @context.io.readable_after_eof?
-              l = "\n"
-              if @context.verbose?
-                printf "Use \"exit\" to leave %s\n", @context.ap_name
-              end
-            else
-              print "\n" if @context.prompting?
-            end
-          end
-          l
-        end
-      end
+      configure_io
 
-      @scanner.set_auto_indent
-
-      @scanner.each_top_level_statement do |line, line_no|
+      each_top_level_statement do |statement, line_no|
         signal_status(:IN_EVAL) do
           begin
-            if IRB.conf[:MEASURE] && IRB.conf[:MEASURE_CALLBACKS].empty?
-              IRB.set_measure_callback
-            end
-            # Assignment expression check should be done before @context.evaluate to handle code like `a /2#/ if false; a = 1`
-            is_assignment = assignment_expression?(line)
-            if IRB.conf[:MEASURE] && !IRB.conf[:MEASURE_CALLBACKS].empty?
-              result = nil
-              last_proc = proc{ result = @context.evaluate(line, line_no, exception: exc) }
-              IRB.conf[:MEASURE_CALLBACKS].inject(last_proc) { |chain, item|
-                _name, callback, arg = item
-                proc {
-                  callback.(@context, line, line_no, arg, exception: exc) do
-                    chain.call
-                  end
-                }
-              }.call
-              @context.set_last_value(result)
-            else
-              @context.evaluate(line, line_no, exception: exc)
+            # If the integration with debugger is activated, we return certain input if it should be dealt with by debugger
+            if @context.with_debugger && statement.should_be_handled_by_debugger?
+              return statement.code
             end
-            if @context.echo?
-              if is_assignment
+
+            @context.evaluate(statement.evaluable_code, line_no)
+
+            if @context.echo? && !statement.suppresses_echo?
+              if statement.is_assignment?
                 if @context.echo_on_assignment?
                   output_value(@context.echo_on_assignment? == :truncate)
                 end
@@ -589,17 +562,144 @@ module IRB
                 output_value
               end
             end
-          rescue Interrupt => exc
           rescue SystemExit, SignalException
             raise
-          rescue Exception => exc
+          rescue Interrupt, Exception => exc
+            handle_exception(exc)
+            @context.workspace.local_variable_set(:_, exc)
+          end
+        end
+      end
+    end
+
+    def read_input
+      signal_status(:IN_INPUT) do
+        if l = @context.io.gets
+          print l if @context.verbose?
+        else
+          if @context.ignore_eof? and @context.io.readable_after_eof?
+            l = "\n"
+            if @context.verbose?
+              printf "Use \"exit\" to leave %s\n", @context.ap_name
+            end
+          else
+            print "\n" if @context.prompting?
+          end
+        end
+        l
+      end
+    end
+
+    def readmultiline
+      @scanner.save_prompt_to_context_io([], false, 0)
+
+      # multiline
+      return read_input if @context.io.respond_to?(:check_termination)
+
+      # nomultiline
+      code = ''
+      line_offset = 0
+      loop do
+        line = read_input
+        unless line
+          return code.empty? ? nil : code
+        end
+
+        code << line
+
+        # Accept any single-line input for symbol aliases or commands that transform args
+        return code if single_line_command?(code)
+
+        tokens, opens, terminated = @scanner.check_code_state(code)
+        return code if terminated
+
+        line_offset += 1
+        continue = @scanner.should_continue?(tokens)
+        @scanner.save_prompt_to_context_io(opens, continue, line_offset)
+      end
+    end
+
+    def each_top_level_statement
+      loop do
+        code = readmultiline
+        break unless code
+
+        if code != "\n"
+          yield build_statement(code), @scanner.line_no
+        end
+        @scanner.increase_line_no(code.count("\n"))
+      rescue RubyLex::TerminateLineInput
+      end
+    end
+
+    def build_statement(code)
+      code.force_encoding(@context.io.encoding)
+      command_or_alias, arg = code.split(/\s/, 2)
+      # Transform a non-identifier alias (@, $) or keywords (next, break)
+      command_name = @context.command_aliases[command_or_alias.to_sym]
+      command = command_name || command_or_alias
+      command_class = ExtendCommandBundle.load_command(command)
+
+      if command_class
+        Statement::Command.new(code, command, arg, command_class)
+      else
+        Statement::Expression.new(code, @scanner.assignment_expression?(code))
+      end
+    end
+
+    def single_line_command?(code)
+      command = code.split(/\s/, 2).first
+      @context.symbol_alias?(command) || @context.transform_args?(command)
+    end
+
+    def configure_io
+      if @context.io.respond_to?(:check_termination)
+        @context.io.check_termination do |code|
+          if Reline::IOGate.in_pasting?
+            rest = @scanner.check_termination_in_prev_line(code)
+            if rest
+              Reline.delete_text
+              rest.bytes.reverse_each do |c|
+                Reline.ungetc(c)
+              end
+              true
+            else
+              false
+            end
           else
-            exc = nil
-            next
+            # Accept any single-line input for symbol aliases or commands that transform args
+            next true if single_line_command?(code)
+
+            _tokens, _opens, terminated = @scanner.check_code_state(code)
+            terminated
+          end
+        end
+      end
+      if @context.io.respond_to?(:dynamic_prompt)
+        @context.io.dynamic_prompt do |lines|
+          lines << '' if lines.empty?
+          tokens = RubyLex.ripper_lex_without_warning(lines.map{ |l| l + "\n" }.join, context: @context)
+          line_results = IRB::NestingParser.parse_by_line(tokens)
+          tokens_until_line = []
+          line_results.map.with_index do |(line_tokens, _prev_opens, next_opens, _min_depth), line_num_offset|
+            line_tokens.each do |token, _s|
+              # Avoid appending duplicated token. Tokens that include "\n" like multiline tstring_content can exist in multiple lines.
+              tokens_until_line << token if token != tokens_until_line.last
+            end
+            continue = @scanner.should_continue?(tokens_until_line)
+            @scanner.prompt(next_opens, continue, line_num_offset)
           end
-          handle_exception(exc)
-          @context.workspace.local_variable_set(:_, exc)
-          exc = nil
+        end
+      end
+
+      if @context.io.respond_to?(:auto_indent) and @context.auto_indent_mode
+        @context.io.auto_indent do |lines, line_index, byte_pointer, is_newline|
+          next nil if lines == [nil] # Workaround for exit IRB with CTRL+d
+          next nil if !is_newline && lines[line_index]&.byteslice(0, byte_pointer)&.match?(/\A\s*\z/)
+
+          code = lines[0..line_index].map { |l| "#{l}\n" }.join
+          tokens = RubyLex.ripper_lex_without_warning(code, context: @context)
+          @scanner.process_indent_level(tokens, lines, line_index, is_newline)
         end
       end
     end
@@ -873,24 +973,6 @@ module IRB
       end
       format("#<%s: %s>", self.class, ary.join(", "))
     end
-
-    def assignment_expression?(line)
-      # Try to parse the line and check if the last of possibly multiple
-      # expressions is an assignment type.
-
-      # If the expression is invalid, Ripper.sexp should return nil which will
-      # result in false being returned. Any valid expression should return an
-      # s-expression where the second element of the top level array is an
-      # array of parsed expressions. The first element of each expression is the
-      # expression's type.
-      verbose, $VERBOSE = $VERBOSE, nil
-      code = "#{RubyLex.generate_local_variables_assign_code(@context.local_variables) || 'nil;'}\n#{line}"
-      # Get the last node_type of the line. drop(1) is to ignore the local_variables_assign_code part.
-      node_type = Ripper.sexp(code)&.dig(1)&.drop(1)&.dig(-1, 0)
-      ASSIGNMENT_NODE_TYPES.include?(node_type)
-    ensure
-      $VERBOSE = verbose
-    end
   end
 
   def @CONF.inspect
@@ -973,14 +1055,34 @@ class Binding
   #     Cooked potato: true
   #
   #
-  # See IRB@IRB+Usage for more information.
+  # See IRB@Usage for more information.
   def irb(show_code: true)
+    # Setup IRB with the current file's path and no command line arguments
     IRB.setup(source_location[0], argv: [])
+    # Create a new workspace using the current binding
     workspace = IRB::WorkSpace.new(self)
+    # Print the code around the binding if show_code is true
     STDOUT.print(workspace.code_around_binding) if show_code
-    binding_irb = IRB::Irb.new(workspace)
-    binding_irb.context.irb_path = File.expand_path(source_location[0])
-    binding_irb.run(IRB.conf)
-    binding_irb.debug_break
+    # Get the original IRB instance
+    debugger_irb = IRB.instance_variable_get(:@debugger_irb)
+
+    irb_path = File.expand_path(source_location[0])
+
+    if debugger_irb
+      # If we're already in a debugger session, set the workspace and irb_path for the original IRB instance
+      debugger_irb.context.workspace = workspace
+      debugger_irb.context.irb_path = irb_path
+      # If we've started a debugger session and hit another binding.irb, we don't want to start an IRB session
+      # instead, we want to resume the irb:rdbg session.
+      IRB::Debug.setup(debugger_irb)
+      IRB::Debug.insert_debug_break
+      debugger_irb.debug_break
+    else
+      # If we're not in a debugger session, create a new IRB instance with the current workspace
+      binding_irb = IRB::Irb.new(workspace)
+      binding_irb.context.irb_path = irb_path
+      binding_irb.run(IRB.conf)
+      binding_irb.debug_break
+    end
   end
 end