irb 1.0.0 → 1.4.1

data/irb.gemspec

@@ -14,13 +14,27 @@ Gem::Specification.new do |spec|
   spec.summary       = %q{Interactive Ruby command-line tool for REPL (Read Eval Print Loop).}
   spec.description   = %q{Interactive Ruby command-line tool for REPL (Read Eval Print Loop).}
   spec.homepage      = "https://github.com/ruby/irb"
-  spec.license       = "BSD-2-Clause"
+  spec.licenses      = ["Ruby", "BSD-2-Clause"]
 
-  spec.files         = [".gitignore", ".travis.yml", "Gemfile", "LICENSE.txt", "README.md", "Rakefile", "bin/console", "bin/setup", "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/load.rb", "lib/irb/cmd/nop.rb", "lib/irb/cmd/pushws.rb", "lib/irb/cmd/subirb.rb", "lib/irb/completion.rb", "lib/irb/context.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/.document", "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-token.rb", "lib/irb/slex.rb", "lib/irb/src_encoding.rb", "lib/irb/version.rb", "lib/irb/workspace.rb", "lib/irb/ws-for-case-2.rb", "lib/irb/xmp.rb"]
+  spec.files         = [
+    ".document",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "bin/console",
+    "bin/setup",
+    "doc/irb/irb-tools.rd.ja",
+    "doc/irb/irb.rd.ja",
+    "exe/irb",
+    "irb.gemspec",
+    "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.add_development_dependency "bundler"
-  spec.add_development_dependency "rake"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.5")
+
+  spec.add_dependency "reline", ">= 0.3.0"
 end

data/lib/irb/cmd/fork.rb

@@ -16,12 +16,12 @@ 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')
           end
-          if iterator?
+          if block_given?
             begin
               yield
             ensure
@@ -35,5 +35,3 @@ module IRB
   end
 end
 # :startdoc:
-
-

data/lib/irb/cmd/help.rb

@@ -9,17 +9,19 @@
 #
 #
 
-require 'rdoc/ri/driver'
-
 require_relative "nop"
 
 # :stopdoc:
 module IRB
   module ExtendCommand
     class Help < Nop
-      begin
-        Ri = RDoc::RI::Driver.new
-      rescue SystemExit
+      def execute(*names)
+        require 'rdoc/ri/driver'
+        opts = RDoc::RI::Driver.process_args([])
+        IRB::ExtendCommand::Help.const_set(:Ri, RDoc::RI::Driver.new(opts))
+      rescue LoadError, SystemExit
+        IRB::ExtendCommand::Help.remove_method(:execute)
+        # raise NoMethodError in ensure
       else
         def execute(*names)
           if names.empty?
@@ -35,6 +37,9 @@ module IRB
           end
           nil
         end
+        nil
+      ensure
+        execute(*names)
       end
     end
   end

data/lib/irb/cmd/info.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: false
+
+require_relative "nop"
+
+# :stopdoc:
+module IRB
+  module ExtendCommand
+    class Info < Nop
+      def execute
+        Class.new {
+          def inspect
+            str  = "Ruby version: #{RUBY_VERSION}\n"
+            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?
+            str += "East Asian Ambiguous Width: #{Reline.ambiguous_width.inspect}\n"
+            if RbConfig::CONFIG['host_os'] =~ /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+              codepage = `chcp`.b.sub(/.*: (\d+)\n/, '\1')
+              str += "Code page: #{codepage}\n"
+            end
+            str
+          end
+          alias_method :to_s, :inspect
+        }.new
+      end
+    end
+  end
+end
+# :startdoc:

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

@@ -0,0 +1,43 @@
+require_relative "nop"
+
+# :stopdoc:
+module IRB
+  module ExtendCommand
+    class Measure < Nop
+      def initialize(*args)
+        super(*args)
+      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
+          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
+          if block_given?
+            IRB.conf[:MEASURE] = true
+            added = IRB.set_measure_callback(&block)
+            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
+        end
+        nil
+      end
+    end
+  end
+end
+# :startdoc:

data/lib/irb/cmd/nop.rb

@@ -14,10 +14,16 @@ module IRB
   module ExtendCommand
     class Nop
 
-
-      def self.execute(conf, *opts)
-        command = new(conf)
-        command.execute(*opts)
+      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/pushws.rb

@@ -38,4 +38,3 @@ module IRB
   end
 end
 # :startdoc:
-

data/lib/irb/cmd/show_source.rb

@@ -0,0 +1,93 @@
+# 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)
+        prev_tokens = []
+
+        # chunk with line number
+        tokens.chunk { |tok| tok.pos[0] }.each do |lnum, chunk|
+          code = lines[0..lnum].join
+          prev_tokens.concat chunk
+          continue = lex.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

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+require 'reline'
+require 'ripper'
+require 'irb/ruby-lex'
+
+module IRB # :nodoc:
+  module Color
+    CLEAR     = 0
+    BOLD      = 1
+    UNDERLINE = 4
+    REVERSE   = 7
+    RED       = 31
+    GREEN     = 32
+    YELLOW    = 33
+    BLUE      = 34
+    MAGENTA   = 35
+    CYAN      = 36
+
+    TOKEN_KEYWORDS = {
+      on_kw: ['nil', 'self', 'true', 'false', '__FILE__', '__LINE__', '__ENCODING__'],
+      on_const: ['ENV'],
+    }
+    private_constant :TOKEN_KEYWORDS
+
+    # A constant of all-bit 1 to match any Ripper's state in #dispatch_seq
+    ALL = -1
+    private_constant :ALL
+
+    begin
+      # Following pry's colors where possible, but sometimes having a compromise like making
+      # backtick and regexp as red (string's color, because they're sharing tokens).
+      TOKEN_SEQ_EXPRS = {
+        on_CHAR:            [[BLUE, BOLD],            ALL],
+        on_backtick:        [[RED, BOLD],             ALL],
+        on_comment:         [[BLUE, BOLD],            ALL],
+        on_const:           [[BLUE, BOLD, UNDERLINE], ALL],
+        on_embexpr_beg:     [[RED],                   ALL],
+        on_embexpr_end:     [[RED],                   ALL],
+        on_embvar:          [[RED],                   ALL],
+        on_float:           [[MAGENTA, BOLD],         ALL],
+        on_gvar:            [[GREEN, BOLD],           ALL],
+        on_heredoc_beg:     [[RED],                   ALL],
+        on_heredoc_end:     [[RED],                   ALL],
+        on_ident:           [[BLUE, BOLD],            Ripper::EXPR_ENDFN],
+        on_imaginary:       [[BLUE, BOLD],            ALL],
+        on_int:             [[BLUE, BOLD],            ALL],
+        on_kw:              [[GREEN],                 ALL],
+        on_label:           [[MAGENTA],               ALL],
+        on_label_end:       [[RED, BOLD],             ALL],
+        on_qsymbols_beg:    [[RED, BOLD],             ALL],
+        on_qwords_beg:      [[RED, BOLD],             ALL],
+        on_rational:        [[BLUE, BOLD],            ALL],
+        on_regexp_beg:      [[RED, BOLD],             ALL],
+        on_regexp_end:      [[RED, BOLD],             ALL],
+        on_symbeg:          [[YELLOW],                ALL],
+        on_symbols_beg:     [[RED, BOLD],             ALL],
+        on_tstring_beg:     [[RED, BOLD],             ALL],
+        on_tstring_content: [[RED],                   ALL],
+        on_tstring_end:     [[RED, BOLD],             ALL],
+        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],
+        on___end__:         [[GREEN],                 ALL],
+      }
+    rescue NameError
+      # Give up highlighting Ripper-incompatible older Ruby
+      TOKEN_SEQ_EXPRS = {}
+    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? && (/mswin|mingw/ =~ RUBY_PLATFORM || (ENV.key?('TERM') && ENV['TERM'] != 'dumb'))
+      end
+
+      def inspect_colorable?(obj, seen: {}.compare_by_identity)
+        case obj
+        when String, Symbol, Regexp, Integer, Float, FalseClass, TrueClass, NilClass
+          true
+        when Hash
+          without_circular_ref(obj, seen: seen) do
+            obj.all? { |k, v| inspect_colorable?(k, seen: seen) && inspect_colorable?(v, seen: seen) }
+          end
+        when Array
+          without_circular_ref(obj, seen: seen) do
+            obj.all? { |o| inspect_colorable?(o, seen: seen) }
+          end
+        when Range
+          inspect_colorable?(obj.begin, seen: seen) && inspect_colorable?(obj.end, seen: seen)
+        when Module
+          !obj.name.nil?
+        else
+          false
+        end
+      end
+
+      def clear(colorable: colorable?)
+        return '' unless colorable
+        "\e[#{CLEAR}m"
+      end
+
+      def colorize(text, seq, colorable: colorable?)
+        return text unless colorable
+        seq = seq.map { |s| "\e[#{const_get(s)}m" }.join('')
+        "#{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, 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
+          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)
+            if seq = dispatch_seq(token, expr, line, in_symbol: in_symbol)
+              colored << seq.map { |s| "\e[#{s}m" }.join('')
+              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
+        unless end_seen or length == code.bytesize
+          return Reline::Unicode.escape_for_print(code)
+        end
+
+        colored
+      end
+
+      private
+
+      def without_circular_ref(obj, seen:, &block)
+        return false if seen.key?(obj)
+        seen[obj] = true
+        block.call
+      ensure
+        seen.delete(obj)
+      end
+
+      def scan(code, allow_last_error:)
+        pos = [1, 0]
+
+        verbose, $VERBOSE = $VERBOSE, nil
+        RubyLex.compile_with_errors_suppressed(code) do |inner_code, line_no|
+          lexer = Ripper::Lexer.new(inner_code, '(ripper)', line_no)
+          if lexer.respond_to?(:scan) # Ruby 2.7+
+            lexer.scan.each do |elem|
+              str = elem.tok
+              next if allow_last_error and /meets end of file|unexpected end-of-input/ =~ elem.message
+              next if ([elem.pos[0], elem.pos[1] + str.bytesize] <=> pos) <= 0
+
+              str.each_line do |line|
+                if line.end_with?("\n")
+                  pos[0] += 1
+                  pos[1] = 0
+                else
+                  pos[1] += line.bytesize
+                end
+              end
+
+              yield(elem.event, str, elem.state)
+            end
+          else
+            lexer.parse.each do |elem|
+              yield(elem.event, elem.tok, elem.state)
+            end
+          end
+        end
+      ensure
+        $VERBOSE = verbose
+      end
+
+      def dispatch_seq(token, expr, str, in_symbol:)
+        if ERROR_TOKENS.include?(token)
+          TOKEN_SEQ_EXPRS[token][0]
+        elsif in_symbol
+          [YELLOW]
+        elsif TOKEN_KEYWORDS.fetch(token, []).include?(str)
+          [CYAN, BOLD]
+        elsif (seq, exprs = TOKEN_SEQ_EXPRS[token]; (expr & (exprs || 0)) != 0)
+          seq
+        else
+          nil
+        end
+      end
+    end
+
+    # A class to manage a state to know whether the current token is for Symbol or not.
+    class SymbolState
+      def initialize
+        # Push `true` to detect Symbol. `false` to increase the nest level for non-Symbol.
+        @stack = []
+      end
+
+      # Return true if the token is a part of Symbol.
+      def scan_token(token)
+        prev_state = @stack.last
+        case token
+        when :on_symbeg, :on_symbols_beg, :on_qsymbols_beg
+          @stack << true
+        when :on_ident, :on_op, :on_const, :on_ivar, :on_cvar, :on_gvar, :on_kw
+          if @stack.last # Pop only when it's Symbol
+            @stack.pop
+            return prev_state
+          end
+        when :on_tstring_beg
+          @stack << false
+        when :on_embexpr_beg
+          @stack << false
+          return prev_state
+        when :on_tstring_end # :on_tstring_end may close Symbol
+          @stack.pop
+          return prev_state
+        when :on_embexpr_end
+          @stack.pop
+        end
+        @stack.last
+      end
+    end
+    private_constant :SymbolState
+  end
+end