irb 1.15.1 → 1.18.0

data/lib/irb/completion.rb

@@ -8,30 +8,33 @@
 require_relative 'ruby-lex'
 
 module IRB
+  class DocumentTarget # :nodoc:
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+  end
+
+  class CommandDocument < DocumentTarget # :nodoc:
+  end
+
+  # Represents a method/class documentation target. May hold multiple names
+  # when the receiver is ambiguous (e.g. `{}.any?` could be Hash#any? or Proc#any?).
+  # The dialog popup uses only the first name; the full-screen display renders all.
+  class MethodDocument < DocumentTarget # :nodoc:
+    attr_reader :names
+
+    def initialize(*names)
+      super(names.first)
+      @names = names
+    end
+  end
+
   class BaseCompletor # :nodoc:
 
     # 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 +63,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
@@ -96,6 +99,12 @@ module IRB
       end
     end
 
+    def command_document_target(preposing, matched)
+      if preposing.empty? && IRB::Command.command_names.include?(matched)
+        CommandDocument.new(matched)
+      end
+    end
+
     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/, '')
@@ -127,12 +136,21 @@ 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:)
-      result = ReplTypeCompletor.analyze(preposing + matched, binding: bind, filename: @context.irb_path)
-      result&.doc_namespace('')
+      command_document_target(preposing, matched) || begin
+        result = ReplTypeCompletor.analyze(preposing + matched, binding: bind, filename: @context.irb_path)
+        result&.doc_namespace('')
+      end
     end
   end
 
@@ -179,28 +197,15 @@ module IRB
       else
         return nil # It's not String literal
       end
