irb 1.2.6 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5cafd02c241d954487f11903643ef4a4218d39352c889f3be57a1e9314acb174
-  data.tar.gz: 0f4afd5294f5357835df0519b0a32cba425cf40a1afc225cf3acf0ae4d0cb04a
+  metadata.gz: e147abaf69084b92f2f7accaf7d83014b6c0f7b3b6cbe0cc9b9878c52baee8af
+  data.tar.gz: 9a770f98f44f4bf498c91a3d8546d13a1db418daa034639646c0df0c3720d23e
 SHA512:
-  metadata.gz: 958f6f1750e5cb951110a1de09beebee65e24c931989da99dd05a1207f050e96f37490e6def0c484b18a23a91c66ad8119a7aa2c5e48c7ad6eacb4590ea4c397
-  data.tar.gz: 1c6d64ed48b51f189ba9d5846ffdfeae02eff8e44554c66d54eeaab597b96381bdbe78aeba6f2f5fbb0929ee5517e87584eeebd50c65bc93e5cd3321c1b8260e
+  metadata.gz: f760ae68d08c7ae7f9f4ec07149935819f50df015a5f4a9453eca4a01574677ed5a29ae1c4eb8462b9cc92f5ad6b465b4e8b1c3f37748bd81ecde7159cf3a1c0
+  data.tar.gz: 3da91491f2e3928c8b619f120b6c6adcd020ed16760a4c176aee38bec5ca3964eb7cd0acc053a6a18dacec571b9a0b1e93d2a4c94a628a642b3b39bfd98b5284

data/irb.gemspec

@@ -33,10 +33,12 @@ Gem::Specification.new do |spec|
     "lib/irb/cmd/fork.rb",
     "lib/irb/cmd/help.rb",
     "lib/irb/cmd/load.rb",
+    "lib/irb/cmd/measure.rb",
     "lib/irb/cmd/nop.rb",
     "lib/irb/cmd/pushws.rb",
     "lib/irb/cmd/subirb.rb",
     "lib/irb/color.rb",
+    "lib/irb/color_printer.rb",
     "lib/irb/completion.rb",
     "lib/irb/context.rb",
     "lib/irb/easter-egg.rb",

data/lib/irb.rb

@@ -400,7 +400,7 @@ module IRB
     irb.run(@CONF)
   end
 
-  # Calls each event hook of <code>IRB.conf[:TA_EXIT]</code> when the current session quits.
+  # Calls each event hook of <code>IRB.conf[:AT_EXIT]</code> when the current session quits.
   def IRB.irb_at_exit
     @CONF[:AT_EXIT].each{|hook| hook.call}
   end
@@ -538,11 +538,28 @@ module IRB
         signal_status(:IN_EVAL) do
           begin
             line.untaint if RUBY_VERSION < '2.7'
-            @context.evaluate(line, line_no, exception: exc)
+            if IRB.conf[:MEASURE] && IRB.conf[:MEASURE_CALLBACKS].empty?
+              IRB.set_measure_callback
+            end
+            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)
+            end
             if @context.echo?
               if assignment_expression?(line)
                 if @context.echo_on_assignment?
-                  output_value(@context.omit_on_assignment?)
+                  output_value(@context.echo_on_assignment? == :truncate)
                 end
               else
                 output_value
@@ -561,6 +578,29 @@ module IRB
       end
     end
 
+    def convert_invalid_byte_sequence(str)
+      str = str.force_encoding(Encoding::ASCII_8BIT)
+      conv = Encoding::Converter.new(Encoding::ASCII_8BIT, Encoding::UTF_8)
+      dst = String.new
+      begin
+        ret = conv.primitive_convert(str, dst)
+        case ret
+        when :invalid_byte_sequence
+          conv.insert_output(conf.primitive_errinfo[3].dump[1..-2])
+          redo
+        when :undefined_conversion
+          c = conv.primitive_errinfo[3].dup.force_encoding(conv.primitive_errinfo[1])
+          conv.insert_output(c.dump[1..-2])
+          redo
+        when :incomplete_input
+          conv.insert_output(conv.primitive_errinfo[3].dump[1..-2])
+        when :finished
+        end
+        break
+      end while nil
+      dst
+    end
+
     def handle_exception(exc)
       if exc.backtrace && exc.backtrace[0] =~ /\/irb(2)?(\/.*|-.*|\.rb)?:/ && exc.class.to_s !~ /^IRB/ &&
          !(SyntaxError === exc) && !(EncodingError === exc)
@@ -570,49 +610,44 @@ module IRB
         irb_bug = false
       end
 
-      if STDOUT.tty?
-        attr = ATTR_TTY
-        print "#{attr[1]}Traceback#{attr[]} (most recent call last):\n"
-      else
-        attr = ATTR_PLAIN
-      end
-      messages = []
-      lasts = []
-      levels = 0
       if exc.backtrace
-        count = 0
-        exc.backtrace.each do |m|
-          m = @context.workspace.filter_backtrace(m) or next unless irb_bug
-          count += 1
-          if attr == ATTR_TTY
-            m = sprintf("%9d: from %s", count, m)
+        order = nil
+        if '2.5.0' == RUBY_VERSION
+          # Exception#full_message doesn't have keyword arguments.
+          message = exc.full_message # the same of (highlight: true, order: bottom)
+          order = :bottom
+        elsif '2.5.1' <= RUBY_VERSION && RUBY_VERSION < '3.0.0'
+          if STDOUT.tty?
+            message = exc.full_message(order: :bottom)
+            order = :bottom
           else
-            m = "\tfrom #{m}"
+            message = exc.full_message(order: :top)
+            order = :top
           end
