irb 1.3.0 → 1.3.5

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

@@ -146,7 +146,7 @@ module IRB # :nodoc:
     @CONF[:AT_EXIT] = []
   end
 
-  def IRB.set_measure_callback(type = nil, arg = nil)
+  def IRB.set_measure_callback(type = nil, arg = nil, &block)
     added = nil
     if type
       type_sym = type.upcase.to_sym
@@ -155,6 +155,16 @@ module IRB # :nodoc:
       end
     elsif IRB.conf[:MEASURE_PROC][:CUSTOM]
       added = [:CUSTOM, IRB.conf[:MEASURE_PROC][:CUSTOM], arg]
+    elsif block_given?
+      added = [:BLOCK, block, arg]
+      found = IRB.conf[:MEASURE_CALLBACKS].find{ |m| m[0] == added[0] && m[2] == added[2] }
+      if found
+        found[1] = block
+        return added
+      else
+        IRB.conf[:MEASURE_CALLBACKS] << added
+        return added
+      end
     else
       added = [:TIME, IRB.conf[:MEASURE_PROC][:TIME], arg]
     end

data/lib/irb/input-method.rb

@@ -124,10 +124,22 @@ module IRB
 
   # Use a File for IO with irb, see InputMethod
   class FileInputMethod < InputMethod
+    class << self
+      def open(file, &block)
+        begin
+          io = new(file)
+          block.call(io)
+        ensure
+          io&.close
+        end
+      end
+    end
+
     # Creates a new input method object
     def initialize(file)
       super
       @io = IRB::MagicFile.open(file)
+      @external_encoding = @io.external_encoding
     end
     # The file name of this input method, usually given during initialization.
     attr_reader :file_name
@@ -137,7 +149,7 @@ module IRB
     #
     # See IO#eof? for more information.
     def eof?
-      @io.eof?
+      @io.closed? || @io.eof?
     end
 
     # Reads the next line from this input method.
@@ -150,13 +162,17 @@ module IRB
 
     # The external encoding for standard input.
     def encoding
-      @io.external_encoding
+      @external_encoding
     end
 
     # For debug message
     def inspect
       'FileInputMethod'
     end
+
+    def close
+      @io.close
+    end
   end
 
   begin
@@ -264,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/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/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

@@ -47,12 +47,26 @@ class RubyLex
     @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)
+          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)
+          if ltype or indent > 0 or continue or code_block_open
+            false
+          else
+            true
+          end
         end
       end
     end
@@ -60,7 +74,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)
         code = String.new
         partial_tokens = []
         unprocessed_tokens = []
@@ -106,30 +120,78 @@ class RubyLex
     end
   end
 
-  def ripper_lex_without_warning(code)
+  ERROR_TOKENS = [
+    :on_parse_error,
+    :compile_error,
+    :on_assign_error,
+    :on_alias_error,
+    :on_class_name_error,
+    :on_param_error
+  ]
+
+  def self.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)
+    compile_with_errors_suppressed(code) 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|
+          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"))
+          @tokens = self.class.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
           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)
           corresponding_token_depth = check_corresponding_token_depth
           if corresponding_token_depth
             corresponding_token_depth
@@ -142,7 +204,7 @@ class RubyLex
   end
 
   def check_state(code, tokens = nil)
-    tokens = ripper_lex_without_warning(code) unless tokens
+    tokens = self.class.ripper_lex_without_warning(code) unless tokens
     ltype = process_literal_type(tokens)
     indent = process_nesting_level(tokens)
     continue = process_continue(tokens)
@@ -175,7 +237,10 @@ class RubyLex
             throw :TERM_INPUT if @line == ''
           else
             @line_no += l.count("\n")
-            next if l == "\n"
+            if l == "\n"
+              @exp_line_no += 1
+              next
+            end
             @line.concat l
             if @code_block_open or @ltype or @continue or @indent > 0
               next
@@ -185,7 +250,7 @@ class RubyLex
             @line.force_encoding(@io.encoding)
             yield @line, @exp_line_no
           end
-          break if @io.eof?
+          raise TerminateLineInput if @io.eof?
           @line = ''
           @exp_line_no = @line_no
 
@@ -205,7 +270,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
@@ -226,8 +291,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
@@ -360,14 +426,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
-            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'
@@ -382,6 +442,83 @@ class RubyLex
     indent
   end
 
+  def is_method_calling?(tokens, index)
+    tk = tokens[index]
+    if tk[3].anybits?(Ripper::EXPR_CMDARG) and tk[1] == :on_ident
+      # The target method call to pass the block with "do".
+      return true
+    elsif tk[3].anybits?(Ripper::EXPR_ARG) and tk[1] == :on_ident
+      non_sp_index = tokens[0..(index - 1)].rindex{ |t| t[1] != :on_sp }
+      if non_sp_index
+        prev_tk = tokens[non_sp_index]
+        if prev_tk[3].anybits?(Ripper::EXPR_DOT) and prev_tk[1] == :on_period
+          # The target method call with receiver to pass the block with "do".
+          return true
+        end
+      end
+    end
+    false
+  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".
+      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 is_method_calling?(tokens, i)
+        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 is_the_in_correspond_to_a_for(tokens, index)
+    syntax_of_in = 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".
+      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[1] == :on_kw && tk[2] == 'for'
+        # 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_in = :for
+      end
+      break if first_in_fomula
+    end
+    syntax_of_in
+  end
+
   def check_newline_depth_difference
     depth_difference = 0
     open_brace_on_line = 0
@@ -410,7 +547,7 @@ class RubyLex
 
       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
@@ -428,14 +565,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'
@@ -443,8 +574,14 @@ class RubyLex
           unless t[3].allbits?(Ripper::EXPR_LABEL)
             depth_difference += 1
           end
-        when 'else', 'elsif', 'ensure', 'when', 'in'
+        when 'else', 'elsif', 'ensure', 'when'
           depth_difference += 1
+        when 'in'
+          unless is_the_in_correspond_to_a_for(@tokens, index)
+            depth_difference += 1
+          end
+        when 'end'
+          depth_difference -= 1
         end
       end
     end
@@ -488,11 +625,13 @@ class RubyLex
 
       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
@@ -514,7 +653,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)
@@ -609,5 +753,50 @@ class RubyLex
       nil
     end
   end
+
+  def check_termination_in_prev_line(code)
+    tokens = self.class.ripper_lex_without_warning(code)
+    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: