irb 1.3.3 → 1.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd13d45b58713bde6589b963fc6d2a93c166d340aaba132c9b7981ffe88062cb
-  data.tar.gz: 56d4e5c73fb369f36cc34bbda1462492a0db7b7393f9b3e15a4e1a54e2ad1ec7
+  metadata.gz: ddb63fc9d57700014a7da313e20504596ca42dfee0952547fa545d726f08d7d6
+  data.tar.gz: cc4ee2f880d56dc7f792ecc406f489f8555601d19499f45d8f8828cc260ed1b0
 SHA512:
-  metadata.gz: cd6725cf6479552499418c3a93058ef9adb471f44fff49bd30d382e6c534dac1aa43086d002a93b06a856c2bffd5d5decdd2a79c1e9b3d31c344ecccf6cfc60f
-  data.tar.gz: 064efe186e582ca440903e98f7b2b5cfab38867c7f3812ffe6f2e8bd1bc3c01b64ca4828c9d38ba26c0b9d6c7ceba76f4e1974484527a9ba6cbea249970cb067
+  metadata.gz: c5b128b8ce5457862489e313231af33167802619c3847da526dda30c83f7fc96d1a248d2916e17da4cbd45f8d30aee8c181237182b97b5741cf4bc4c13568bfb
+  data.tar.gz: 61147b2b4e76f34076043feaa84feeb2e893a140d3d7d1e5013a00f87f27f694802f8ae21788709a7ee03c5b41ee445735aec93bfedbeaa9fcf02d6bf06f705d

data/Gemfile

@@ -3,3 +3,13 @@ source "https://rubygems.org"
 git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
 gemspec
+
+group :development do
+  gem "bundler"
+  is_unix = RUBY_PLATFORM =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris|irix|hpux)/i
+  is_truffleruby = RUBY_DESCRIPTION =~ /truffleruby/
+  gem 'vterm', '>= 0.0.5' if is_unix && ENV['WITH_VTERM']
+  gem 'yamatanooroti', '>= 0.0.6'
+  gem "rake"
+  gem "stackprof" if is_unix && !is_truffleruby
+end

data/Rakefile

@@ -4,7 +4,14 @@ require "rake/testtask"
 Rake::TestTask.new(:test) do |t|
   t.libs << "test" << "test/lib"
   t.libs << "lib"
-  t.test_files = FileList["test/**/test_*.rb"]
+  t.test_files = FileList["test/irb/test_*.rb"]
+end
+
+Rake::TestTask.new(:test_yamatanooroti) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  #t.loader = :direct
+  t.pattern = 'test/irb/yamatanooroti/test_*.rb'
 end
 
 task :default => :test

data/irb.gemspec

@@ -28,60 +28,13 @@ Gem::Specification.new do |spec|
     "doc/irb/irb.rd.ja",
     "exe/irb",
     "irb.gemspec",
-    "lib/irb.rb",
-    "lib/irb/cmd/chws.rb",
-    "lib/irb/cmd/fork.rb",
-    "lib/irb/cmd/help.rb",
-    "lib/irb/cmd/info.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",
-    "lib/irb/ext/change-ws.rb",
-    "lib/irb/ext/history.rb",
-    "lib/irb/ext/loader.rb",
-    "lib/irb/ext/multi-irb.rb",
-    "lib/irb/ext/save-history.rb",
-    "lib/irb/ext/tracer.rb",
-    "lib/irb/ext/use-loader.rb",
-    "lib/irb/ext/workspaces.rb",
-    "lib/irb/extend-command.rb",
-    "lib/irb/frame.rb",
-    "lib/irb/help.rb",
-    "lib/irb/init.rb",
-    "lib/irb/input-method.rb",
-    "lib/irb/inspector.rb",
-    "lib/irb/lc/error.rb",
-    "lib/irb/lc/help-message",
-    "lib/irb/lc/ja/encoding_aliases.rb",
-    "lib/irb/lc/ja/error.rb",
-    "lib/irb/lc/ja/help-message",
-    "lib/irb/locale.rb",
-    "lib/irb/magic-file.rb",
-    "lib/irb/notifier.rb",
-    "lib/irb/output-method.rb",
-    "lib/irb/ruby-lex.rb",
-    "lib/irb/ruby_logo.aa",
-    "lib/irb/src_encoding.rb",
-    "lib/irb/version.rb",
-    "lib/irb/workspace.rb",
-    "lib/irb/ws-for-case-2.rb",
-    "lib/irb/xmp.rb",
     "man/irb.1",
-  ]
+  ] + Dir.glob("lib/**/*")
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
   spec.required_ruby_version = Gem::Requirement.new(">= 2.5")
 
-  spec.add_dependency "reline", ">= 0.1.5"
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake"
+  spec.add_dependency "reline", ">= 0.2.7"
 end

data/lib/irb.rb

@@ -60,7 +60,11 @@ require_relative "irb/easter-egg"
 #     -E enc            Same as `ruby -E`
 #     -w                Same as `ruby -w`
 #     -W[level=2]       Same as `ruby -W`
-#     --inspect         Use `inspect' for output (default except for bc mode)
+#     --context-mode n  Set n[0-4] to method to create Binding Object,
+#                       when new workspace was created
+#     --echo            Show result(default)
+#     --noecho          Don't show result
+#     --inspect         Use `inspect' for output
 #     --noinspect       Don't use inspect for output
 #     --multiline       Use multiline editor module
 #     --nomultiline     Don't use multiline editor module
@@ -68,19 +72,24 @@ require_relative "irb/easter-egg"
 #     --nosingleline    Don't use singleline editor module
 #     --colorize        Use colorization
 #     --nocolorize      Don't use colorization
-#     --prompt prompt-mode
-#     --prompt-mode prompt-mode
+#     --prompt prompt-mode/--prompt-mode prompt-mode
 #                       Switch prompt mode. Pre-defined prompt modes are
 #                       `default', `simple', `xmp' and `inf-ruby'
 #     --inf-ruby-mode   Use prompt appropriate for inf-ruby-mode on emacs.
 #                       Suppresses --multiline and --singleline.
-#     --simple-prompt   Simple prompt mode
+#     --sample-book-mode/--simple-prompt
+#                       Simple prompt mode
 #     --noprompt        No prompt mode
+#     --single-irb      Share self with sub-irb.
 #     --tracer          Display trace for each execution of commands.
 #     --back-trace-limit n
 #                       Display backtrace top n and tail n. The default
 #                       value is 16.
-#     -v, --version     Print the version of irb
+#     --verbose         Show details
+#     --noverbose       Don't show details
+#     -v, --version	    Print the version of irb
+#     -h, --help        Print help
+#     --                Separate options of irb from the list of command-line args
 #
 # == Configuration
 #
@@ -463,7 +472,7 @@ module IRB
       conf[:IRB_RC].call(context) if conf[:IRB_RC]
       conf[:MAIN_CONTEXT] = context
 
-      trap("SIGINT") do
+      prev_trap = trap("SIGINT") do
         signal_handle
       end
 
@@ -472,6 +481,7 @@ module IRB
           eval_input
         end
       ensure
+        trap("SIGINT", prev_trap)
         conf[:AT_EXIT].each{|hook| hook.call}
       end
     end
@@ -514,7 +524,7 @@ module IRB
         @context.io.prompt
       end
 
-      @scanner.set_input(@context.io) do
+      @scanner.set_input(@context.io, context: @context) do
         signal_status(:IN_INPUT) do
           if l = @context.io.gets
             print l if @context.verbose?
@@ -580,9 +590,15 @@ 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)
+    def convert_invalid_byte_sequence(str, enc)
+      str.force_encoding(enc)
+      str.scrub { |c|
+        c.bytes.map{ |b| "\\x#{b.to_s(16).upcase}" }.join
+      }
+    end
+
+    def encode_with_invalid_byte_sequence(str, enc)
+      conv = Encoding::Converter.new(str.encoding, enc)
       dst = String.new
       begin
         ret = conv.primitive_convert(str, dst)
@@ -630,7 +646,8 @@ module IRB
           message = exc.full_message(order: :top)
           order = :top
         end
-        message = convert_invalid_byte_sequence(message)
+        message = convert_invalid_byte_sequence(message, exc.message.encoding)
+        message = encode_with_invalid_byte_sequence(message, IRB.conf[:LC_MESSAGES].encoding) unless message.encoding.to_s.casecmp?(IRB.conf[:LC_MESSAGES].encoding.to_s)
         message = message.gsub(/((?:^\t.+$\n)+)/)  { |m|
           case order
           when :top

data/lib/irb/cmd/info.rb

@@ -13,6 +13,13 @@ module IRB
             str += "IRB version: #{IRB.version}\n"
             str += "InputMethod: #{IRB.CurrentContext.io.inspect}\n"
             str += ".irbrc path: #{IRB.rc_file}\n" if File.exist?(IRB.rc_file)
+            str += "RUBY_PLATFORM: #{RUBY_PLATFORM}\n"
+            str += "LANG env: #{ENV["LANG"]}\n" if ENV["LANG"] && !ENV["LANG"].empty?
+            str += "LC_ALL env: #{ENV["LC_ALL"]}\n" if ENV["LC_ALL"] && !ENV["LC_ALL"].empty?
+            if RbConfig::CONFIG['host_os'] =~ /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+              codepage = `chcp`.sub(/.*: (\d+)\n/, '\1')
+              str += "Code page: #{codepage}\n"
+            end
             str
           end
           alias_method :to_s, :inspect

data/lib/irb/cmd/ls.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "reline"
+require_relative "nop"
+require_relative "../color"
+
+# :stopdoc:
+module IRB
+  module ExtendCommand
+    class Ls < Nop
+      def execute(*arg, grep: nil)
+        o = Output.new(grep: grep)
+
+        obj    = arg.empty? ? irb_context.workspace.main : arg.first
+        locals = arg.empty? ? irb_context.workspace.binding.local_variables : []
+        klass  = (obj.class == Class || obj.class == Module ? obj : obj.class)
+
+        o.dump("constants", obj.constants) if obj.respond_to?(:constants)
+        dump_methods(o, klass, obj)
+        o.dump("instance variables", obj.instance_variables)
+        o.dump("class variables", klass.class_variables)
+        o.dump("locals", locals)
+      end
+
+      def dump_methods(o, klass, obj)
+        singleton_class = begin obj.singleton_class; rescue TypeError; nil end
+        maps = class_method_map((singleton_class || klass).ancestors)
+        maps.each do |mod, methods|
+          name = mod == singleton_class ? "#{klass}.methods" : "#{mod}#methods"
+          o.dump(name, methods)
+        end
+      end
+
+      def class_method_map(classes)
+        dumped = Array.new
+        classes.reject { |mod| mod >= Object }.map do |mod|
+          methods = mod.public_instance_methods(false).select do |m|
+            dumped.push(m) unless dumped.include?(m)
+          end
+          [mod, methods]
+        end.reverse
+      end
+
+      class Output
+        MARGIN = "  "
+
+        def initialize(grep: nil)
+          @grep = grep
+          @line_width = screen_width - MARGIN.length # right padding
+        end
+
+        def dump(name, strs)
+          strs = strs.grep(@grep) if @grep
+          strs = strs.sort
+          return if strs.empty?
+
+          # Attempt a single line
+          print "#{Color.colorize(name, [:BOLD, :BLUE])}: "
+          if fits_on_line?(strs, cols: strs.size, offset: "#{name}: ".length)
+            puts strs.join(MARGIN)
+            return
+          end
+          puts
+
+          # Dump with the largest # of columns that fits on a line
+          cols = strs.size
+          until fits_on_line?(strs, cols: cols, offset: MARGIN.length) || cols == 1
+            cols -= 1
+          end
+          widths = col_widths(strs, cols: cols)
+          strs.each_slice(cols) do |ss|
+            puts ss.map.with_index { |s, i| "#{MARGIN}%-#{widths[i]}s" % s }.join
+          end
+        end
+
+        private
+
+        def fits_on_line?(strs, cols:, offset: 0)
+          width = col_widths(strs, cols: cols).sum + MARGIN.length * (cols - 1)
+          width <= @line_width - offset
+        end
+
+        def col_widths(strs, cols:)
+          cols.times.map do |col|
+            (col...strs.size).step(cols).map do |i|
+              strs[i].length
+            end.max
+          end
+        end
+
+        def screen_width
+          Reline.get_screen_size.last
+        rescue Errno::EINVAL # in `winsize': Invalid argument - <STDIN>
+          80
+        end
+      end
+      private_constant :Output
+    end
+  end
+end
+# :startdoc:

data/lib/irb/cmd/measure.rb

@@ -9,6 +9,9 @@ module IRB
       end
 
       def execute(type = nil, arg = nil, &block)
+        # Please check IRB.init_config in lib/irb/init.rb that sets
+        # IRB.conf[:MEASURE_PROC] to register default "measure" methods,
+        # "measure :time" (abbreviated as "measure") and "measure :stackprof".
         case type
         when :off
           IRB.conf[:MEASURE] = nil

data/lib/irb/cmd/nop.rb

@@ -14,10 +14,16 @@ module IRB
   module ExtendCommand
     class Nop
 
-
-      def self.execute(conf, *opts, &block)
-        command = new(conf)
-        command.execute(*opts, &block)
+      if RUBY_ENGINE == "ruby" && RUBY_VERSION >= "2.7.0"
+        def self.execute(conf, *opts, **kwargs, &block)
+          command = new(conf)
+          command.execute(*opts, **kwargs, &block)
+        end
+      else
+        def self.execute(conf, *opts, &block)
+          command = new(conf)
+          command.execute(*opts, &block)
+        end
       end
 
       def initialize(conf)

data/lib/irb/cmd/show_source.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "nop"
+require_relative "../color"
+require_relative "../ruby-lex"
+
+# :stopdoc:
+module IRB
+  module ExtendCommand
+    class ShowSource < Nop
+      def execute(str = nil)
+        unless str.is_a?(String)
+          puts "Error: Expected a string but got #{str.inspect}"
+          return
+        end
+        source = find_source(str)
+        if source && File.exist?(source.file)
+          show_source(source)
+        else
+          puts "Error: Couldn't locate a definition for #{str}"
+        end
+        nil
+      end
+
+      private
+
+      # @param [IRB::ExtendCommand::ShowSource::Source] source
+      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
+      end
+
+      def find_source(str)
+        case str
+        when /\A[A-Z]\w*(::[A-Z]\w*)*\z/ # Const::Name
+          eval(str, irb_context.workspace.binding) # trigger autoload
+          base = irb_context.workspace.binding.receiver.yield_self { |r| r.is_a?(Module) ? r : Object }
+          file, line = base.const_source_location(str) if base.respond_to?(:const_source_location) # Ruby 2.7+
+        when /\A(?<owner>[A-Z]\w*(::[A-Z]\w*)*)#(?<method>[^ :.]+)\z/ # Class#method
+          owner = eval(Regexp.last_match[:owner], irb_context.workspace.binding)
+          method = Regexp.last_match[:method]
+          if owner.respond_to?(:instance_method) && owner.instance_methods.include?(method.to_sym)
+            file, line = owner.instance_method(method).source_location
+          end
+        when /\A((?<receiver>.+)(\.|::))?(?<method>[^ :.]+)\z/ # method, receiver.method, receiver::method
+          receiver = eval(Regexp.last_match[:receiver] || 'self', irb_context.workspace.binding)
+          method = Regexp.last_match[:method]
+          file, line = receiver.method(method).source_location if receiver.respond_to?(method)
+        end
+        if file && line
+          Source.new(file: file, first_line: line, last_line: find_end(file, line))
+        end
+      end
+
+      def find_end(file, first_line)
+        return first_line unless File.exist?(file)
+        lex = RubyLex.new
+        lines = File.read(file).lines[(first_line - 1)..-1]
+        tokens = RubyLex.ripper_lex_without_warning(lines.join)
+
+        code = +""
+        prev_tokens = []
+
+        # chunk with line number
+        tokens.chunk { |tok| tok[0][0] }.each do |lnum, chunk|
+          code << lines[lnum]
+          prev_tokens.concat chunk
+
+          continue = lex.process_continue(prev_tokens)
+          code_block_open = lex.check_code_block(code, prev_tokens)
+          if !continue && !code_block_open
+            return first_line + lnum
+          end
+        end
+        first_line
+      end
+
+      def bold(str)
+        Color.colorize(str, [:BOLD])
+      end
+
+      Source = Struct.new(
+        :file,       # @param [String] - file name
+        :first_line, # @param [String] - first line
+        :last_line,  # @param [String] - last line
+        keyword_init: true,
+      )
+      private_constant :Source
+    end
+  end
+end
+# :startdoc:

data/lib/irb/cmd/whereami.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "nop"
+
+# :stopdoc:
+module IRB
+  module ExtendCommand
+    class Whereami < Nop
+      def execute(*)
+        code = irb_context.workspace.code_around_binding
+        if code
+          puts code
+        else
+          puts "The current context doesn't have code."
+        end
+      end
+    end
+  end
+end
+# :startdoc:

data/lib/irb/color.rb

@@ -64,6 +64,7 @@ module IRB # :nodoc:
         on_alias_error:     [[RED, REVERSE],          ALL],
         on_class_name_error:[[RED, REVERSE],          ALL],
         on_param_error:     [[RED, REVERSE],          ALL],
+        on___end__:         [[GREEN],                 ALL],
       }
     rescue NameError
       # Give up highlighting Ripper-incompatible older Ruby
@@ -76,7 +77,7 @@ module IRB # :nodoc:
 
     class << self
       def colorable?
-        $stdout.tty? && supported? && (/mswin|mingw/ =~ RUBY_PLATFORM || (ENV.key?('TERM') && ENV['TERM'] != 'dumb'))
+        $stdout.tty? && (/mswin|mingw/ =~ RUBY_PLATFORM || (ENV.key?('TERM') && ENV['TERM'] != 'dumb'))
       end
 
       def inspect_colorable?(obj, seen: {}.compare_by_identity)
@@ -100,26 +101,27 @@ module IRB # :nodoc:
         end
       end
 
-      def clear
-        return '' unless colorable?
+      def clear(colorable: colorable?)
+        return '' unless colorable
         "\e[#{CLEAR}m"
       end
 
-      def colorize(text, seq)
-        return text unless colorable?
+      def colorize(text, seq, colorable: colorable?)
+        return text unless colorable
         seq = seq.map { |s| "\e[#{const_get(s)}m" }.join('')
-        "#{seq}#{text}#{clear}"
+        "#{seq}#{text}#{clear(colorable: colorable)}"
       end
 
       # 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, ignore_error: false)
-        return code unless colorable?
+      def colorize_code(code, complete: true, ignore_error: false, colorable: colorable?)
+        return code unless colorable
 
         symbol_state = SymbolState.new
         colored = +''
         length = 0
+        end_seen = false
 
         scan(code, allow_last_error: !complete) do |token, str, expr|
           # IRB::ColorPrinter skips colorizing fragments with any invalid token
@@ -132,16 +134,17 @@ module IRB # :nodoc:
             line = Reline::Unicode.escape_for_print(line)
             if seq = dispatch_seq(token, expr, line, in_symbol: in_symbol)
               colored << seq.map { |s| "\e[#{s}m" }.join('')
-              colored << line.sub(/\Z/, clear)
+              colored << line.sub(/\Z/, clear(colorable: colorable))
             else
               colored << line
             end
           end
           length += str.bytesize
+          end_seen = true if token == :on___end__
         end
 
         # give up colorizing incomplete Ripper tokens
-        if length != code.bytesize
+        unless end_seen or length == code.bytesize
           return Reline::Unicode.escape_for_print(code)
         end
 
@@ -158,11 +161,6 @@ module IRB # :nodoc:
         seen.delete(obj)
       end
 
-      def supported?
-        return @supported if defined?(@supported)
-        @supported = Ripper::Lexer::Elem.method_defined?(:state)
-      end
-
       def scan(code, allow_last_error:)
         pos = [1, 0]
 

data/lib/irb/color_printer.rb

@@ -21,6 +21,15 @@ module IRB
       end
     end
 
+    def pp(obj)
+      if obj.is_a?(String)
+        # Avoid calling Ruby 2.4+ String#pretty_print that splits a string by "\n"
+        text(obj.inspect)
+      else
+        super
+      end
+    end
+
     def text(str, width = nil)
       unless str.is_a?(String)
         str = str.inspect

data/lib/irb/completion.rb

@@ -7,7 +7,7 @@
 #       From Original Idea of shugo@ruby-lang.org
 #
 
-autoload :RDoc, "rdoc"
+require_relative 'ruby-lex'
 
 module IRB
   module InputCompletor # :nodoc:
@@ -38,8 +38,69 @@ module IRB
 
     BASIC_WORD_BREAK_CHARACTERS = " \t\n`><=;|&{("
 
-    CompletionProc = proc { |input|
-      retrieve_completion_data(input).compact.map{ |i| i.encode(Encoding.default_external) }
+    def self.retrieve_files_to_require_from_load_path
+      @@files_from_load_path ||= $LOAD_PATH.flat_map { |path|
+        begin
+          Dir.glob("**/*.{rb,#{RbConfig::CONFIG['DLEXT']}}", base: path)
+        rescue Errno::ENOENT
+          []
+        end
+      }.uniq.map { |path|
+        path.sub(/\.(rb|#{RbConfig::CONFIG['DLEXT']})\z/, '')
+      }
+    end
+
+    def self.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
+
+    CompletionRequireProc = lambda { |target, preposing = nil, postposing = nil|
+      if target =~ /\A(['"])([^'"]+)\Z/
+        quote = $1
+        actual_target = $2
+      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
+      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
+      end
+      result
+    }
+
+    CompletionProc = lambda { |target, preposing = nil, postposing = nil|
+      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) }
+      end
     }
 
     def self.retrieve_completion_data(input, bind: IRB.conf[:MAIN_CONTEXT].workspace.binding, doc_namespace: false)
@@ -266,13 +327,22 @@ module IRB
     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|

data/lib/irb/ext/loader.rb

@@ -38,9 +38,9 @@ module IRB # :nodoc:
     else
       separator =
         if File::ALT_SEPARATOR
-          File::SEPARATOR
-        else
           "[#{Regexp.quote(File::SEPARATOR + File::ALT_SEPARATOR)}]"
+        else
+          File::SEPARATOR
         end
       ABSOLUTE_PATH_PATTERN = # :nodoc:
         case Dir.pwd

data/lib/irb/ext/save-history.rb

@@ -81,6 +81,8 @@ module IRB
             end
           }
         end
+        @loaded_history_lines = history.size
+        @loaded_history_mtime = File.mtime(history_file)
       end
     end
 
@@ -105,12 +107,20 @@ module IRB
           raise
         end
 
-        open(history_file, "w:#{IRB.conf[:LC_MESSAGES].encoding}", 0600) do |f|
+        if File.exist?(history_file) && @loaded_history_mtime &&
+           File.mtime(history_file) != @loaded_history_mtime
+          history = history[@loaded_history_lines..-1]
+          append_history = true
+        end
+
+        open(history_file, "#{append_history ? 'a' : 'w'}:#{IRB.conf[:LC_MESSAGES].encoding}", 0600) do |f|
           hist = history.map{ |l| l.split("\n").join("\\\n") }
-          begin
-            hist = hist.last(num) if hist.size > num and num > 0
-          rescue RangeError # bignum too big to convert into `long'
-            # Do nothing because the bignum should be treated as inifinity
+          unless append_history
+            begin
+              hist = hist.last(num) if hist.size > num and num > 0
+            rescue RangeError # bignum too big to convert into `long'
+              # Do nothing because the bignum should be treated as inifinity
+            end
           end
           f.puts(hist)
         end

data/lib/irb/extend-command.rb

@@ -126,7 +126,23 @@ module IRB # :nodoc:
       ],
 
       [
-        :measure, :Measure, "irb/cmd/measure"
+        :irb_ls, :Ls, "irb/cmd/ls",
+        [:ls, NO_OVERRIDE],
+      ],
+
+      [
+        :irb_measure, :Measure, "irb/cmd/measure",
+        [:measure, NO_OVERRIDE],
+      ],
+
+      [
+        :irb_show_source, :ShowSource, "irb/cmd/show_source",
+        [:show_source, NO_OVERRIDE],
+      ],
+
+      [
+        :irb_whereami, :Whereami, "irb/cmd/whereami",
+        [:whereami, NO_OVERRIDE],
       ],
 
     ]
@@ -168,12 +184,13 @@ module IRB # :nodoc:
       end
 
       if load_file