-          if messages.size < @context.back_trace_limit
-            messages.push(m)
-          elsif lasts.size < @context.back_trace_limit
-            lasts.push(m).shift
-            levels += 1
-          end
-        end
-      end
-      if attr == ATTR_TTY
-        unless lasts.empty?
-          puts lasts.reverse
-          printf "... %d levels...\n", levels if levels > 0
-        end
-        puts messages.reverse
-      end
-      m = exc.to_s.split(/\n/)
-      print "#{attr[1]}#{exc.class} (#{attr[4]}#{m.shift}#{attr[0, 1]})#{attr[]}\n"
-      puts m.map {|s| "#{attr[1]}#{s}#{attr[]}\n"}
-      if attr == ATTR_PLAIN
-        puts messages
-        unless lasts.empty?
-          puts lasts
-          printf "... %d levels...\n", levels if levels > 0
+        else # '3.0.0' <= RUBY_VERSION
+          message = exc.full_message(order: :top)
+          order = :top
         end
+        message = convert_invalid_byte_sequence(message)
+        message = message.gsub(/((?:^\t.+$\n)+)/)  { |m|
+          case order
+          when :top
+            lines = m.split("\n")
+          when :bottom
+            lines = m.split("\n").reverse
+          end
+          unless irb_bug
+            lines = lines.map { |l| @context.workspace.filter_backtrace(l) }.compact
+            if lines.size > @context.back_trace_limit
+              omit = lines.size - @context.back_trace_limit
+              lines = lines[0..(@context.back_trace_limit - 1)]
+              lines << "\t... %d levels..." % omit
+            end
+          end
+          lines = lines.reverse if order == :bottom
+          lines.map{ |l| l + "\n" }.join
+        }
+        puts message
       end
       print "Maybe IRB bug!\n" if irb_bug
     end
@@ -761,7 +796,7 @@ module IRB
             str = "%s...\e[0m" % lines.first
             multiline_p = false
           else
-            str.gsub!(/(\A.*?\n).*/m, "\\1...")
+            str = str.gsub(/(\A.*?\n).*/m, "\\1...")
           end
         else
           output_width = Reline::Unicode.calculate_width(@context.return_format % str, true)

data/lib/irb/cmd/fork.rb

@@ -16,7 +16,7 @@ module IRB
   module ExtendCommand
     class Fork < Nop
       def execute
-        pid = send ExtendCommand.irb_original_method_name("fork")
+        pid = __send__ ExtendCommand.irb_original_method_name("fork")
         unless pid
           class << self
             alias_method :exit, ExtendCommand.irb_original_method_name('exit')

data/lib/irb/cmd/measure.rb

@@ -0,0 +1,34 @@
+require_relative "nop"
+
+# :stopdoc:
+module IRB
+  module ExtendCommand
+    class Measure < Nop
+      def initialize(*args)
+        super(*args)
+      end
+
+      def execute(type = nil, arg = nil)
+        case type
+        when :off
+          IRB.conf[:MEASURE] = nil
+          IRB.unset_measure_callback(arg)
+        when :list
+          IRB.conf[:MEASURE_CALLBACKS].each do |type_name, _, arg_val|
+            puts "- #{type_name}" + (arg_val ? "(#{arg_val.inspect})" : '')
+          end
+        when :on
+          IRB.conf[:MEASURE] = true
+          added = IRB.set_measure_callback(type, arg)
+          puts "#{added[0]} is added." if added
+        else
+          IRB.conf[:MEASURE] = true
+          added = IRB.set_measure_callback(type, arg)
+          puts "#{added[0]} is added." if added
+        end
+        nil
+      end
+    end
+  end
+end
+# :startdoc:

data/lib/irb/color.rb

@@ -60,6 +60,10 @@ module IRB # :nodoc:
         on_words_beg:       [[RED, BOLD],             ALL],
         on_parse_error:     [[RED, REVERSE],          ALL],
         compile_error:      [[RED, REVERSE],          ALL],
+        on_assign_error:    [[RED, REVERSE],          ALL],
+        on_alias_error:     [[RED, REVERSE],          ALL],
+        on_class_name_error:[[RED, REVERSE],          ALL],
+        on_param_error:     [[RED, REVERSE],          ALL],
       }
     rescue NameError
       # Give up highlighting Ripper-incompatible older Ruby
@@ -67,6 +71,9 @@ module IRB # :nodoc:
     end
     private_constant :TOKEN_SEQ_EXPRS
 
+    ERROR_TOKENS = TOKEN_SEQ_EXPRS.keys.select { |k| k.to_s.end_with?('error') }
+    private_constant :ERROR_TOKENS
+
     class << self
       def colorable?
         $stdout.tty? && supported? && (/mswin|mingw/ =~ RUBY_PLATFORM || (ENV.key?('TERM') && ENV['TERM'] != 'dumb'))
@@ -107,7 +114,7 @@ module IRB # :nodoc:
       # If `complete` is false (code is incomplete), this does not warn compile_error.
       # This option is needed to avoid warning a user when the compile_error is happening
       # because the input is not wrong but just incomplete.
-      def colorize_code(code, complete: true)
+      def colorize_code(code, complete: true, ignore_error: false)
         return code unless colorable?
 
         symbol_state = SymbolState.new
@@ -115,6 +122,11 @@ module IRB # :nodoc:
         length = 0
 
         scan(code, allow_last_error: !complete) do |token, str, expr|
+          # IRB::ColorPrinter skips colorizing fragments with any invalid token
+          if ignore_error && ERROR_TOKENS.include?(token)
+            return Reline::Unicode.escape_for_print(code)
+          end
+
           in_symbol = symbol_state.scan_token(token)
           str.each_line do |line|
             line = Reline::Unicode.escape_for_print(line)
@@ -180,11 +192,12 @@ module IRB # :nodoc:
             end
           end
         end
+      ensure
         $VERBOSE = verbose
       end
 
       def dispatch_seq(token, expr, str, in_symbol:)
-        if token == :on_parse_error or token == :compile_error
+        if ERROR_TOKENS.include?(token)
           TOKEN_SEQ_EXPRS[token][0]
         elsif in_symbol
           [YELLOW]