-      tokens = RubyLex.ripper_lex_without_warning(preposing.gsub(/\s*\z/, ''))
-      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)
-          tok = t
-          break
-        end
-      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
+
+      case preposing
+      when /(^|[^\w])require\(? *\z/
+        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
+      when /(^|[^\w])require_relative\(? *\z/
+        retrieve_files_to_require_relative_from_current_dir.filter_map { |path|
+          quote + path if path.start_with?(actual_target)
         }
       end
     end
@@ -218,12 +223,17 @@ 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
 
-    def doc_namespace(_preposing, matched, _postposing, bind:)
-      retrieve_completion_data(matched, bind: bind, doc_namespace: true)
+    def doc_namespace(preposing, matched, _postposing, bind:)
+      command_document_target(preposing, matched) || retrieve_completion_data(matched, bind: bind, doc_namespace: true)
     end
 
     def retrieve_completion_data(input, bind:, doc_namespace:)
@@ -287,7 +297,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 +469,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

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/init.rb

@@ -87,6 +87,7 @@ module IRB # :nodoc:
     @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
@@ -345,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"

data/lib/irb/input-method.rb

@@ -26,10 +26,11 @@ module IRB
 
     def winsize
       if instance_variable_defined?(:@stdout) && @stdout.tty?
-        @stdout.winsize
-      else
-        [24, 80]
+        winsize = @stdout.winsize
+        # If width or height is 0, something is wrong.
+        return winsize unless winsize.include? 0
       end
+      [24, 80]
     end
 
     # Whether this input method is still readable when there is no more data to
@@ -175,10 +176,15 @@ module IRB
   class ReadlineInputMethod < StdioInputMethod
     class << self
       def initialize_readline
-        require "readline"
-      rescue LoadError
-      else
-        include ::Readline
+        return if defined?(self::Readline)
+
+        begin
+          require 'readline'
+          const_set(:Readline, ::Readline)
+        rescue LoadError
+          const_set(:Readline, ::Reline)
+        end
+        const_set(:HISTORY, self::Readline::HISTORY)
       end
     end
 
@@ -216,8 +222,8 @@ module IRB
     def gets
       Readline.input = @stdin
       Readline.output = @stdout
-      if l = readline(@prompt, false)
-        HISTORY.push(l) if !l.empty?
+      if l = Readline.readline(@prompt, false)
+        Readline::HISTORY.push(l) if !l.empty? && l != Readline::HISTORY.to_a.last
         @line[@line_no += 1] = l + "\n"
       else
         @eof = true
@@ -239,7 +245,7 @@ module IRB
 
     # For debug message
     def inspect
-      readline_impl = (defined?(Reline) && Readline == Reline) ? 'Reline' : 'ext/readline'
+      readline_impl = Readline == ::Reline ? 'Reline' : 'ext/readline'
       str = "ReadlineInputMethod with #{readline_impl} #{Readline::VERSION}"
       inputrc_path = File.expand_path(ENV['INPUTRC'] || '~/.inputrc')
       str += " and #{inputrc_path}" if File.exist?(inputrc_path)
@@ -249,6 +255,16 @@ module IRB
 
   class RelineInputMethod < StdioInputMethod
     HISTORY = Reline::HISTORY
+    ALT_KEY_NAME = RUBY_PLATFORM.match?(/darwin/) ? "Option" : "Alt"
+    PRESS_ALT_D_TO_READ_FULL_DOC = "Press #{ALT_KEY_NAME}+d to read the full document".freeze
+    PRESS_ALT_D_TO_SEE_MORE = "Press #{ALT_KEY_NAME}+d to see more".freeze
+    ALT_D_SEQUENCES = [
+      [27, 100], # Normal Alt+d when convert-meta isn't used.
+      # When option/alt is not configured as a meta key in terminal emulator,
+      # option/alt + d will send a unicode character depend on OS keyboard setting.
+      [195, 164], # "ä" in somewhere (FIXME: environment information is unknown).
+      [226, 136, 130] # "∂" Alt+d on Mac keyboard.
+    ].freeze
     include HistorySavingAbility
     # Creates a new input method object using Reline
     def initialize(completor)
@@ -299,9 +315,17 @@ module IRB
       @auto_indent_proc = block
     end
 
-    def retrieve_doc_namespace(matched)
+    def retrieve_document_target(matched)
       preposing, _target, postposing, bind = @completion_params
-      @completor.doc_namespace(preposing, matched, postposing, bind: bind)
+      result = @completor.doc_namespace(preposing, matched, postposing, bind: bind)
+      case result
+      when DocumentTarget, nil
+        result
+      when Array
+        MethodDocument.new(*result)
+      when String
+        MethodDocument.new(result)
+      end
     end
 
     def rdoc_ri_driver
@@ -322,146 +346,158 @@ module IRB
       input_method = self # self is changed in the lambda below.
       ->() {
         dialog.trap_key = nil
-        alt_d = [
-          [27, 100], # Normal Alt+d when convert-meta isn't used.
-          # When option/alt is not configured as a meta key in terminal emulator,
-          # option/alt + d will send a unicode character depend on OS keyboard setting.
-          [195, 164], # "ä" in somewhere (FIXME: environment information is unknown).
-          [226, 136, 130] # "∂" Alt+d on Mac keyboard.
-        ]
-
-        if just_cursor_moving and completion_journey_data.nil?
+
+        if just_cursor_moving && 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
+        return nil if result.nil? || pointer.nil? || pointer < 0
 
-        name = input_method.retrieve_doc_namespace(result[pointer])
-        # Use first one because document dialog does not support multiple namespaces.
-        name = name.first if name.is_a?(Array)
+        matched_text = result[pointer]
+        show_easter_egg = matched_text&.match?(/\ARubyVM/) && !ENV['RUBY_YES_I_AM_NOT_A_NORMAL_USER']
+        target = show_easter_egg ? nil : input_method.retrieve_document_target(matched_text)
 
-        show_easter_egg = name&.match?(/\ARubyVM/) && !ENV['RUBY_YES_I_AM_NOT_A_NORMAL_USER']
+        x, width = input_method.dialog_doc_position(cursor_pos_to_render, autocomplete_dialog, screen_width)
+        return nil unless x
 
-        driver = input_method.rdoc_ri_driver
+        dialog.trap_key = ALT_D_SEQUENCES
 
         if key.match?(dialog.name)
-          if show_easter_egg
-            IRB.__send__(:easter_egg)
-          else
-            # RDoc::RI::Driver#display_names uses pager command internally.
-            # Some pager command like `more` doesn't use alternate screen
-            # so we need to turn on and off alternate screen manually.
-            begin
-              print "\e[?1049h"
-              driver.display_names([name])
-            rescue RDoc::RI::Driver::NotFoundError
-            ensure
-              print "\e[?1049l"
-            end
+          begin
+            print "\e[?1049h"
+            input_method.display_document(matched_text)
+          ensure
+            print "\e[?1049l"
           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
+        contents = case target
+        when CommandDocument
+          input_method.command_doc_dialog_contents(target.name, width)
+        when MethodDocument
+          input_method.rdoc_dialog_contents(target.name, width)
+        else
+          if show_easter_egg
+            input_method.easter_egg_dialog_contents
           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
+        return nil unless contents
+
+        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 command_doc_dialog_contents(command_name, width)
+      command_class = IRB::Command.load_command(command_name)
+      return unless command_class
+
+      [PRESS_ALT_D_TO_READ_FULL_DOC, ""] + command_class.doc_dialog_content(command_name, width)
+    end
+
+    def easter_egg_dialog_contents
+      type = STDOUT.external_encoding == Encoding::UTF_8 ? :unicode : :ascii
+      lines = IRB.send(:easter_egg_logo, type).split("\n")
+      lines[0][0, PRESS_ALT_D_TO_SEE_MORE.size] = PRESS_ALT_D_TO_SEE_MORE
+      lines
+    end
+
+    def rdoc_dialog_contents(name, width)
+      driver = rdoc_ri_driver
+      return unless driver
+
+      name = driver.expand_name(name)
+
+      doc = if name =~ /#|\./
+        d = RDoc::Markup::Document.new
+        driver.add_method(d, name)
+        d
+      else
+        found, klasses, includes, extends = driver.classes_and_includes_and_extends_for(name)
+        if found.empty?
+          d = RDoc::Markup::Document.new
+          driver.add_method(d, name)
+          d
+        else
+          driver.class_document(name, found, klasses, includes, extends)
         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
+      end
+
+      formatter = RDoc::Markup::ToAnsi.new
+      formatter.width = width
+      [PRESS_ALT_D_TO_READ_FULL_DOC] + doc.accept(formatter).split("\n")
+    rescue RDoc::RI::Driver::NotFoundError
+    end
+
+    def dialog_doc_position(cursor_pos_to_render, autocomplete_dialog, screen_width)
+      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? && left_width.positive?
+          if right_width >= left_width
             width = right_width
             x = right_x
-          elsif right_width <= 0 and left_width.positive?
+          else
             width = left_width
             x = left_x
-          else # Both are negative width.
-            return nil
           end
-        else
+        elsif right_width.positive? && left_width <= 0
+          width = right_width
           x = right_x
-        end
-        formatter = RDoc::Markup::ToAnsi.new
-        formatter.width = width
-        dialog.trap_key = alt_d
-        mod_key = RUBY_PLATFORM.match?(/darwin/) ? "Option" : "Alt"
-        if show_easter_egg
-          type = STDOUT.external_encoding == Encoding::UTF_8 ? :unicode : :ascii
-          contents = IRB.send(:easter_egg_logo, type).split("\n")
-          message = "Press #{mod_key}+d to see more"
-          contents[0][0, message.size] = message
+        elsif right_width <= 0 && left_width.positive?
+          width = left_width
+          x = left_x
         else
-          message = "Press #{mod_key}+d to read the full document"
-          contents = [message] + doc.accept(formatter).split("\n")
+          return nil
         end
-        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')
-      }
+      else
+        x = right_x
+      end
+      [x, width]
     end
 
     def display_document(matched)
-      driver = rdoc_ri_driver
-      return unless driver
-
-      if matched =~ /\A(?:::)?RubyVM/ and not ENV['RUBY_YES_I_AM_NOT_A_NORMAL_USER']
-        IRB.__send__(:easter_egg)
-        return
-      end
+      target = retrieve_document_target(matched)
+      return unless target
+
+      case target
+      when CommandDocument
+        command_class = IRB::Command.load_command(target.name)
+        if command_class
+          content = command_class.help_message || command_class.description
+          Pager.page(retain_content: true) do |io|
+            io.puts content
+          end
+        end
+      when MethodDocument
+        driver = rdoc_ri_driver
+        return unless driver
 
-      namespace = retrieve_doc_namespace(matched)
-      return unless namespace
+        if matched =~ /\A(?:::)?RubyVM/ && !ENV['RUBY_YES_I_AM_NOT_A_NORMAL_USER']
+          IRB.__send__(:easter_egg)
+          return
+        end
 
-      if namespace.is_a?(Array)
-        out = RDoc::Markup::Document.new
-        namespace.each do |m|
+        if target.names.length > 1
+          out = RDoc::Markup::Document.new
+          target.names.each do |m|
+            begin
+              driver.add_method(out, m)
+            rescue RDoc::RI::Driver::NotFoundError
+            end
+          end
+          driver.display(out)
+        else
           begin
-            driver.add_method(out, m)
+            driver.display_names([target.name])
           rescue RDoc::RI::Driver::NotFoundError
           end
         end
-        driver.display(out)
-      else
-        begin
-          driver.display_names([namespace])
-        rescue RDoc::RI::Driver::NotFoundError
-        end
       end
     end
 
@@ -474,7 +510,7 @@ module IRB
       Reline.prompt_proc = @prompt_proc
       Reline.auto_indent_proc = @auto_indent_proc if @auto_indent_proc
       if l = Reline.readmultiline(@prompt, false, &@check_termination_proc)
-        Reline::HISTORY.push(l) if !l.empty?
+        Reline::HISTORY.push(l) if !l.empty? && l != Reline::HISTORY.to_a.last
         @line[@line_no += 1] = l + "\n"
       else
         @eof = true