+        kwargs = ", **kwargs" if RUBY_ENGINE == "ruby" && RUBY_VERSION >= "2.7.0"
         line = __LINE__; eval %[
-          def #{cmd_name}(*opts, &b)
+          def #{cmd_name}(*opts#{kwargs}, &b)
             require "#{load_file}"
             arity = ExtendCommand::#{cmd_class}.instance_method(:execute).arity
             args = (1..(arity < 0 ? ~arity : arity)).map {|i| "arg" + i.to_s }
-            args << "*opts" if arity < 0
+            args << "*opts#{kwargs}" if arity < 0
             args << "&block"
             args = args.join(", ")
             line = __LINE__; eval %[
@@ -184,7 +201,7 @@ module IRB # :nodoc:
                 end
               end
             ], nil, __FILE__, line
-            __send__ :#{cmd_name}_, *opts, &b
+            __send__ :#{cmd_name}_, *opts#{kwargs}, &b
           end
         ], nil, __FILE__, line
       else

data/lib/irb/init.rb

@@ -44,7 +44,7 @@ module IRB # :nodoc:
     @CONF[:IRB_RC] = nil
 
     @CONF[:USE_SINGLELINE] = false unless defined?(ReadlineInputMethod)
-    @CONF[:USE_COLORIZE] = true
+    @CONF[:USE_COLORIZE] = !ENV['NO_COLOR']
     @CONF[:INSPECT_MODE] = true
     @CONF[:USE_TRACER] = false
     @CONF[:USE_LOADER] = false
@@ -120,7 +120,11 @@ module IRB # :nodoc:
       puts 'processing time: %fs' % (now - time) if IRB.conf[:MEASURE]
       result
     }
+    # arg can be either a symbol for the mode (:cpu, :wall, ..) or a hash for
+    # a more complete configuration.
+    # See https://github.com/tmm1/stackprof#all-options.
     @CONF[:MEASURE_PROC][:STACKPROF] = proc { |context, code, line_no, arg, &block|
+      return block.() unless IRB.conf[:MEASURE]
       success = false
       begin
         require 'stackprof'
@@ -130,10 +134,18 @@ module IRB # :nodoc:
       end
       if success
         result = nil
-        stackprof_result = StackProf.run(mode: arg ? arg : :cpu) do
+        arg = { mode: arg || :cpu } unless arg.is_a?(Hash)
+        stackprof_result = StackProf.run(**arg) do
           result = block.()
         end
-        StackProf::Report.new(stackprof_result).print_text if IRB.conf[:MEASURE]
+        case stackprof_result
+        when File
+          puts "StackProf report saved to #{stackprof_result.path}"
+        when Hash
+          StackProf::Report.new(stackprof_result).print_text
+        else
+          puts "Stackprof ran with #{arg.inspect}"
+        end
         result
       else
         block.()
@@ -301,11 +313,11 @@ module IRB # :nodoc:
         break
       end
     end
+
     load_path.collect! do |path|
       /\A\.\// =~ path ? path : File.expand_path(path)
     end
     $LOAD_PATH.unshift(*load_path)
-
   end
 
   # running config

data/lib/irb/input-method.rb

@@ -280,6 +280,7 @@ module IRB
         Reline.basic_word_break_characters = IRB::InputCompletor::BASIC_WORD_BREAK_CHARACTERS
       end
       Reline.completion_append_character = nil
+      Reline.completer_quote_characters = ''
       Reline.completion_proc = IRB::InputCompletor::CompletionProc
       Reline.output_modifier_proc =
         if IRB.conf[:USE_COLORIZE]

data/lib/irb/lc/help-message

@@ -10,7 +10,7 @@
 #
 #
 Usage:  irb.rb [options] [programfile] [arguments]
-  -f		    Suppress read of ~/.irbrc
+  -f                Suppress read of ~/.irbrc
   -d                Set $DEBUG to true (same as `ruby -d')
   -r load-module    Same as `ruby -r'
   -I path           Specify $LOAD_PATH directory
@@ -18,7 +18,7 @@ Usage:  irb.rb [options] [programfile] [arguments]
   -E enc            Same as `ruby -E`
   -w                Same as `ruby -w`
   -W[level=2]       Same as `ruby -W`
-  --context-mode n  Set n[0-3] to method to create Binding Object,
+  --context-mode n  Set n[0-4] to method to create Binding Object,
                     when new workspace was created
   --echo            Show result(default)
   --noecho          Don't show result
@@ -31,8 +31,8 @@ Usage:  irb.rb [options] [programfile] [arguments]
   --colorize        Use colorization
   --nocolorize      Don't use colorization
   --prompt prompt-mode/--prompt-mode prompt-mode
-		    Switch prompt mode. Pre-defined prompt modes are
-		    `default', `simple', `xmp' and `inf-ruby'
+                    Switch prompt mode. Pre-defined prompt modes are
+                    `default', `simple', `xmp' and `inf-ruby'
   --inf-ruby-mode   Use prompt appropriate for inf-ruby-mode on emacs.
                     Suppresses --multiline and --singleline.
   --sample-book-mode/--simple-prompt
@@ -41,8 +41,8 @@ Usage:  irb.rb [options] [programfile] [arguments]
   --single-irb      Share self with sub-irb.
   --tracer          Display trace for each execution of commands.
   --back-trace-limit n
-		    Display backtrace top n and tail n. The default
-		    value is 16.
+                    Display backtrace top n and tail n. The default
+                    value is 16.
   --verbose         Show details
   --noverbose       Don't show details
   -v, --version	    Print the version of irb

data/lib/irb/ruby-lex.rb

@@ -30,29 +30,48 @@ class RubyLex
     @prompt = nil
   end
 
-  def self.compile_with_errors_suppressed(code)
-    line_no = 1
+  def self.compile_with_errors_suppressed(code, line_no: 1)
     begin
       result = yield code, line_no
     rescue ArgumentError
+      # Ruby can issue an error for the code if there is an
+      # incomplete magic comment for encoding in it. Force an
+      # expression with a new line before the code in this
+      # case to prevent magic comment handling.  To make sure
+      # line numbers in the lexed code remain the same,
+      # decrease the line number by one.
       code = ";\n#{code}"
-      line_no = 0
+      line_no -= 1
       result = yield code, line_no
     end
     result
   end
 
   # io functions
-  def set_input(io, p = nil, &block)
+  def set_input(io, p = nil, context: nil, &block)
     @io = io
     if @io.respond_to?(:check_termination)
       @io.check_termination do |code|
-        code.gsub!(/\s*\z/, '').concat("\n")
-        ltype, indent, continue, code_block_open = check_state(code)
-        if ltype or indent > 0 or continue or code_block_open
-          false
+        if Reline::IOGate.in_pasting?
+          lex = RubyLex.new
+          rest = lex.check_termination_in_prev_line(code, context: context)
+          if rest
+            Reline.delete_text
+            rest.bytes.reverse_each do |c|
+              Reline.ungetc(c)
+            end
+            true
+          else
+            false
+          end
         else
-          true
+          code.gsub!(/\s*\z/, '').concat("\n")
+          ltype, indent, continue, code_block_open = check_state(code, context: context)
+          if ltype or indent > 0 or continue or code_block_open
+            false
+          else
+            true
+          end
         end
       end
     end
@@ -60,7 +79,7 @@ class RubyLex
       @io.dynamic_prompt do |lines|
         lines << '' if lines.empty?
         result = []
-        tokens = ripper_lex_without_warning(lines.map{ |l| l + "\n" }.join)
+        tokens = self.class.ripper_lex_without_warning(lines.map{ |l| l + "\n" }.join, context: context)
         code = String.new
         partial_tokens = []
         unprocessed_tokens = []
@@ -72,7 +91,7 @@ class RubyLex
             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)
+              ltype, indent, continue, code_block_open = check_state(code, partial_tokens, context: context)
               result << @prompt.call(ltype, indent, continue || code_block_open, @line_no + line_num_offset)
               line_num_offset += 1
             end
@@ -82,7 +101,7 @@ class RubyLex
           end
         end
         unless unprocessed_tokens.empty?
-          ltype, indent, continue, code_block_open = check_state(code, unprocessed_tokens)
+          ltype, indent, continue, code_block_open = check_state(code, unprocessed_tokens, context: context)
           result << @prompt.call(ltype, indent, continue || code_block_open, @line_no + line_num_offset)
         end
         result
@@ -115,15 +134,25 @@ class RubyLex
     :on_param_error
   ]
 