data/lib/irb/color_printer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require 'pp'
+require 'irb/color'
+
+module IRB
+  class ColorPrinter < ::PP
+    def self.pp(obj, out = $>, width = 79)
+      q = ColorPrinter.new(out, width)
+      q.guard_inspect_key {q.pp obj}
+      q.flush
+      out << "\n"
+    end
+
+    def text(str, width = nil)
+      unless str.is_a?(String)
+        str = str.inspect
+      end
+      width ||= str.length
+
+      case str
+      when /\A#</, '=', '>'
+        super(Color.colorize(str, [:GREEN]), width)
+      else
+        super(Color.colorize_code(str, ignore_error: true), width)
+      end
+    end
+  end
+end

data/lib/irb/completion.rb

@@ -47,7 +47,7 @@ module IRB
       when /^((["'`]).*\2)\.([^.]*)$/
         # String
         receiver = $1
-        message = Regexp.quote($3)
+        message = $3
 
         candidates = String.instance_methods.collect{|m| m.to_s}
         if doc_namespace
@@ -59,7 +59,7 @@ module IRB
       when /^(\/[^\/]*\/)\.([^.]*)$/
         # Regexp
         receiver = $1
-        message = Regexp.quote($2)
+        message = $2
 
         candidates = Regexp.instance_methods.collect{|m| m.to_s}
         if doc_namespace
@@ -71,7 +71,7 @@ module IRB
       when /^([^\]]*\])\.([^.]*)$/
         # Array
         receiver = $1
-        message = Regexp.quote($2)
+        message = $2
 
         candidates = Array.instance_methods.collect{|m| m.to_s}
         if doc_namespace
@@ -83,7 +83,7 @@ module IRB
       when /^([^\}]*\})\.([^.]*)$/
         # Proc or Hash
         receiver = $1
-        message = Regexp.quote($2)
+        message = $2
 
         proc_candidates = Proc.instance_methods.collect{|m| m.to_s}
         hash_candidates = Hash.instance_methods.collect{|m| m.to_s}
@@ -117,7 +117,7 @@ module IRB
       when /^([A-Z].*)::([^:.]*)$/
         # Constant or class methods
         receiver = $1
-        message = Regexp.quote($2)
+        message = $2
         begin
           candidates = eval("#{receiver}.constants.collect{|m| m.to_s}", bind)
           candidates |= eval("#{receiver}.methods.collect{|m| m.to_s}", bind)
@@ -134,7 +134,7 @@ module IRB
         # Symbol
         receiver = $1
         sep = $2
-        message = Regexp.quote($3)
+        message = $3
 
         candidates = Symbol.instance_methods.collect{|m| m.to_s}
         if doc_namespace
@@ -147,7 +147,7 @@ module IRB
         # Numeric
         receiver = $~[:num]
         sep = $~[:sep]
-        message = Regexp.quote($~[:mes])
+        message = $~[:mes]
 
         begin
           instance = eval(receiver, bind)
@@ -169,7 +169,7 @@ module IRB
         # Numeric(0xFFFF)
         receiver = $1
         sep = $2
-        message = Regexp.quote($3)
+        message = $3
 
         begin
           instance = eval(receiver, bind)
@@ -201,7 +201,7 @@ module IRB
         # variable.func or func.func
         receiver = $1
         sep = $2
-        message = Regexp.quote($3)
+        message = $3
 
         gv = eval("global_variables", bind).collect{|m| m.to_s}.push("true", "false", "nil")
         lv = eval("local_variables", bind).collect{|m| m.to_s}
@@ -244,7 +244,7 @@ module IRB
         # unknown(maybe String)
 
         receiver = ""
-        message = Regexp.quote($1)
+        message = $1
 
         candidates = String.instance_methods(true).collect{|m| m.to_s}
         if doc_namespace
