irb 1.8.0 → 1.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 485bdcb4daa6d3f0e0a70fc6ff6e93289d9d8b46c4a32094ab85fd7ad1ad6994
-  data.tar.gz: d57ae530ec9c2db847b0f15ab10f01f23e4ae62cd9542770ddbbee83fe446195
+  metadata.gz: 811c1b4343957dac57d58178adbc13195e6d53de980f63810ec83eec09d1f8c1
+  data.tar.gz: bbc99d3f46a8e7afa6a7a8e32dc137300e3da15935631e05a56b203a901887fb
 SHA512:
-  metadata.gz: e8d8f8a7444b8c6bb13d7ba2e4baf38df9ee4126be78188ddb15d5c97160908e43789b54df09d534badb8eb3a69a4f771687f46038033361fdccf0e1ffe3fa66
-  data.tar.gz: 2658667bb3f923447d311f9c866b3fbcefd0f7451e8cdc61c9593b5c9e05d443558e87e7da7e706fdb998cc86fe601e1ec87d4ed21e32ea05552e66906dabca3
+  metadata.gz: 76b770cf0a8012031f11306cc96879173d819cbd0501efdd41c434571028c3dee8bc12b5928696232d61215f6e22ecec3b9a6e3ff93e085349282c035c9389ec
+  data.tar.gz: f48e1f3912d5bb59acfa041718014dafb24d7f39ac23e1f0b267047ca4e4f937af77bdb0d40a940813da71f5920f53b5bbdc987b9dc50d16e5bdb85a754e02b7

data/README.md

@@ -150,7 +150,7 @@ Context
 
 Starting from version 1.8.0, IRB boasts a powerful integration with `debug.gem`, providing a debugging experience akin to `pry-byebug`.
 
-After hitting a `binding.irb` breakpoint, you can activate the debugger with the `debug` command.
+After hitting a `binding.irb` breakpoint, you can activate the debugger with the `debug` command. Alternatively, if the `debug` method happens to already be defined in the current scope, you can call `irb_debug`.
 
 ```shell
 From: test.rb @ line 3 :

data/irb.gemspec

@@ -41,6 +41,6 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = Gem::Requirement.new(">= 2.7")
 
-  spec.add_dependency "reline", ">= 0.3.6"
-  spec.add_dependency "rdoc", "~> 6.5"
+  spec.add_dependency "reline", ">= 0.3.8"
+  spec.add_dependency "rdoc"
 end

data/lib/irb/cmd/show_source.rb

@@ -2,6 +2,7 @@
 
 require_relative "nop"
 require_relative "../source_finder"
+require_relative "../pager"
 require_relative "../color"
 
 module IRB
@@ -40,12 +41,16 @@ module IRB
       private
 
       def show_source(source)
-        puts
-        puts "#{bold("From")}: #{source.file}:#{source.first_line}"
-        puts
-        code = IRB::Color.colorize_code(File.read(source.file))
-        puts code.lines[(source.first_line - 1)...source.last_line].join
-        puts
+        file_content = IRB::Color.colorize_code(File.read(source.file))
+        code = file_content.lines[(source.first_line - 1)...source.last_line].join
+        content = <<~CONTENT
+
+          #{bold("From")}: #{source.file}:#{source.first_line}
+
+          #{code}
+        CONTENT
+
+        Pager.page_content(content)
       end
 
       def bold(str)

data/lib/irb/completion.rb

@@ -8,55 +8,14 @@
 require_relative 'ruby-lex'
 
 module IRB
-  module InputCompletor # :nodoc:
-    using Module.new {
-      refine ::Binding do
-        def eval_methods
-          ::Kernel.instance_method(:methods).bind(eval("self")).call
-        end
-
-        def eval_private_methods
-          ::Kernel.instance_method(:private_methods).bind(eval("self")).call
-        end
-
-        def eval_instance_variables
-          ::Kernel.instance_method(:instance_variables).bind(eval("self")).call
-        end
-
-        def eval_global_variables
-          ::Kernel.instance_method(:global_variables).bind(eval("self")).call
-        end
-
-        def eval_class_constants
-          ::Module.instance_method(:constants).bind(eval("self.class")).call
-        end
-      end
-    }
-
-    # 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
-    ]
+  class BaseCompletor # :nodoc:
+    def completion_candidates(preposing, target, postposing, bind:)
+      raise NotImplementedError
+    end
 
-    BASIC_WORD_BREAK_CHARACTERS = " \t\n`><=;|&{("
+    def doc_namespace(preposing, matched, postposing, bind:)
+      raise NotImplementedError
+    end
 
     GEM_PATHS =
       if defined?(Gem::Specification)
@@ -73,7 +32,7 @@ module IRB
         []
       end.freeze
 
-    def self.retrieve_gem_and_system_load_path
+    def retrieve_gem_and_system_load_path
       candidates = (GEM_PATHS | $LOAD_PATH)
       candidates.map do |p|
         if p.respond_to?(:to_path)
@@ -84,8 +43,8 @@ module IRB
       end.compact.sort
     end
 
-    def self.retrieve_files_to_require_from_load_path
-      @@files_from_load_path ||=
+    def retrieve_files_to_require_from_load_path
+      @files_from_load_path ||=
         (
           shortest = []
           rest = retrieve_gem_and_system_load_path.each_with_object([]) { |path, result|
@@ -103,13 +62,62 @@ module IRB
         )
     end
 
-    def self.retrieve_files_to_require_relative_from_current_dir
-      @@files_from_current_dir ||= Dir.glob("**/*.{rb,#{RbConfig::CONFIG['DLEXT']}}", base: '.').map { |path|
+    def retrieve_files_to_require_relative_from_current_dir
+      @files_from_current_dir ||= Dir.glob("**/*.{rb,#{RbConfig::CONFIG['DLEXT']}}", base: '.').map { |path|
         path.sub(/\.(rb|#{RbConfig::CONFIG['DLEXT']})\z/, '')
       }
     end
+  end
+
+  class RegexpCompletor < BaseCompletor # :nodoc:
+    using Module.new {
+      refine ::Binding do
+        def eval_methods
+          ::Kernel.instance_method(:methods).bind(eval("self")).call
+        end
+
+        def eval_private_methods
+          ::Kernel.instance_method(:private_methods).bind(eval("self")).call
+        end
+
+        def eval_instance_variables
+          ::Kernel.instance_method(:instance_variables).bind(eval("self")).call
+        end
+
+        def eval_global_variables
+          ::Kernel.instance_method(:global_variables).bind(eval("self")).call
+        end
+
+        def eval_class_constants
+          ::Module.instance_method(:constants).bind(eval("self.class")).call
+        end
+      end
+    }
 
-    CompletionRequireProc = lambda { |target, preposing = nil, postposing = nil|
+    # 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
+    ]
+
+    def complete_require_path(target, preposing, postposing)
       if target =~ /\A(['"])([^'"]+)\Z/
         quote = $1
         actual_target = $2
@@ -124,39 +132,37 @@ module IRB
           break
         end
       end
-      result = []
-      if tok && tok.event == :on_ident && tok.state == Ripper::EXPR_CMDARG
-        case tok.tok
-        when 'require'
-          result = retrieve_files_to_require_from_load_path.select { |path|
-            path.start_with?(actual_target)
-          }.map { |path|
-            quote + path
-          }
-        when 'require_relative'
-          result = retrieve_files_to_require_relative_from_current_dir.select { |path|
-            path.start_with?(actual_target)
-          }.map { |path|
-            quote + path
-          }
-        end
+      return unless tok&.event == :on_ident && tok.state == Ripper::EXPR_CMDARG
+
+      case tok.tok
+      when 'require'
+        retrieve_files_to_require_from_load_path.select { |path|
+          path.start_with?(actual_target)
+        }.map { |path|
+          quote + path
+        }
+      when 'require_relative'
+        retrieve_files_to_require_relative_from_current_dir.select { |path|
+          path.start_with?(actual_target)
+        }.map { |path|
+          quote + path
+        }
       end
-      result
-    }
+    end
 
-    CompletionProc = lambda { |target, preposing = nil, postposing = nil|
+    def completion_candidates(preposing, target, postposing, bind:)
       if preposing && postposing
-        result = CompletionRequireProc.(target, preposing, postposing)
-        unless result
-          result = retrieve_completion_data(target).compact.map{ |i| i.encode(Encoding.default_external) }
-        end
-        result
-      else
-        retrieve_completion_data(target).compact.map{ |i| i.encode(Encoding.default_external) }
+        result = complete_require_path(target, preposing, postposing)
+        return result if result
       end
-    }
+      retrieve_completion_data(target, bind: bind, doc_namespace: false).compact.map{ |i| i.encode(Encoding.default_external) }
+    end
+
+    def doc_namespace(_preposing, matched, _postposing, bind:)
+      retrieve_completion_data(matched, bind: bind, doc_namespace: true)
+    end
 
-    def self.retrieve_completion_data(input, bind: IRB.conf[:MAIN_CONTEXT].workspace.binding, doc_namespace: false)
+    def retrieve_completion_data(input, bind:, doc_namespace:)
       case input
       # this regexp only matches the closing character because of irb's Reline.completer_quote_characters setting
       # details are described in: https://github.com/ruby/irb/pull/523
@@ -394,44 +400,10 @@ module IRB
       end
     end
 
-    PerfectMatchedProc = ->(matched, bind: IRB.conf[:MAIN_CONTEXT].workspace.binding) {
-      begin
-        require 'rdoc'
-      rescue LoadError
-        return
-      end
-
-      RDocRIDriver ||= RDoc::RI::Driver.new
-
-      if matched =~ /\A(?:::)?RubyVM/ and not ENV['RUBY_YES_I_AM_NOT_A_NORMAL_USER']
-        IRB.__send__(:easter_egg)
-        return
-      end
-
-      namespace = retrieve_completion_data(matched, bind: bind, doc_namespace: true)
-      return unless namespace
-
-      if namespace.is_a?(Array)
-        out = RDoc::Markup::Document.new
-        namespace.each do |m|
-          begin
-            RDocRIDriver.add_method(out, m)
-          rescue RDoc::RI::Driver::NotFoundError
-          end
-        end
-        RDocRIDriver.display(out)
-      else
-        begin
-          RDocRIDriver.display_names([namespace])
-        rescue RDoc::RI::Driver::NotFoundError
-        end
-      end
-    }
-
     # Set of available operators in Ruby
     Operators = %w[% & * ** + - / < << <= <=> == === =~ > >= >> [] []= ^ ! != !~]
 
-    def self.select_message(receiver, message, candidates, sep = ".")
+    def select_message(receiver, message, candidates, sep = ".")
       candidates.grep(/^#{Regexp.quote(message)}/).collect do |e|
         case e
         when /^[a-zA-Z_]/

data/lib/irb/debug/ui.rb

@@ -4,8 +4,7 @@ require 'debug/console'
 module IRB
   module Debug
     class UI < DEBUGGER__::UI_Base
-      def initialize(thread, irb)
-        @thread = thread
+      def initialize(irb)
         @irb = irb
       end
 
@@ -56,7 +55,7 @@ module IRB
 
       def readline _
         setup_interrupt do
-          tc = DEBUGGER__::SESSION.get_thread_client(@thread)
+          tc = DEBUGGER__::SESSION.instance_variable_get(:@tc)
           cmd = @irb.debug_readline(tc.current_frame.binding || TOPLEVEL_BINDING)
 
           case cmd

data/lib/irb/debug.rb

@@ -32,17 +32,14 @@ module IRB
           end
           DEBUGGER__::CONFIG.set_config
           configure_irb_for_debugger(irb)
-          thread = Thread.current
 
-          DEBUGGER__.initialize_session{ IRB::Debug::UI.new(thread, irb) }
+          DEBUGGER__.initialize_session{ IRB::Debug::UI.new(irb) }
         end
 
         # When debug session was previously started but not by IRB
         if defined?(DEBUGGER__::SESSION) && !irb.context.with_debugger
           configure_irb_for_debugger(irb)
-          thread = Thread.current
-
-          DEBUGGER__::SESSION.reset_ui(IRB::Debug::UI.new(thread, irb))
+          DEBUGGER__::SESSION.reset_ui(IRB::Debug::UI.new(irb))
         end
 
         # Apply patches to debug gem so it skips IRB frames

data/lib/irb/history.rb

@@ -10,6 +10,7 @@ module IRB
 
     def load_history
       history = self.class::HISTORY
+
       if history_file = IRB.conf[:HISTORY_FILE]
         history_file = File.expand_path(history_file)
       end
@@ -32,7 +33,8 @@ module IRB
     end
 
     def save_history
-      history = self.class::HISTORY
+      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)

data/lib/irb/input-method.rb

@@ -11,6 +11,8 @@ require 'reline'
 
 module IRB
   class InputMethod
+    BASIC_WORD_BREAK_CHARACTERS = " \t\n`><=;|&{("
+
     # The irb prompt associated with this input method
     attr_accessor :prompt
 
@@ -179,12 +181,16 @@ module IRB
       super
 
       @eof = false
+      @completor = RegexpCompletor.new
 
       if Readline.respond_to?("basic_word_break_characters=")
-        Readline.basic_word_break_characters = IRB::InputCompletor::BASIC_WORD_BREAK_CHARACTERS
+        Readline.basic_word_break_characters = BASIC_WORD_BREAK_CHARACTERS
       end
       Readline.completion_append_character = nil
-      Readline.completion_proc = IRB::InputCompletor::CompletionProc
+      Readline.completion_proc = ->(target) {
+        bind = IRB.conf[:MAIN_CONTEXT].workspace.binding
+        @completor.completion_candidates('', target, '', bind: bind)
+      }
     end
 
     # Reads the next line from this input method.
@@ -230,11 +236,16 @@ module IRB
       super
 
       @eof = false
+      @completor = RegexpCompletor.new
 
-      Reline.basic_word_break_characters = IRB::InputCompletor::BASIC_WORD_BREAK_CHARACTERS
+      Reline.basic_word_break_characters = BASIC_WORD_BREAK_CHARACTERS
       Reline.completion_append_character = nil
       Reline.completer_quote_characters = ''
-      Reline.completion_proc = IRB::InputCompletor::CompletionProc
+      Reline.completion_proc = ->(target, preposing, postposing) {
+        bind = IRB.conf[:MAIN_CONTEXT].workspace.binding
+        @completion_params = [preposing, target, postposing, bind]
+        @completor.completion_candidates(preposing, target, postposing, bind: bind)
+      }
       Reline.output_modifier_proc =
         if IRB.conf[:USE_COLORIZE]
           proc do |output, complete: |
@@ -247,13 +258,13 @@ module IRB
             Reline::Unicode.escape_for_print(output)
           end
         end
-      Reline.dig_perfect_match_proc = IRB::InputCompletor::PerfectMatchedProc
+      Reline.dig_perfect_match_proc = ->(matched) { display_document(matched) }
       Reline.autocompletion = IRB.conf[:USE_AUTOCOMPLETE]
 
       if IRB.conf[:USE_AUTOCOMPLETE]
         begin
           require 'rdoc'
-          Reline.add_dialog_proc(:show_doc, SHOW_DOC_DIALOG, Reline::DEFAULT_DIALOG_CONTEXT)
+          Reline.add_dialog_proc(:show_doc, show_doc_dialog_proc, Reline::DEFAULT_DIALOG_CONTEXT)
         rescue LoadError
         end
       end
@@ -271,100 +282,140 @@ module IRB
       @auto_indent_proc = block
     end
 
-    SHOW_DOC_DIALOG = ->() {
-      dialog.trap_key = nil
-      alt_d = [
-        [Reline::Key.new(nil, 0xE4, true)], # Normal Alt+d.
-        [27, 100], # Normal Alt+d when convert-meta isn't used.
-        [195, 164], # The "ä" that appears when Alt+d is pressed on xterm.
-        [226, 136, 130] # The "∂" that appears when Alt+d in pressed on iTerm2.
-      ]
+    def show_doc_dialog_proc
+      doc_namespace = ->(matched) {
+        preposing, _target, postposing, bind = @completion_params
+        @completor.doc_namespace(preposing, matched, postposing, bind: bind)
+      }
+      ->() {
+        dialog.trap_key = nil
+        alt_d = [
+          [Reline::Key.new(nil, 0xE4, true)], # Normal Alt+d.
+          [27, 100], # Normal Alt+d when convert-meta isn't used.
+          [195, 164], # The "ä" that appears when Alt+d is pressed on xterm.
+          [226, 136, 130] # The "∂" that appears when Alt+d in pressed on iTerm2.
+        ]
+
+        if just_cursor_moving and completion_journey_data.nil?
+          return nil
+        end
+        cursor_pos_to_render, result, pointer, autocomplete_dialog = context.pop(4)
+        return nil if result.nil? or pointer.nil? or pointer < 0
 
-      if just_cursor_moving and completion_journey_data.nil?
-        return nil
-      end
-      cursor_pos_to_render, result, pointer, autocomplete_dialog = context.pop(4)
-      return nil if result.nil? or pointer.nil? or pointer < 0
-      name = result[pointer]
-      name = IRB::InputCompletor.retrieve_completion_data(name, doc_namespace: true)
+        name = doc_namespace.call(result[pointer])
 
-      options = {}
-      options[:extra_doc_dirs] = IRB.conf[:EXTRA_DOC_DIRS] unless IRB.conf[:EXTRA_DOC_DIRS].empty?
-      driver = RDoc::RI::Driver.new(options)
+        options = {}
+        options[:extra_doc_dirs] = IRB.conf[:EXTRA_DOC_DIRS] unless IRB.conf[:EXTRA_DOC_DIRS].empty?
+        driver = RDoc::RI::Driver.new(options)
 
-      if key.match?(dialog.name)
-        begin
-          driver.display_names([name])
-        rescue RDoc::RI::Driver::NotFoundError
+        if key.match?(dialog.name)
+          begin
+            driver.display_names([name])
+          rescue RDoc::RI::Driver::NotFoundError
+          end
         end
-      end
 
-      begin
-        name = driver.expand_name(name)
-      rescue RDoc::RI::Driver::NotFoundError
-        return nil
-      rescue
-        return nil # unknown error
-      end
-      doc = nil
-      used_for_class = false
-      if not name =~ /#|\./
-        found, klasses, includes, extends = driver.classes_and_includes_and_extends_for(name)
-        if not found.empty?
-          doc = driver.class_document(name, found, klasses, includes, extends)
-          used_for_class = true
-        end
-      end
-      unless used_for_class
-        doc = RDoc::Markup::Document.new
         begin
-          driver.add_method(doc, name)
+          name = driver.expand_name(name)
         rescue RDoc::RI::Driver::NotFoundError
-          doc = nil
+          return nil
         rescue
           return nil # unknown error
         end
-      end
-      return nil if doc.nil?
-      width = 40
-
-      right_x = cursor_pos_to_render.x + autocomplete_dialog.width
-      if right_x + width > screen_width
-        right_width = screen_width - (right_x + 1)
-        left_x = autocomplete_dialog.column - width
-        left_x = 0 if left_x < 0
-        left_width = width > autocomplete_dialog.column ? autocomplete_dialog.column : width
-        if right_width.positive? and left_width.positive?
-          if right_width >= left_width
+        doc = nil
+        used_for_class = false
+        if not name =~ /#|\./
+          found, klasses, includes, extends = driver.classes_and_includes_and_extends_for(name)
+          if not found.empty?
+            doc = driver.class_document(name, found, klasses, includes, extends)
+            used_for_class = true
+          end
+        end
+        unless used_for_class
+          doc = RDoc::Markup::Document.new
+          begin
+            driver.add_method(doc, name)
+          rescue RDoc::RI::Driver::NotFoundError
+            doc = nil
+          rescue
+            return nil # unknown error
+          end
+        end
+        return nil if doc.nil?
+        width = 40
+
+        right_x = cursor_pos_to_render.x + autocomplete_dialog.width
+        if right_x + width > screen_width
+          right_width = screen_width - (right_x + 1)
+          left_x = autocomplete_dialog.column - width
+          left_x = 0 if left_x < 0
+          left_width = width > autocomplete_dialog.column ? autocomplete_dialog.column : width
+          if right_width.positive? and left_width.positive?
+            if right_width >= left_width
+              width = right_width
+              x = right_x
+            else
+              width = left_width
+              x = left_x
+            end
+          elsif right_width.positive? and left_width <= 0
             width = right_width
             x = right_x
-          else
+          elsif right_width <= 0 and left_width.positive?
             width = left_width
             x = left_x
+          else # Both are negative width.
+            return nil
           end
-        elsif right_width.positive? and left_width <= 0
-          width = right_width
+        else
           x = right_x
-        elsif right_width <= 0 and left_width.positive?
-          width = left_width
-          x = left_x
-        else # Both are negative width.
-          return nil
         end
+        formatter = RDoc::Markup::ToAnsi.new
+        formatter.width = width
+        dialog.trap_key = alt_d
+        mod_key = RUBY_PLATFORM.match?(/darwin/) ? "Option" : "Alt"
+        message = "Press #{mod_key}+d to read the full document"
+        contents = [message] + doc.accept(formatter).split("\n")
+        contents = contents.take(preferred_dialog_height)
+
+        y = cursor_pos_to_render.y
+        Reline::DialogRenderInfo.new(pos: Reline::CursorPos.new(x, y), contents: contents, width: width, bg_color: '49')
+      }
+    end
+
+    def display_document(matched, driver: nil)
+      begin
+        require 'rdoc'
+      rescue LoadError
+        return
+      end
+
+      if matched =~ /\A(?:::)?RubyVM/ and not ENV['RUBY_YES_I_AM_NOT_A_NORMAL_USER']
+        IRB.__send__(:easter_egg)
+        return
+      end
+
+      _target, preposing, postposing, bind = @completion_params
+      namespace = @completor.doc_namespace(preposing, matched, postposing, bind: bind)
+      return unless namespace
+
+      driver ||= RDoc::RI::Driver.new
+      if namespace.is_a?(Array)
+        out = RDoc::Markup::Document.new
+        namespace.each do |m|
+          begin
+            driver.add_method(out, m)
+          rescue RDoc::RI::Driver::NotFoundError
+          end
+        end
+        driver.display(out)
       else
-        x = right_x
+        begin
+          driver.display_names([namespace])
+        rescue RDoc::RI::Driver::NotFoundError
+        end
       end
-      formatter = RDoc::Markup::ToAnsi.new
-      formatter.width = width
-      dialog.trap_key = alt_d
-      mod_key = RUBY_PLATFORM.match?(/darwin/) ? "Option" : "Alt"
-      message = "Press #{mod_key}+d to read the full document"
-      contents = [message] + doc.accept(formatter).split("\n")
-      contents = contents.take(preferred_dialog_height)
-
-      y = cursor_pos_to_render.y
-      Reline::DialogRenderInfo.new(pos: Reline::CursorPos.new(x, y), contents: contents, width: width, bg_color: '49')
-    }
+    end
 
     # Reads the next line from this input method.
     #

data/lib/irb/ruby-lex.rb

@@ -42,14 +42,6 @@ module IRB
       end
     end
 
-    attr_reader :line_no
-
-    def initialize(context)
-      @context = context
-      @line_no = 1
-      @prompt = nil
-    end
-
     def self.compile_with_errors_suppressed(code, line_no: 1)
       begin
         result = yield code, line_no
@@ -67,10 +59,6 @@ module IRB
       result
     end
 
-    def set_prompt(&block)
-      @prompt = block
-    end
-
     ERROR_TOKENS = [
       :on_parse_error,
       :compile_error,
@@ -116,9 +104,9 @@ module IRB
       interpolated
     end
 
-    def self.ripper_lex_without_warning(code, context: nil)
+    def self.ripper_lex_without_warning(code, local_variables: [])
       verbose, $VERBOSE = $VERBOSE, nil
-      lvars_code = generate_local_variables_assign_code(context&.local_variables || [])
+      lvars_code = generate_local_variables_assign_code(local_variables)
       original_code = code
       if lvars_code
         code = "#{lvars_code}\n#{code}"
@@ -146,20 +134,14 @@ module IRB
       $VERBOSE = verbose
     end
 
-    def prompt(opens, continue, line_num_offset)
-      ltype = ltype_from_open_tokens(opens)
-      indent_level = calc_indent_level(opens)
-      @prompt&.call(ltype, indent_level, opens.any? || continue, @line_no + line_num_offset)
-    end
-
-    def check_code_state(code)
-      tokens = self.class.ripper_lex_without_warning(code, context: @context)
+    def check_code_state(code, local_variables:)
+      tokens = self.class.ripper_lex_without_warning(code, local_variables: local_variables)
       opens = NestingParser.open_tokens(tokens)
-      [tokens, opens, code_terminated?(code, tokens, opens)]
+      [tokens, opens, code_terminated?(code, tokens, opens, local_variables: local_variables)]
     end
 
-    def code_terminated?(code, tokens, opens)
-      case check_code_syntax(code)
+    def code_terminated?(code, tokens, opens, local_variables:)
+      case check_code_syntax(code, local_variables: local_variables)
       when :unrecoverable_error
         true
       when :recoverable_error
@@ -171,16 +153,7 @@ module IRB
       end
     end
 
-    def save_prompt_to_context_io(opens, continue, line_num_offset)
-      # Implicitly saves prompt string to `@context.io.prompt`. This will be used in the next `@input.call`.
-      prompt(opens, continue, line_num_offset)
-    end
-
-    def increase_line_no(addition)
-      @line_no += addition
-    end
-
-    def assignment_expression?(code)
+    def assignment_expression?(code, local_variables:)
       # Try to parse the code and check if the last of possibly multiple
       # expressions is an assignment type.
 
@@ -190,7 +163,7 @@ module IRB
       # 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#{code}"
+      code = "#{RubyLex.generate_local_variables_assign_code(local_variables) || 'nil;'}\n#{code}"
       # 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)
@@ -222,8 +195,8 @@ module IRB
       false
     end
 
-    def check_code_syntax(code)
-      lvars_code = RubyLex.generate_local_variables_assign_code(@context.local_variables)
+    def check_code_syntax(code, local_variables:)
+      lvars_code = RubyLex.generate_local_variables_assign_code(local_variables)
       code = "#{lvars_code}\n#{code}"
 
       begin # check if parser error are available
@@ -455,8 +428,8 @@ module IRB
       end
     end
 
-    def check_termination_in_prev_line(code)
-      tokens = self.class.ripper_lex_without_warning(code, context: @context)
+    def check_termination_in_prev_line(code, local_variables:)
+      tokens = self.class.ripper_lex_without_warning(code, local_variables: local_variables)
       past_first_newline = false
       index = tokens.rindex do |t|
         # traverse first token before last line
@@ -486,7 +459,7 @@ module IRB
           tokens_without_last_line = tokens[0..index]
           code_without_last_line = tokens_without_last_line.map(&:tok).join
           opens_without_last_line = NestingParser.open_tokens(tokens_without_last_line)
-          if code_terminated?(code_without_last_line, tokens_without_last_line, opens_without_last_line)
+          if code_terminated?(code_without_last_line, tokens_without_last_line, opens_without_last_line, local_variables: local_variables)
             return last_line_tokens.map(&:tok).join
           end
         end

data/lib/irb/source_finder.rb

@@ -43,7 +43,7 @@ module IRB
     private
 
     def find_end(file, first_line)
-      lex = RubyLex.new(@irb_context)
+      lex = RubyLex.new
       lines = File.read(file).lines[(first_line - 1)..-1]
       tokens = RubyLex.ripper_lex_without_warning(lines.join)
       prev_tokens = []
@@ -53,7 +53,7 @@ module IRB
         code = lines[0..lnum].join
         prev_tokens.concat chunk
         continue = lex.should_continue?(prev_tokens)
-        syntax = lex.check_code_syntax(code)
+        syntax = lex.check_code_syntax(code, local_variables: [])
         if !continue && syntax == :valid
           return first_line + lnum
         end

data/lib/irb/version.rb

@@ -5,7 +5,7 @@
 #
 
 module IRB # :nodoc:
-  VERSION = "1.8.0"
+  VERSION = "1.8.2"
   @RELEASE_VERSION = VERSION
-  @LAST_UPDATE_DATE = "2023-08-30"
+  @LAST_UPDATE_DATE = "2023-10-12"
 end

data/lib/irb.rb

@@ -436,7 +436,8 @@ module IRB
       @context = Context.new(self, workspace, input_method)
       @context.workspace.load_commands_to_main
       @signal_status = :IN_IRB
-      @scanner = RubyLex.new(@context)
+      @scanner = RubyLex.new
+      @line_no = 1
     end
 
     # A hook point for `debug` command's breakpoint after :IRB_EXIT as well as its clean-up
@@ -454,7 +455,7 @@ module IRB
       workspace = IRB::WorkSpace.new(binding)
       context.workspace = workspace
       context.workspace.load_commands_to_main
-      scanner.increase_line_no(1)
+      @line_no += 1
 
       # When users run:
       # 1. Debugging commands, like `step 2`
@@ -476,7 +477,7 @@ module IRB
       end
 
       if input&.include?("\n")
-        scanner.increase_line_no(input.count("\n") - 1)
+        @line_no += input.count("\n") - 1
       end
 
       input
@@ -513,34 +514,38 @@ module IRB
     # The lexer used by this irb session
     attr_accessor :scanner
 
-    # Evaluates input for this session.
-    def eval_input
-      @scanner.set_prompt do
-        |ltype, indent, continue, line_no|
-        if ltype
-          f = @context.prompt_s
-        elsif continue
-          f = @context.prompt_c
-        else
-          f = @context.prompt_i
-        end
-        f = "" unless f
-        if @context.prompting?
-          @context.io.prompt = p = prompt(f, ltype, indent, line_no)
-        else
-          @context.io.prompt = p = ""
-        end
-        if @context.auto_indent_mode and !@context.io.respond_to?(:auto_indent)
-          unless ltype
-            prompt_i = @context.prompt_i.nil? ? "" : @context.prompt_i
-            ind = prompt(prompt_i, ltype, indent, line_no)[/.*\z/].size +
-              indent * 2 - p.size
-            @context.io.prompt = p + " " * ind if ind > 0
-          end
+    private def generate_prompt(opens, continue, line_offset)
+      ltype = @scanner.ltype_from_open_tokens(opens)
+      indent = @scanner.calc_indent_level(opens)
+      continue = opens.any? || continue
+      line_no = @line_no + line_offset
+
+      if ltype
+        f = @context.prompt_s
+      elsif continue
+        f = @context.prompt_c
+      else
+        f = @context.prompt_i
+      end
+      f = "" unless f
+      if @context.prompting?
+        p = format_prompt(f, ltype, indent, line_no)
+      else
+        p = ""
+      end
+      if @context.auto_indent_mode and !@context.io.respond_to?(:auto_indent)
+        unless ltype
+          prompt_i = @context.prompt_i.nil? ? "" : @context.prompt_i
+          ind = format_prompt(prompt_i, ltype, indent, line_no)[/.*\z/].size +
+            indent * 2 - p.size
+          p += " " * ind if ind > 0
         end
-        @context.io.prompt
       end
+      p
+    end
 
+    # Evaluates input for this session.
+    def eval_input
       configure_io
 
       each_top_level_statement do |statement, line_no|
@@ -572,8 +577,9 @@ module IRB
       end
     end
 
-    def read_input
+    def read_input(prompt)
       signal_status(:IN_INPUT) do
+        @context.io.prompt = prompt
         if l = @context.io.gets
           print l if @context.verbose?
         else
@@ -591,16 +597,16 @@ module IRB
     end
 
     def readmultiline
-      @scanner.save_prompt_to_context_io([], false, 0)
+      prompt = generate_prompt([], false, 0)
 
       # multiline
-      return read_input if @context.io.respond_to?(:check_termination)
+      return read_input(prompt) if @context.io.respond_to?(:check_termination)
 
       # nomultiline
       code = ''
       line_offset = 0
       loop do
-        line = read_input
+        line = read_input(prompt)
         unless line
           return code.empty? ? nil : code
         end
@@ -610,12 +616,12 @@ module IRB
         # 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)
+        tokens, opens, terminated = @scanner.check_code_state(code, local_variables: @context.local_variables)
         return code if terminated
 
         line_offset += 1
         continue = @scanner.should_continue?(tokens)
-        @scanner.save_prompt_to_context_io(opens, continue, line_offset)
+        prompt = generate_prompt(opens, continue, line_offset)
       end
     end
 
@@ -625,9 +631,9 @@ module IRB
         break unless code
 
         if code != "\n"
-          yield build_statement(code), @scanner.line_no
+          yield build_statement(code), @line_no
         end
-        @scanner.increase_line_no(code.count("\n"))
+        @line_no += code.count("\n")
       rescue RubyLex::TerminateLineInput
       end
     end
@@ -643,7 +649,8 @@ module IRB
       if command_class
         Statement::Command.new(code, command, arg, command_class)
       else
-        Statement::Expression.new(code, @scanner.assignment_expression?(code))
+        is_assignment_expression = @scanner.assignment_expression?(code, local_variables: @context.local_variables)
+        Statement::Expression.new(code, is_assignment_expression)
       end
     end
 
@@ -656,7 +663,7 @@ module IRB
       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)
+            rest = @scanner.check_termination_in_prev_line(code, local_variables: @context.local_variables)
             if rest
               Reline.delete_text
               rest.bytes.reverse_each do |c|
@@ -670,7 +677,7 @@ module IRB
             # 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)
+            _tokens, _opens, terminated = @scanner.check_code_state(code, local_variables: @context.local_variables)
             terminated
           end
         end
@@ -678,7 +685,7 @@ module IRB
       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)
+          tokens = RubyLex.ripper_lex_without_warning(lines.map{ |l| l + "\n" }.join, local_variables: @context.local_variables)
           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|
@@ -687,7 +694,7 @@ module IRB
               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)
+            generate_prompt(next_opens, continue, line_num_offset)
           end
         end
       end
@@ -698,7 +705,7 @@ module IRB
           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)
+          tokens = RubyLex.ripper_lex_without_warning(code, local_variables: @context.local_variables)
           @scanner.process_indent_level(tokens, lines, line_index, is_newline)
         end
       end
@@ -873,7 +880,7 @@ module IRB
       end
     end
 
-    def truncate_prompt_main(str) # :nodoc:
+    private def truncate_prompt_main(str) # :nodoc:
       str = str.tr(CONTROL_CHARACTERS_PATTERN, ' ')
       if str.size <= PROMPT_MAIN_TRUNCATE_LENGTH
         str
@@ -882,9 +889,8 @@ module IRB
       end
     end
 
-    def prompt(prompt, ltype, indent, line_no) # :nodoc:
-      p = prompt.dup
-      p.gsub!(/%([0-9]+)?([a-zA-Z])/) do
+    private def format_prompt(format, ltype, indent, line_no) # :nodoc:
+      format.gsub(/%([0-9]+)?([a-zA-Z])/) do
         case $2
         when "N"
           @context.irb_name
@@ -918,7 +924,6 @@ module IRB
           "%"
         end
       end
-      p
     end
 
     def output_value(omit = false) # :nodoc:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: irb
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 1.8.2
 platform: ruby
 authors:
 - aycabta
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-30 00:00:00.000000000 Z
+date: 2023-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: reline
@@ -17,28 +17,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.6
+        version: 0.3.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.6
+        version: 0.3.8
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '6.5'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '6.5'
+        version: '0'
 description: Interactive Ruby command-line tool for REPL (Read Eval Print Loop).
 email:
 - aycabta@gmail.com