-  def ripper_lex_without_warning(code)
+  def self.ripper_lex_without_warning(code, context: nil)
     verbose, $VERBOSE = $VERBOSE, nil
+    if context
+      lvars = context&.workspace&.binding&.local_variables
+      if lvars && !lvars.empty?
+        code = "#{lvars.join('=')}=nil\n#{code}"
+        line_no = 0
+      else
+        line_no = 1
+      end
+    end
     tokens = nil
-    self.class.compile_with_errors_suppressed(code) do |inner_code, line_no|
+    compile_with_errors_suppressed(code, line_no: line_no) do |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|
+          next if t.pos.first == 0
           if pos_to_index.has_key?(t[0])
             index = pos_to_index[t[0]]
             found_tk = tokens[index]
@@ -168,7 +197,7 @@ class RubyLex
     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
-          @tokens = ripper_lex_without_warning(lines[0..line_index].join("\n"))
+          @tokens = self.class.ripper_lex_without_warning(lines[0..line_index].join("\n"), context: context)
           prev_spaces = find_prev_spaces(line_index)
           depth_difference = check_newline_depth_difference
           depth_difference = 0 if depth_difference < 0
@@ -177,7 +206,7 @@ class RubyLex
           code = line_index.zero? ? '' : lines[0..(line_index - 1)].map{ |l| l + "\n" }.join
           last_line = lines[line_index]&.byteslice(0, byte_pointer)
           code += last_line if last_line
-          @tokens = ripper_lex_without_warning(code)
+          @tokens = self.class.ripper_lex_without_warning(code, context: context)
           corresponding_token_depth = check_corresponding_token_depth
           if corresponding_token_depth
             corresponding_token_depth
@@ -189,8 +218,8 @@ class RubyLex
     end
   end
 
-  def check_state(code, tokens = nil)
-    tokens = ripper_lex_without_warning(code) unless tokens
+  def check_state(code, tokens = nil, context: nil)
+    tokens = self.class.ripper_lex_without_warning(code, context: context) unless tokens
     ltype = process_literal_type(tokens)
     indent = process_nesting_level(tokens)
     continue = process_continue(tokens)
@@ -256,7 +285,7 @@ class RubyLex
     end
     code = @line + (line.nil? ? '' : line)
     code.gsub!(/\s*\z/, '').concat("\n")
-    @tokens = ripper_lex_without_warning(code)
+    @tokens = self.class.ripper_lex_without_warning(code)
     @continue = process_continue
     @code_block_open = check_code_block(code)
     @indent = process_nesting_level
@@ -277,8 +306,9 @@ class RubyLex
       return true
     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) and tokens[-2][2] !~ /\A\.\.\.?\z/
       # end of literal except for regexp
+      # endless range at end of line is not a continue
       return true
     end
     false
@@ -324,7 +354,7 @@ class RubyLex
         # "syntax error, unexpected end-of-input, expecting keyword_end"
         #
         #   example:
-        #     if ture
+        #     if true
         #       hoge
         #       if false
         #         fuga
@@ -685,7 +715,7 @@ class RubyLex
         start_token << t
         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}
+        acceptable_single_tokens = %i{on_ident on_const on_op on_cvar on_ivar on_gvar on_kw on_int}
         if (i + 1) < tokens.size and acceptable_single_tokens.all?{ |st| tokens[i + 1][1] != st }
           start_token << t
           end_type << :on_tstring_end
@@ -738,5 +768,50 @@ class RubyLex
       nil
     end
   end
+
+  def check_termination_in_prev_line(code, context: nil)
+    tokens = self.class.ripper_lex_without_warning(code, context: context)
+    past_first_newline = false
+    index = tokens.rindex do |t|
+      # traverse first token before last line
+      if past_first_newline
+        if t.tok.include?("\n")
+          true
+        end
+      elsif t.tok.include?("\n")
+        past_first_newline = true
+        false
+      else
+        false
+      end
+    end
+    if index
+      first_token = nil
+      last_line_tokens = tokens[(index + 1)..(tokens.size - 1)]
+      last_line_tokens.each do |t|
+        unless [:on_sp, :on_ignored_sp, :on_comment].include?(t.event)
+          first_token = t
+          break
+        end
+      end
+      if first_token.nil?
+        return false
+      elsif first_token && first_token.state == Ripper::EXPR_DOT
+        return false
+      else
+        tokens_without_last_line = tokens[0..index]
+        ltype = process_literal_type(tokens_without_last_line)
+        indent = process_nesting_level(tokens_without_last_line)
+        continue = process_continue(tokens_without_last_line)
+        code_block_open = check_code_block(tokens_without_last_line.map(&:tok).join(''), tokens_without_last_line)
+        if ltype or indent > 0 or continue or code_block_open
+          return false
+        else
+          return last_line_tokens.map(&:tok).join('')
+        end
+      end
+    end
+    false
+  end
 end
 # :startdoc:

data/lib/irb/version.rb

@@ -11,7 +11,7 @@
 #
 
 module IRB # :nodoc:
-  VERSION = "1.3.3"
+  VERSION = "1.3.7"
   @RELEASE_VERSION = VERSION
-  @LAST_UPDATE_DATE = "2021-02-07"
+  @LAST_UPDATE_DATE = "2021-08-12"
 end

data/lib/irb/workspace.rb

@@ -175,7 +175,7 @@ EOF
       body = (start_pos..end_pos).map do |current_pos|
         sprintf(fmt, pos == current_pos ? '=>' : '', current_pos + 1, lines[current_pos])
       end.join("")
-      "\nFrom: #{file} @ line #{pos + 1} :\n\n#{body}#{Color.clear}\n"
+      "\nFrom: #{file} @ line #{pos + 1} :\n\n#{body}#{Color.clear if use_colorize}\n"
     end
 
     def IRB.delete_caller

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: irb
 version: !ruby/object:Gem::Version
-  version: 1.3.3
+  version: 1.3.7
 platform: ruby
 authors:
 - Keiju ISHITSUKA
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-02-06 00:00:00.000000000 Z
+date: 2021-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: reline
@@ -16,42 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.5
+        version: 0.2.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.5
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.2.7
 description: Interactive Ruby command-line tool for REPL (Read Eval Print Loop).
 email:
 - keiju@ruby-lang.org
@@ -77,10 +49,13 @@ files:
 - lib/irb/cmd/help.rb
 - lib/irb/cmd/info.rb
 - lib/irb/cmd/load.rb
+- lib/irb/cmd/ls.rb
 - lib/irb/cmd/measure.rb
 - lib/irb/cmd/nop.rb
 - lib/irb/cmd/pushws.rb
+- lib/irb/cmd/show_source.rb
 - lib/irb/cmd/subirb.rb
+- lib/irb/cmd/whereami.rb
 - lib/irb/color.rb
 - lib/irb/color_printer.rb
 - lib/irb/completion.rb
@@ -137,7 +112,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: Interactive Ruby command-line tool for REPL (Read Eval Print Loop).