@@ -268,7 +268,7 @@ module IRB
     PerfectMatchedProc = ->(matched, bind: IRB.conf[:MAIN_CONTEXT].workspace.binding) {
       RDocRIDriver ||= RDoc::RI::Driver.new
       if matched =~ /\A(?:::)?RubyVM/ and not ENV['RUBY_YES_I_AM_NOT_A_NORMAL_USER']
-        IRB.send(:easter_egg)
+        IRB.__send__(:easter_egg)
         return
       end
       namespace = retrieve_completion_data(matched, bind: bind, doc_namespace: true)
@@ -294,7 +294,7 @@ module IRB
     Operators = %w[% & * ** + - / < << <= <=> == === =~ > >= >> [] []= ^ ! != !~]
 
     def self.select_message(receiver, message, candidates, sep = ".")
-      candidates.grep(/^#{message}/).collect do |e|
+      candidates.grep(/^#{Regexp.quote(message)}/).collect do |e|
         case e
         when /^[a-zA-Z_]/
           receiver + sep + e

data/lib/irb/context.rb

@@ -131,12 +131,7 @@ module IRB
 
       @echo_on_assignment = IRB.conf[:ECHO_ON_ASSIGNMENT]
       if @echo_on_assignment.nil?
-        @echo_on_assignment = true
-      end
-
-      @omit_on_assignment = IRB.conf[:OMIT_ON_ASSIGNMENT]
-      if @omit_on_assignment.nil?
-        @omit_on_assignment = true
+        @echo_on_assignment = :truncate
       end
 
       @newline_before_multiline_output = IRB.conf[:NEWLINE_BEFORE_MULTILINE_OUTPUT]
@@ -256,27 +251,24 @@ module IRB
     attr_accessor :echo
     # Whether to echo for assignment expressions
     #
-    # Uses <code>IRB.conf[:ECHO_ON_ASSIGNMENT]</code> if available, or defaults to +true+.
+    # If set to +false+, the value of assignment will not be shown.
+    #
+    # If set to +true+, the value of assignment will be shown.
+    #
+    # If set to +:truncate+, the value of assignment will be shown and truncated.
+    #
+    # It defaults to +:truncate+.
     #
     #     a = "omg"
     #     #=> omg
+    #     a = "omg" * 10
+    #     #=> omgomgomgomgomgomgomg...
     #     IRB.CurrentContext.echo_on_assignment = false
     #     a = "omg"
+    #     IRB.CurrentContext.echo_on_assignment = true
+    #     a = "omg"
+    #     #=> omgomgomgomgomgomgomgomgomgomg
     attr_accessor :echo_on_assignment
-    # Whether to omit echo for assignment expressions
-    #
-    # Uses <code>IRB.conf[:OMIT_ON_ASSIGNMENT]</code> if available, or defaults to +true+.
-    #
-    #     a = [1] * 10
-    #     #=> [1, 1, 1, 1, 1, 1, 1, 1, ...
-    #     [1] * 10
-    #     #=> [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
-    #     IRB.CurrentContext.omit_on_assignment = false
-    #     a = [1] * 10
-    #     #=> [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
-    #     [1] * 10
-    #     #=> [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
-    attr_accessor :omit_on_assignment
     # Whether a newline is put before multiline output.
     #
     # Uses <code>IRB.conf[:NEWLINE_BEFORE_MULTILINE_OUTPUT]</code> if available,
@@ -325,7 +317,6 @@ module IRB
     alias ignore_eof? ignore_eof
     alias echo? echo
     alias echo_on_assignment? echo_on_assignment
-    alias omit_on_assignment? omit_on_assignment
     alias newline_before_multiline_output? newline_before_multiline_output
 
     # Returns whether messages are displayed or not.

data/lib/irb/easter-egg.rb

@@ -126,6 +126,7 @@ module IRB
             print "\e[H" + buff
             sleep 0.05
           end
+        rescue Interrupt
         ensure
           print "\e[0m\e[?1049l"
         end
@@ -134,4 +135,4 @@ module IRB
   end
 end
 
-IRB.send(:easter_egg, ARGV[0]&.to_sym) if $0 == __FILE__
+IRB.__send__(:easter_egg, ARGV[0]&.to_sym) if $0 == __FILE__

data/lib/irb/extend-command.rb

@@ -125,6 +125,10 @@ module IRB # :nodoc:
         :irb_info, :Info, "irb/cmd/info"
       ],
 
+      [
+        :measure, :Measure, "irb/cmd/measure"
+      ],
+
     ]
 
     # Installs the default irb commands:
@@ -173,14 +177,14 @@ module IRB # :nodoc:
             args << "&block"
             args = args.join(", ")
             line = __LINE__; eval %[
-              unless self.class.class_variable_defined?(:@@#{cmd_name}_)
-              self.class.class_variable_set(:@@#{cmd_name}_, true)
-                def #{cmd_name}_(\#{args})
+              unless singleton_class.class_variable_defined?(:@@#{cmd_name}_)
+                singleton_class.class_variable_set(:@@#{cmd_name}_, true)
+                def self.#{cmd_name}_(\#{args})
                   ExtendCommand::#{cmd_class}.execute(irb_context, \#{args})
                 end
               end
             ], nil, __FILE__, line
-            send :#{cmd_name}_, *opts, &b
+            __send__ :#{cmd_name}_, *opts, &b
           end
         ], nil, __FILE__, line
       else
@@ -268,7 +272,7 @@ module IRB # :nodoc:
         def #{cmd_name}(*opts, &b)
           Context.module_eval {remove_method(:#{cmd_name})}
           require "#{load_file}"
-          send :#{cmd_name}, *opts, &b
+          __send__ :#{cmd_name}, *opts, &b
         end
         for ali in aliases
           alias_method ali, cmd_name
@@ -291,8 +295,8 @@ module IRB # :nodoc:
       module_eval %[
         alias_method alias_name, base_method
         def #{base_method}(*opts)
-          send :#{extend_method}, *opts
-          send :#{alias_name}, *opts
+          __send__ :#{extend_method}, *opts
+          __send__ :#{alias_name}, *opts
         end
       ]
     end
@@ -307,8 +311,8 @@ module IRB # :nodoc:
       module_eval %[
         alias_method alias_name, base_method
         def #{base_method}(*opts)
-          send :#{alias_name}, *opts
-          send :#{extend_method}, *opts
+          __send__ :#{alias_name}, *opts
+          __send__ :#{extend_method}, *opts
         end
       ]
     end

data/lib/irb/init.rb

@@ -52,7 +52,6 @@ module IRB # :nodoc:
     @CONF[:IGNORE_EOF] = false
     @CONF[:ECHO] = nil
     @CONF[:ECHO_ON_ASSIGNMENT] = nil
-    @CONF[:OMIT_ON_ASSIGNMENT] = nil
     @CONF[:VERBOSE] = nil
 
     @CONF[:EVAL_HISTORY] = nil
@@ -109,14 +108,79 @@ module IRB # :nodoc:
     @CONF[:PROMPT_MODE] = (STDIN.tty? ? :DEFAULT : :NULL)
     @CONF[:AUTO_INDENT] = true
 
-    @CONF[:CONTEXT_MODE] = 3 # use binding in function on TOPLEVEL_BINDING
+    @CONF[:CONTEXT_MODE] = 4 # use a copy of TOPLEVEL_BINDING
     @CONF[:SINGLE_IRB] = false
 
+    @CONF[:MEASURE] = false
+    @CONF[:MEASURE_PROC] = {}
+    @CONF[:MEASURE_PROC][:TIME] = proc { |context, code, line_no, &block|
+      time = Time.now
+      result = block.()
+      now = Time.now
+      puts 'processing time: %fs' % (now - time) if IRB.conf[:MEASURE]
+      result
+    }
+    @CONF[:MEASURE_PROC][:STACKPROF] = proc { |context, code, line_no, arg, &block|
+      success = false
+      begin
+        require 'stackprof'
+        success = true
+      rescue LoadError
+        puts 'Please run "gem install stackprof" before measuring by StackProf.'
+      end
+      if success
+        result = nil
+        stackprof_result = StackProf.run(mode: arg ? arg : :cpu) do
+          result = block.()
+        end
+        StackProf::Report.new(stackprof_result).print_text if IRB.conf[:MEASURE]
+        result
+      else
+        block.()
+      end
+    }
+    @CONF[:MEASURE_CALLBACKS] = []
+
     @CONF[:LC_MESSAGES] = Locale.new
 
     @CONF[:AT_EXIT] = []
   end
 
+  def IRB.set_measure_callback(type = nil, arg = nil)
+    added = nil
+    if type
+      type_sym = type.upcase.to_sym
+      if IRB.conf[:MEASURE_PROC][type_sym]
+        added = [type_sym, IRB.conf[:MEASURE_PROC][type_sym], arg]
+      end
+    elsif IRB.conf[:MEASURE_PROC][:CUSTOM]
+      added = [:CUSTOM, IRB.conf[:MEASURE_PROC][:CUSTOM], arg]
+    else
+      added = [:TIME, IRB.conf[:MEASURE_PROC][:TIME], arg]
+    end
+    if added
+      found = IRB.conf[:MEASURE_CALLBACKS].find{ |m| m[0] == added[0] && m[2] == added[2] }
+      if found
+        # already added
+        nil
+      else
+        IRB.conf[:MEASURE_CALLBACKS] << added if added
+        added
+      end
+    else
+      nil
+    end
+  end
+
+  def IRB.unset_measure_callback(type = nil)
+    if type.nil?
+      IRB.conf[:MEASURE_CALLBACKS].clear
+    else
+      type_sym = type.upcase.to_sym
+      IRB.conf[:MEASURE_CALLBACKS].reject!{ |t, | t == type_sym }
+    end
+  end
+
   def IRB.init_error
     @CONF[:LC_MESSAGES].load("irb/error.rb")
   end
@@ -132,7 +196,7 @@ module IRB # :nodoc:
         $DEBUG = true
         $VERBOSE = true
       when "-w"
-        $VERBOSE = true
+        Warning[:deprecated] = $VERBOSE = true
       when /^-W(.+)?/
         opt = $1 || argv.shift
         case opt
@@ -141,7 +205,7 @@ module IRB # :nodoc:
         when "1"
           $VERBOSE = false
         else
-          $VERBOSE = true
+          Warning[:deprecated] = $VERBOSE = true
         end
       when /^-r(.+)?/
         opt = $1 || argv.shift
@@ -178,10 +242,8 @@ module IRB # :nodoc:
         @CONF[:ECHO_ON_ASSIGNMENT] = true
       when "--noecho-on-assignment"
         @CONF[:ECHO_ON_ASSIGNMENT] = false
-      when "--omit-on-assignment"
-        @CONF[:OMIT_ON_ASSIGNMENT] = true
-      when "--noomit-on-assignment"
-        @CONF[:OMIT_ON_ASSIGNMENT] = false
+      when "--truncate-echo-on-assignment"
+        @CONF[:ECHO_ON_ASSIGNMENT] = :truncate
       when "--verbose"
         @CONF[:VERBOSE] = true
       when "--noverbose"

data/lib/irb/input-method.rb

@@ -83,7 +83,15 @@ module IRB
     #
     # See IO#eof? for more information.
     def eof?
-      @stdin.eof?
+      rs, = IO.select([@stdin], [], [], 0.00001)
+      if rs and rs[0]
+        c = @stdin.getc
+        result = c.nil? ? true : false
+        @stdin.ungetc(c) unless c.nil?
+        result
+      else # buffer is empty
+        false
+      end
     end
 
     # Whether this input method is still readable when there is no more data to

data/lib/irb/inspector.rb

@@ -100,29 +100,27 @@ module IRB # :nodoc:
     # Proc to call when the input is evaluated and output in irb.
     def inspect_value(v)
       @inspect.call(v)
+    rescue
+      puts "(Object doesn't support #inspect)"
+      ''
     end
   end
 
   Inspector.def_inspector([false, :to_s, :raw]){|v| v.to_s}
-  Inspector.def_inspector([true, :p, :inspect]){|v|
-    begin
-      result = v.inspect
-      if IRB.conf[:MAIN_CONTEXT]&.use_colorize? && Color.inspect_colorable?(v)
-        result = Color.colorize_code(result)
-      end
-      result
-    rescue NoMethodError
-      puts "(Object doesn't support #inspect)"
-      ''
-    end
-  }
-  Inspector.def_inspector([:pp, :pretty_inspect], proc{require "pp"}){|v|
-    result = v.pretty_inspect.chomp
+  Inspector.def_inspector([:p, :inspect]){|v|
+    result = v.inspect
     if IRB.conf[:MAIN_CONTEXT]&.use_colorize? && Color.inspect_colorable?(v)
       result = Color.colorize_code(result)
     end
     result
   }
+  Inspector.def_inspector([true, :pp, :pretty_inspect], proc{require "irb/color_printer"}){|v|
+    if IRB.conf[:MAIN_CONTEXT]&.use_colorize?
+      IRB::ColorPrinter.pp(v, '').chomp
+    else
+      v.pretty_inspect.chomp
+    end
+  }
   Inspector.def_inspector([:yaml, :YAML], proc{require "yaml"}){|v|
     begin
       YAML.dump(v)

data/lib/irb/ruby-lex.rb

@@ -60,11 +60,31 @@ class RubyLex
       @io.dynamic_prompt do |lines|
         lines << '' if lines.empty?
         result = []
-        lines.each_index { |i|
-          c = lines[0..i].map{ |l| l + "\n" }.join
-          ltype, indent, continue, code_block_open = check_state(c)
-          result << @prompt.call(ltype, indent, continue || code_block_open, @line_no + i)
-        }
+        tokens = ripper_lex_without_warning(lines.map{ |l| l + "\n" }.join)
+        code = String.new
+        partial_tokens = []
+        unprocessed_tokens = []
+        line_num_offset = 0
+        tokens.each do |t|
+          partial_tokens << t
+          unprocessed_tokens << t
+          if t[2].include?("\n")
+            t_str = t[2]
+            t_str.each_line("\n") do |s|
+              code << s << "\n"
+              ltype, indent, continue, code_block_open = check_state(code, partial_tokens)
+              result << @prompt.call(ltype, indent, continue || code_block_open, @line_no + line_num_offset)
+              line_num_offset += 1
+            end
+            unprocessed_tokens = []
+          else
+            code << t[2]
+          end
+        end
+        unless unprocessed_tokens.empty?
+          ltype, indent, continue, code_block_open = check_state(code, unprocessed_tokens)
+          result << @prompt.call(ltype, indent, continue || code_block_open, @line_no + line_num_offset)
+        end
         result
       end
     end
@@ -86,24 +106,72 @@ class RubyLex
     end
   end
 
+  ERROR_TOKENS = [
+    :on_parse_error,
+    :compile_error,
+    :on_assign_error,
+    :on_alias_error,
+    :on_class_name_error,
+    :on_param_error
+  ]
+
   def ripper_lex_without_warning(code)
     verbose, $VERBOSE = $VERBOSE, nil
     tokens = nil
     self.class.compile_with_errors_suppressed(code) do |inner_code, line_no|
-      tokens = Ripper.lex(inner_code, '-', line_no)
+      lexer = Ripper::Lexer.new(inner_code, '-', line_no)
+      if lexer.respond_to?(:scan) # Ruby 2.7+
+        tokens = []
+        pos_to_index = {}
+        lexer.scan.each do |t|
+          if pos_to_index.has_key?(t[0])
+            index = pos_to_index[t[0]]
+            found_tk = tokens[index]
+            if ERROR_TOKENS.include?(found_tk[1]) && !ERROR_TOKENS.include?(t[1])
+              tokens[index] = t
+            end
+          else
+            pos_to_index[t[0]] = tokens.size
+            tokens << t
+          end
+        end
+      else
+        tokens = lexer.parse
+      end
     end
-    $VERBOSE = verbose
     tokens
+  ensure
+    $VERBOSE = verbose
+  end
+
+  def find_prev_spaces(line_index)
+    return 0 if @tokens.size == 0
+    md = @tokens[0][2].match(/(\A +)/)
+    prev_spaces = md.nil? ? 0 : md[1].count(' ')
+    line_count = 0
+    @tokens.each_with_index do |t, i|
+      if t[2].include?("\n")
+        line_count += t[2].count("\n")
+        if line_count >= line_index
+          return prev_spaces
+        end
+        if (@tokens.size - 1) > i
+          md = @tokens[i + 1][2].match(/(\A +)/)
+          prev_spaces = md.nil? ? 0 : md[1].count(' ')
+        end
+      end
+    end
+    prev_spaces
   end
 
   def set_auto_indent(context)
     if @io.respond_to?(:auto_indent) and context.auto_indent_mode
       @io.auto_indent do |lines, line_index, byte_pointer, is_newline|
         if is_newline
-          md = lines[line_index - 1].match(/(\A +)/)
-          prev_spaces = md.nil? ? 0 : md[1].count(' ')
           @tokens = ripper_lex_without_warning(lines[0..line_index].join("\n"))
+          prev_spaces = find_prev_spaces(line_index)
           depth_difference = check_newline_depth_difference
+          depth_difference = 0 if depth_difference < 0
           prev_spaces + depth_difference * 2
         else
           code = line_index.zero? ? '' : lines[0..(line_index - 1)].map{ |l| l + "\n" }.join
@@ -121,12 +189,12 @@ class RubyLex
     end
   end
 
-  def check_state(code)
-    @tokens = ripper_lex_without_warning(code)
-    ltype = process_literal_type
-    indent = process_nesting_level
-    continue = process_continue
-    code_block_open = check_code_block(code)
+  def check_state(code, tokens = nil)
+    tokens = ripper_lex_without_warning(code) unless tokens
+    ltype = process_literal_type(tokens)
+    indent = process_nesting_level(tokens)
+    continue = process_continue(tokens)
+    code_block_open = check_code_block(code, tokens)
     [ltype, indent, continue, code_block_open]
   end
 
@@ -193,40 +261,45 @@ class RubyLex
     line
   end
 
-  def process_continue
+  def process_continue(tokens = @tokens)
     # last token is always newline
-    if @tokens.size >= 2 and @tokens[-2][1] == :on_regexp_end
+    if tokens.size >= 2 and tokens[-2][1] == :on_regexp_end
       # end of regexp literal
       return false
-    elsif @tokens.size >= 2 and @tokens[-2][1] == :on_semicolon
+    elsif tokens.size >= 2 and tokens[-2][1] == :on_semicolon
       return false
-    elsif @tokens.size >= 2 and @tokens[-2][1] == :on_kw and ['begin', 'else', 'ensure'].include?(@tokens[-2][2])
+    elsif tokens.size >= 2 and tokens[-2][1] == :on_kw and ['begin', 'else', 'ensure'].include?(tokens[-2][2])
       return false
-    elsif !@tokens.empty? and @tokens.last[2] == "\\\n"
+    elsif !tokens.empty? and tokens.last[2] == "\\\n"
       return true
-    elsif @tokens.size >= 1 and @tokens[-1][1] == :on_heredoc_end # "EOH\n"
+    elsif tokens.size >= 1 and tokens[-1][1] == :on_heredoc_end # "EOH\n"
       return false
-    elsif @tokens.size >= 2 and defined?(Ripper::EXPR_BEG) and @tokens[-2][3].anybits?(Ripper::EXPR_BEG | Ripper::EXPR_FNAME)
+    elsif tokens.size >= 2 and defined?(Ripper::EXPR_BEG) and tokens[-2][3].anybits?(Ripper::EXPR_BEG | Ripper::EXPR_FNAME)
       # end of literal except for regexp
       return true
     end
     false
   end
 
-  def check_code_block(code)
-    return true if @tokens.empty?
-    if @tokens.last[1] == :on_heredoc_beg
+  def check_code_block(code, tokens = @tokens)
+    return true if tokens.empty?
+    if tokens.last[1] == :on_heredoc_beg
       return true
     end
 
     begin # check if parser error are available
       verbose, $VERBOSE = $VERBOSE, nil
       case RUBY_ENGINE
+      when 'ruby'
+        self.class.compile_with_errors_suppressed(code) do |inner_code, line_no|
+          RubyVM::InstructionSequence.compile(inner_code, nil, nil, line_no)
+        end
       when 'jruby'
         JRuby.compile_ir(code)
       else
-        self.class.compile_with_errors_suppressed(code) do |inner_code, line_no|
-          RubyVM::InstructionSequence.compile(inner_code, nil, nil, line_no)
+        catch(:valid) do
+          eval("BEGIN { throw :valid, true }\n#{code}")
+          false
         end
       end
     rescue EncodingError
@@ -282,7 +355,7 @@ class RubyLex
     end
 
     if defined?(Ripper::EXPR_BEG)
-      last_lex_state = @tokens.last[3]
+      last_lex_state = tokens.last[3]
       if last_lex_state.allbits?(Ripper::EXPR_BEG)
         return false
       elsif last_lex_state.allbits?(Ripper::EXPR_DOT)
@@ -301,10 +374,10 @@ class RubyLex
     false
   end
 
-  def process_nesting_level
+  def process_nesting_level(tokens = @tokens)
     indent = 0
     in_oneliner_def = nil
-    @tokens.each_with_index { |t, index|
+    tokens.each_with_index { |t, index|
       # detecting one-liner method definition
       if in_oneliner_def.nil?
         if t[3].allbits?(Ripper::EXPR_ENDFN)
@@ -317,14 +390,12 @@ class RubyLex
           if t[2] == '='
             in_oneliner_def = :BODY
           end
-        elsif t[3].allbits?(Ripper::EXPR_END)
+        else
           if in_oneliner_def == :BODY
             # one-liner method definition
             indent -= 1
           end
           in_oneliner_def = nil
-        else
-          in_oneliner_def = nil
         end
       end
 
@@ -334,17 +405,11 @@ class RubyLex
       when :on_rbracket, :on_rbrace, :on_rparen
         indent -= 1
       when :on_kw
-        next if index > 0 and @tokens[index - 1][3].allbits?(Ripper::EXPR_FNAME)
+        next if index > 0 and tokens[index - 1][3].allbits?(Ripper::EXPR_FNAME)
         case t[2]
         when 'do'
-          if index > 0 and @tokens[index - 1][3].anybits?(Ripper::EXPR_CMDARG | Ripper::EXPR_ENDFN | Ripper::EXPR_ARG)
-            # method_with_block do; end
-            indent += 1
-          else
-            # while cond do; end # also "until" or "for"
-            # This "do" doesn't increment indent because "while" already
-            # incremented.
-          end
+          syntax_of_do = take_corresponding_syntax_to_kw_do(tokens, index)
+          indent += 1 if syntax_of_do == :method_calling
         when 'def', 'case', 'for', 'begin', 'class', 'module'
           indent += 1
         when 'if', 'unless', 'while', 'until'
@@ -359,6 +424,40 @@ class RubyLex
     indent
   end
 
+  def take_corresponding_syntax_to_kw_do(tokens, index)
+    syntax_of_do = nil
+    # Finding a syntax correnponding to "do".
+    index.downto(0) do |i|
+      tk = tokens[i]
+      # In "continue", the token isn't the corresponding syntax to "do".
+      #is_continue = process_continue(@tokens[0..(i - 1)])
+      # continue ではなく、直前に (:on_ignored_nl|:on_nl|:on_comment):on_sp* みたいなのがあるかどうかを調べる
+      non_sp_index = tokens[0..(i - 1)].rindex{ |t| t[1] != :on_sp }
+      first_in_fomula = false
+      if non_sp_index.nil?
+        first_in_fomula = true
+      elsif [:on_ignored_nl, :on_nl, :on_comment].include?(tokens[non_sp_index][1])
+        first_in_fomula = true
+      end
+      if tk[3].anybits?(Ripper::EXPR_CMDARG) and tk[1] == :on_ident
+        # The target method call to pass the block with "do".
+        syntax_of_do = :method_calling
+        break if first_in_fomula
+      elsif tk[1] == :on_kw && %w{while until for}.include?(tk[2])
+        # A loop syntax in front of "do" found.
+        #
+        #   while cond do # also "until" or "for"
+        #   end
+        #
+        # This "do" doesn't increment indent because the loop syntax already
+        # incremented.
+        syntax_of_do = :loop_syntax
+        break if first_in_fomula
+      end
+    end
+    syntax_of_do
+  end
+
   def check_newline_depth_difference
     depth_difference = 0
     open_brace_on_line = 0
@@ -376,20 +475,18 @@ class RubyLex
           if t[2] == '='
             in_oneliner_def = :BODY
           end
-        elsif t[3].allbits?(Ripper::EXPR_END)
+        else
           if in_oneliner_def == :BODY
-            # one[-liner method definition
+            # one-liner method definition
             depth_difference -= 1
           end
           in_oneliner_def = nil
-        else
-          in_oneliner_def = nil
         end
       end
 
       case t[1]
       when :on_ignored_nl, :on_nl, :on_comment
-        if index != (@tokens.size - 1)
+        if index != (@tokens.size - 1) and in_oneliner_def != :BODY
           depth_difference = 0
           open_brace_on_line = 0
         end
@@ -407,14 +504,8 @@ class RubyLex
         next if index > 0 and @tokens[index - 1][3].allbits?(Ripper::EXPR_FNAME)
         case t[2]
         when 'do'
-          if index > 0 and @tokens[index - 1][3].anybits?(Ripper::EXPR_CMDARG | Ripper::EXPR_ENDFN | Ripper::EXPR_ARG)
-            # method_with_block do; end
-            depth_difference += 1
-          else
-            # while cond do; end # also "until" or "for"
-            # This "do" doesn't increment indent because "while" already
-            # incremented.
-          end
+          syntax_of_do = take_corresponding_syntax_to_kw_do(@tokens, index)
+          depth_difference += 1 if syntax_of_do == :method_calling
         when 'def', 'case', 'for', 'begin', 'class', 'module'
           depth_difference += 1
         when 'if', 'unless', 'while', 'until', 'rescue'
@@ -424,6 +515,8 @@ class RubyLex
           end
         when 'else', 'elsif', 'ensure', 'when', 'in'
           depth_difference += 1
+        when 'end'
+          depth_difference -= 1
         end
       end
     end
@@ -451,7 +544,7 @@ class RubyLex
           if t[2] == '='
             in_oneliner_def = :BODY
           end
-        elsif t[3].allbits?(Ripper::EXPR_END)
+        else
           if in_oneliner_def == :BODY
             # one-liner method definition
             if is_first_printable_of_line
@@ -462,18 +555,18 @@ class RubyLex
             end
           end
           in_oneliner_def = nil
-        else
-          in_oneliner_def = nil
         end
       end
 
       case t[1]
       when :on_ignored_nl, :on_nl, :on_comment
-        corresponding_token_depth = nil
-        spaces_at_line_head = 0
-        is_first_spaces_of_line = true
-        is_first_printable_of_line = true
-        open_brace_on_line = 0
+        if in_oneliner_def != :BODY
+          corresponding_token_depth = nil
+          spaces_at_line_head = 0
+          is_first_spaces_of_line = true
+          is_first_printable_of_line = true
+          open_brace_on_line = 0
+        end
         next
       when :on_sp
         spaces_at_line_head = t[2].count(' ') if is_first_spaces_of_line
@@ -495,7 +588,12 @@ class RubyLex
       when :on_kw
         next if index > 0 and @tokens[index - 1][3].allbits?(Ripper::EXPR_FNAME)
         case t[2]
-        when 'def', 'do', 'case', 'for', 'begin', 'class', 'module'
+        when 'do'
+          syntax_of_do = take_corresponding_syntax_to_kw_do(@tokens, index)
+          if syntax_of_do == :method_calling
+            spaces_of_nest.push(spaces_at_line_head)
+          end
+        when 'def', 'case', 'for', 'begin', 'class', 'module'
           spaces_of_nest.push(spaces_at_line_head)
         when 'rescue'
           unless t[3].allbits?(Ripper::EXPR_LABEL)
@@ -523,12 +621,12 @@ class RubyLex
     corresponding_token_depth
   end
 
-  def check_string_literal
+  def check_string_literal(tokens)
     i = 0
     start_token = []
     end_type = []
-    while i < @tokens.size
-      t = @tokens[i]
+    while i < tokens.size
+      t = tokens[i]
       case t[1]
       when :on_tstring_beg
         start_token << t
@@ -538,7 +636,7 @@ class RubyLex
         end_type << :on_regexp_end
       when :on_symbeg
         acceptable_single_tokens = %i{on_ident on_const on_op on_cvar on_ivar on_gvar on_kw}
-        if (i + 1) < @tokens.size and acceptable_single_tokens.all?{ |t| @tokens[i + 1][1] != t }
+        if (i + 1) < tokens.size and acceptable_single_tokens.all?{ |st| tokens[i + 1][1] != st }
           start_token << t
           end_type << :on_tstring_end
         end
@@ -560,8 +658,8 @@ class RubyLex
     start_token.last.nil? ? '' : start_token.last
   end
 
-  def process_literal_type
-    start_token = check_string_literal
+  def process_literal_type(tokens = @tokens)
+    start_token = check_string_literal(tokens)
     case start_token[1]
     when :on_tstring_beg
       case start_token[2]

data/lib/irb/version.rb

@@ -11,7 +11,7 @@
 #
 
 module IRB # :nodoc:
-  VERSION = "1.2.6"
+  VERSION = "1.3.1"
   @RELEASE_VERSION = VERSION
-  @LAST_UPDATE_DATE = "2020-09-14"
+  @LAST_UPDATE_DATE = "2021-01-12"
 end

data/lib/irb/workspace.rb

@@ -51,11 +51,13 @@ EOF
           end
           @binding = BINDING_QUEUE.pop
 
-        when 3	# binding in function on TOPLEVEL_BINDING(default)
-          @binding = eval("self.class.send(:remove_method, :irb_binding) if defined?(irb_binding); private; def irb_binding; binding; end; irb_binding",
+        when 3	# binding in function on TOPLEVEL_BINDING
+          @binding = eval("self.class.remove_method(:irb_binding) if defined?(irb_binding); private; def irb_binding; binding; end; irb_binding",
                           TOPLEVEL_BINDING,
                           __FILE__,
                           __LINE__ - 3)
+        when 4  # binding is a copy of TOPLEVEL_BINDING (default)
+          @binding = TOPLEVEL_BINDING.dup
         end
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: irb
 version: !ruby/object:Gem::Version
-  version: 1.2.6
+  version: 1.3.1
 platform: ruby
 authors:
 - Keiju ISHITSUKA
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-09-13 00:00:00.000000000 Z
+date: 2021-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: reline
@@ -76,10 +76,12 @@ files:
 - lib/irb/cmd/fork.rb
 - lib/irb/cmd/help.rb
 - lib/irb/cmd/load.rb
+- lib/irb/cmd/measure.rb
 - lib/irb/cmd/nop.rb
 - lib/irb/cmd/pushws.rb
 - lib/irb/cmd/subirb.rb
 - lib/irb/color.rb
+- lib/irb/color_printer.rb
 - lib/irb/completion.rb
 - lib/irb/context.rb
 - lib/irb/easter-egg.rb
@@ -134,7 +136,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: Interactive Ruby command-line tool for REPL (Read Eval Print Loop).