irb 1.14.0 → 1.14.1

data/lib/irb/nesting_parser.rb

@@ -3,235 +3,237 @@ module IRB
   module NestingParser
     IGNORE_TOKENS = %i[on_sp on_ignored_nl on_comment on_embdoc_beg on_embdoc on_embdoc_end]
 
-    # Scan each token and call the given block with array of token and other information for parsing
-    def self.scan_opens(tokens)
-      opens = []
-      pending_heredocs = []
-      first_token_on_line = true
-      tokens.each do |t|
-        skip = false
-        last_tok, state, args = opens.last
-        case state
-        when :in_alias_undef
-          skip = t.event == :on_kw
-        when :in_unquoted_symbol
-          unless IGNORE_TOKENS.include?(t.event)
-            opens.pop
-            skip = true
-          end
-        when :in_lambda_head
-          opens.pop if t.event == :on_tlambeg || (t.event == :on_kw && t.tok == 'do')
-        when :in_method_head
-          unless IGNORE_TOKENS.include?(t.event)
-            next_args = []
-            body = nil
-            if args.include?(:receiver)
-              case t.event
-              when :on_lparen, :on_ivar, :on_gvar, :on_cvar
-                # def (receiver). | def @ivar. | def $gvar. | def @@cvar.
-                next_args << :dot
-              when :on_kw
-                case t.tok
-                when 'self', 'true', 'false', 'nil'
-                  # def self(arg) | def self.
-                  next_args.push(:arg, :dot)
-                else
-                  # def if(arg)
+    class << self
+      # Scan each token and call the given block with array of token and other information for parsing
+      def scan_opens(tokens)
+        opens = []
+        pending_heredocs = []
+        first_token_on_line = true
+        tokens.each do |t|
+          skip = false
+          last_tok, state, args = opens.last
+          case state
+          when :in_alias_undef
+            skip = t.event == :on_kw
+          when :in_unquoted_symbol
+            unless IGNORE_TOKENS.include?(t.event)
+              opens.pop
+              skip = true
+            end
+          when :in_lambda_head
+            opens.pop if t.event == :on_tlambeg || (t.event == :on_kw && t.tok == 'do')
+          when :in_method_head
+            unless IGNORE_TOKENS.include?(t.event)
+              next_args = []
+              body = nil
+              if args.include?(:receiver)
+                case t.event
+                when :on_lparen, :on_ivar, :on_gvar, :on_cvar
+                  # def (receiver). | def @ivar. | def $gvar. | def @@cvar.
+                  next_args << :dot
+                when :on_kw
+                  case t.tok
+                  when 'self', 'true', 'false', 'nil'
+                    # def self(arg) | def self.
+                    next_args.push(:arg, :dot)
+                  else
+                    # def if(arg)
+                    skip = true
+                    next_args << :arg
+                  end
+                when :on_op, :on_backtick
+                  # def +(arg)
                   skip = true
                   next_args << :arg
+                when :on_ident, :on_const
+                  # def a(arg) | def a.
+                  next_args.push(:arg, :dot)
                 end
-              when :on_op, :on_backtick
-                # def +(arg)
-                skip = true
-                next_args << :arg
-              when :on_ident, :on_const
-                # def a(arg) | def a.
-                next_args.push(:arg, :dot)
               end
-            end
-            if args.include?(:dot)
-              # def receiver.name
-              next_args << :name if t.event == :on_period || (t.event == :on_op && t.tok == '::')
-            end
-            if args.include?(:name)
-              if %i[on_ident on_const on_op on_kw on_backtick].include?(t.event)
-                # def name(arg) | def receiver.name(arg)
-                next_args << :arg
-                skip = true
+              if args.include?(:dot)
+                # def receiver.name
+                next_args << :name if t.event == :on_period || (t.event == :on_op && t.tok == '::')
               end
-            end
-            if args.include?(:arg)
-              case t.event
-              when :on_nl, :on_semicolon
-                # def receiver.f;
-                body = :normal
-              when :on_lparen
-                # def receiver.f()
-                next_args << :eq
-              else
+              if args.include?(:name)
+                if %i[on_ident on_const on_op on_kw on_backtick].include?(t.event)
+                  # def name(arg) | def receiver.name(arg)
+                  next_args << :arg
+                  skip = true
+                end
+              end
+              if args.include?(:arg)
+                case t.event
+                when :on_nl, :on_semicolon
+                  # def receiver.f;
+                  body = :normal
+                when :on_lparen
+                  # def receiver.f()
+                  next_args << :eq
+                else
+                  if t.event == :on_op && t.tok == '='
+                    # def receiver.f =
+                    body = :oneliner
+                  else
+                    # def receiver.f arg
+                    next_args << :arg_without_paren
+                  end
+                end
+              end
+              if args.include?(:eq)
                 if t.event == :on_op && t.tok == '='
-                  # def receiver.f =
                   body = :oneliner
                 else
-                  # def receiver.f arg
-                  next_args << :arg_without_paren
+                  body = :normal
                 end
               end
-            end
-            if args.include?(:eq)
-              if t.event == :on_op && t.tok == '='
-                body = :oneliner
-              else
-                body = :normal
+              if args.include?(:arg_without_paren)
+                if %i[on_semicolon on_nl].include?(t.event)
+                  # def f a;
+                  body = :normal
+                else
+                  # def f a, b
+                  next_args << :arg_without_paren
+                end
               end
-            end
-            if args.include?(:arg_without_paren)
-              if %i[on_semicolon on_nl].include?(t.event)
-                # def f a;
-                body = :normal
+              if body == :oneliner
+                opens.pop
+              elsif body
+                opens[-1] = [last_tok, nil]
               else
-                # def f a, b
-                next_args << :arg_without_paren
+                opens[-1] = [last_tok, :in_method_head, next_args]
               end
             end
-            if body == :oneliner
-              opens.pop
-            elsif body
+          when :in_for_while_until_condition
+            if t.event == :on_semicolon || t.event == :on_nl || (t.event == :on_kw && t.tok == 'do')
+              skip = true if t.event == :on_kw && t.tok == 'do'
               opens[-1] = [last_tok, nil]
-            else
-              opens[-1] = [last_tok, :in_method_head, next_args]
             end
           end
-        when :in_for_while_until_condition
-          if t.event == :on_semicolon || t.event == :on_nl || (t.event == :on_kw && t.tok == 'do')
-            skip = true if t.event == :on_kw && t.tok == 'do'
-            opens[-1] = [last_tok, nil]
-          end
-        end
 
-        unless skip
-          case t.event
-          when :on_kw
-            case t.tok
-            when 'begin', 'class', 'module', 'do', 'case'
-              opens << [t, nil]
-            when 'end'
-              opens.pop
-            when 'def'
-              opens << [t, :in_method_head, [:receiver, :name]]
-            when 'if', 'unless'
-              unless t.state.allbits?(Ripper::EXPR_LABEL)
+          unless skip
+            case t.event
+            when :on_kw
+              case t.tok
+              when 'begin', 'class', 'module', 'do', 'case'
                 opens << [t, nil]
-              end
-            when 'while', 'until'
-              unless t.state.allbits?(Ripper::EXPR_LABEL)
-                opens << [t, :in_for_while_until_condition]
-              end
-            when 'ensure', 'rescue'
-              unless t.state.allbits?(Ripper::EXPR_LABEL)
+              when 'end'
+                opens.pop
+              when 'def'
+                opens << [t, :in_method_head, [:receiver, :name]]
+              when 'if', 'unless'
+                unless t.state.allbits?(Ripper::EXPR_LABEL)
+                  opens << [t, nil]
+                end
+              when 'while', 'until'
+                unless t.state.allbits?(Ripper::EXPR_LABEL)
+                  opens << [t, :in_for_while_until_condition]
+                end
+              when 'ensure', 'rescue'
+                unless t.state.allbits?(Ripper::EXPR_LABEL)
+                  opens.pop
+                  opens << [t, nil]
+                end
+              when 'alias'
+                opens << [t, :in_alias_undef, 2]
+              when 'undef'
+                opens << [t, :in_alias_undef, 1]
+              when 'elsif', 'else', 'when'
                 opens.pop
                 opens << [t, nil]
+              when 'for'
+                opens << [t, :in_for_while_until_condition]
+              when 'in'
+                if last_tok&.event == :on_kw && %w[case in].include?(last_tok.tok) && first_token_on_line
+                  opens.pop
+                  opens << [t, nil]
+                end
               end
-            when 'alias'
-              opens << [t, :in_alias_undef, 2]
-            when 'undef'
-              opens << [t, :in_alias_undef, 1]
-            when 'elsif', 'else', 'when'
+            when :on_tlambda
+              opens << [t, :in_lambda_head]
+            when :on_lparen, :on_lbracket, :on_lbrace, :on_tlambeg, :on_embexpr_beg, :on_embdoc_beg
+              opens << [t, nil]
+            when :on_rparen, :on_rbracket, :on_rbrace, :on_embexpr_end, :on_embdoc_end
+              opens.pop
+            when :on_heredoc_beg
+              pending_heredocs << t
+            when :on_heredoc_end
               opens.pop
+            when :on_backtick
+              opens << [t, nil] if t.state.allbits?(Ripper::EXPR_BEG)
+            when :on_tstring_beg, :on_words_beg, :on_qwords_beg, :on_symbols_beg, :on_qsymbols_beg, :on_regexp_beg
               opens << [t, nil]
-            when 'for'
-              opens << [t, :in_for_while_until_condition]
-            when 'in'
-              if last_tok&.event == :on_kw && %w[case in].include?(last_tok.tok) && first_token_on_line
-                opens.pop
+            when :on_tstring_end, :on_regexp_end, :on_label_end
+              opens.pop
+            when :on_symbeg
+              if t.tok == ':'
+                opens << [t, :in_unquoted_symbol]
+              else
                 opens << [t, nil]
               end
             end
-          when :on_tlambda
-            opens << [t, :in_lambda_head]
-          when :on_lparen, :on_lbracket, :on_lbrace, :on_tlambeg, :on_embexpr_beg, :on_embdoc_beg
-            opens << [t, nil]
-          when :on_rparen, :on_rbracket, :on_rbrace, :on_embexpr_end, :on_embdoc_end
-            opens.pop
-          when :on_heredoc_beg
-            pending_heredocs << t
-          when :on_heredoc_end
-            opens.pop
-          when :on_backtick
-            opens << [t, nil] if t.state.allbits?(Ripper::EXPR_BEG)
-          when :on_tstring_beg, :on_words_beg, :on_qwords_beg, :on_symbols_beg, :on_qsymbols_beg, :on_regexp_beg
-            opens << [t, nil]
-          when :on_tstring_end, :on_regexp_end, :on_label_end
-            opens.pop
-          when :on_symbeg
-            if t.tok == ':'
-              opens << [t, :in_unquoted_symbol]
-            else
-              opens << [t, nil]
-            end
           end
+          if t.event == :on_nl || t.event == :on_semicolon
+            first_token_on_line = true
+          elsif t.event != :on_sp
+            first_token_on_line = false
+          end
+          if pending_heredocs.any? && t.tok.include?("\n")
+            pending_heredocs.reverse_each { |t| opens << [t, nil] }
+            pending_heredocs = []
+          end
+          if opens.last && opens.last[1] == :in_alias_undef && !IGNORE_TOKENS.include?(t.event) && t.event != :on_heredoc_end
+            tok, state, arg = opens.pop
+            opens << [tok, state, arg - 1] if arg >= 1
+          end
+          yield t, opens if block_given?
         end
-        if t.event == :on_nl || t.event == :on_semicolon
-          first_token_on_line = true
-        elsif t.event != :on_sp
-          first_token_on_line = false
-        end
-        if pending_heredocs.any? && t.tok.include?("\n")
-          pending_heredocs.reverse_each { |t| opens << [t, nil] }
-          pending_heredocs = []
-        end
-        if opens.last && opens.last[1] == :in_alias_undef && !IGNORE_TOKENS.include?(t.event) && t.event != :on_heredoc_end
-          tok, state, arg = opens.pop
-          opens << [tok, state, arg - 1] if arg >= 1
-        end
-        yield t, opens if block_given?
+        opens.map(&:first) + pending_heredocs.reverse
       end
-      opens.map(&:first) + pending_heredocs.reverse
-    end
 
-    def self.open_tokens(tokens)
-      # scan_opens without block will return a list of open tokens at last token position
-      scan_opens(tokens)
-    end
+      def open_tokens(tokens)
+        # scan_opens without block will return a list of open tokens at last token position
+        scan_opens(tokens)
+      end
 
-    # Calculates token information [line_tokens, prev_opens, next_opens, min_depth] for each line.
-    # Example code
-    #   ["hello
-    #   world"+(
-    # First line
-    #   line_tokens: [[lbracket, '['], [tstring_beg, '"'], [tstring_content("hello\nworld"), "hello\n"]]
-    #   prev_opens:  []
-    #   next_tokens: [lbracket, tstring_beg]
-    #   min_depth:   0 (minimum at beginning of line)
-    # Second line
-    #   line_tokens: [[tstring_content("hello\nworld"), "world"], [tstring_end, '"'], [op, '+'], [lparen, '(']]
-    #   prev_opens:  [lbracket, tstring_beg]
-    #   next_tokens: [lbracket, lparen]
-    #   min_depth:   1 (minimum just after tstring_end)
-    def self.parse_by_line(tokens)
-      line_tokens = []
-      prev_opens = []
-      min_depth = 0
-      output = []
-      last_opens = scan_opens(tokens) do |t, opens|
-        depth = t == opens.last&.first ? opens.size - 1 : opens.size
-        min_depth = depth if depth < min_depth
-        if t.tok.include?("\n")
-          t.tok.each_line do |line|
-            line_tokens << [t, line]
-            next if line[-1] != "\n"
-            next_opens = opens.map(&:first)
-            output << [line_tokens, prev_opens, next_opens, min_depth]
-            prev_opens = next_opens
-            min_depth = prev_opens.size
-            line_tokens = []
+      # Calculates token information [line_tokens, prev_opens, next_opens, min_depth] for each line.
+      # Example code
+      #   ["hello
+      #   world"+(
+      # First line
+      #   line_tokens: [[lbracket, '['], [tstring_beg, '"'], [tstring_content("hello\nworld"), "hello\n"]]
+      #   prev_opens:  []
+      #   next_tokens: [lbracket, tstring_beg]
+      #   min_depth:   0 (minimum at beginning of line)
+      # Second line
+      #   line_tokens: [[tstring_content("hello\nworld"), "world"], [tstring_end, '"'], [op, '+'], [lparen, '(']]
+      #   prev_opens:  [lbracket, tstring_beg]
+      #   next_tokens: [lbracket, lparen]
+      #   min_depth:   1 (minimum just after tstring_end)
+      def parse_by_line(tokens)
+        line_tokens = []
+        prev_opens = []
+        min_depth = 0
+        output = []
+        last_opens = scan_opens(tokens) do |t, opens|
+          depth = t == opens.last&.first ? opens.size - 1 : opens.size
+          min_depth = depth if depth < min_depth
+          if t.tok.include?("\n")
+            t.tok.each_line do |line|
+              line_tokens << [t, line]
+              next if line[-1] != "\n"
+              next_opens = opens.map(&:first)
+              output << [line_tokens, prev_opens, next_opens, min_depth]
+              prev_opens = next_opens
+              min_depth = prev_opens.size
+              line_tokens = []
+            end
+          else
+            line_tokens << [t, t.tok]
           end
-        else
-          line_tokens << [t, t.tok]
         end
+        output << [line_tokens, prev_opens, last_opens, min_depth] if line_tokens.any?
+        output
       end
-      output << [line_tokens, prev_opens, last_opens, min_depth] if line_tokens.any?
-      output
     end
   end
 end

data/lib/irb/pager.rb

@@ -33,7 +33,11 @@ module IRB
       # the `IRB::Abort` exception only interrupts IRB's execution but doesn't affect the pager
       # So to properly terminate the pager with Ctrl-C, we need to catch `IRB::Abort` and kill the pager process
       rescue IRB::Abort
-        Process.kill("TERM", pid) if pid
+        begin
+          Process.kill("TERM", pid) if pid
+        rescue Errno::ESRCH
+          # Pager process already terminated
+        end
         nil
       rescue Errno::EPIPE
       end

data/lib/irb/ruby-lex.rb

@@ -36,29 +36,6 @@ module IRB
       :massign,
     ]
 
-    class TerminateLineInput < StandardError
-      def initialize
-        super("Terminate Line Input")
-      end
-    end
-
-    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 -= 1
-        result = yield code, line_no
-      end
-      result
-    end
-
     ERROR_TOKENS = [
       :on_parse_error,
       :compile_error,
@@ -68,70 +45,102 @@ module IRB
       :on_param_error
     ]
 
-    def self.generate_local_variables_assign_code(local_variables)
-      "#{local_variables.join('=')}=nil;" unless local_variables.empty?
+    LTYPE_TOKENS = %i[
+      on_heredoc_beg on_tstring_beg
+      on_regexp_beg on_symbeg on_backtick
+      on_symbols_beg on_qsymbols_beg
+      on_words_beg on_qwords_beg
+    ]
+
+    class TerminateLineInput < StandardError
+      def initialize
+        super("Terminate Line Input")
+      end
     end
 
-    # Some part of the code is not included in Ripper's token.
-    # Example: DATA part, token after heredoc_beg when heredoc has unclosed embexpr.
-    # With interpolated tokens, tokens.map(&:tok).join will be equal to code.
-    def self.interpolate_ripper_ignored_tokens(code, tokens)
-      line_positions = [0]
-      code.lines.each do |line|
-        line_positions << line_positions.last + line.bytesize
+    class << self
+      def 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 -= 1
+          result = yield code, line_no
+        end
+        result
+      end
+
+      def generate_local_variables_assign_code(local_variables)
+        "#{local_variables.join('=')}=nil;" unless local_variables.empty?
       end
-      prev_byte_pos = 0
-      interpolated = []
-      prev_line = 1
-      tokens.each do |t|
-        line, col = t.pos
-        byte_pos = line_positions[line - 1] + col
-        if prev_byte_pos < byte_pos
-          tok = code.byteslice(prev_byte_pos...byte_pos)
+
+      # Some part of the code is not included in Ripper's token.
+      # Example: DATA part, token after heredoc_beg when heredoc has unclosed embexpr.
+      # With interpolated tokens, tokens.map(&:tok).join will be equal to code.
+      def interpolate_ripper_ignored_tokens(code, tokens)
+        line_positions = [0]
+        code.lines.each do |line|
+          line_positions << line_positions.last + line.bytesize
+        end
+        prev_byte_pos = 0
+        interpolated = []
+        prev_line = 1
+        tokens.each do |t|
+          line, col = t.pos
+          byte_pos = line_positions[line - 1] + col
+          if prev_byte_pos < byte_pos
+            tok = code.byteslice(prev_byte_pos...byte_pos)
+            pos = [prev_line, prev_byte_pos - line_positions[prev_line - 1]]
+            interpolated << Ripper::Lexer::Elem.new(pos, :on_ignored_by_ripper, tok, 0)
+            prev_line += tok.count("\n")
+          end
+          interpolated << t
+          prev_byte_pos = byte_pos + t.tok.bytesize
+          prev_line += t.tok.count("\n")
+        end
+        if prev_byte_pos < code.bytesize
+          tok = code.byteslice(prev_byte_pos..)
           pos = [prev_line, prev_byte_pos - line_positions[prev_line - 1]]
           interpolated << Ripper::Lexer::Elem.new(pos, :on_ignored_by_ripper, tok, 0)
-          prev_line += tok.count("\n")
         end
-        interpolated << t
-        prev_byte_pos = byte_pos + t.tok.bytesize
-        prev_line += t.tok.count("\n")
-      end
-      if prev_byte_pos < code.bytesize
-        tok = code.byteslice(prev_byte_pos..)
-        pos = [prev_line, prev_byte_pos - line_positions[prev_line - 1]]
-        interpolated << Ripper::Lexer::Elem.new(pos, :on_ignored_by_ripper, tok, 0)
+        interpolated
       end
-      interpolated
-    end
 
-    def self.ripper_lex_without_warning(code, local_variables: [])
-      verbose, $VERBOSE = $VERBOSE, nil
-      lvars_code = generate_local_variables_assign_code(local_variables)
-      original_code = code
-      if lvars_code
-        code = "#{lvars_code}\n#{code}"
-        line_no = 0
-      else
-        line_no = 1
-      end
+      def ripper_lex_without_warning(code, local_variables: [])
+        verbose, $VERBOSE = $VERBOSE, nil
+        lvars_code = generate_local_variables_assign_code(local_variables)
+        original_code = code
+        if lvars_code
+          code = "#{lvars_code}\n#{code}"
+          line_no = 0
+        else
+          line_no = 1
+        end
 
-      compile_with_errors_suppressed(code, line_no: line_no) do |inner_code, line_no|
-        lexer = Ripper::Lexer.new(inner_code, '-', line_no)
-        tokens = []
-        lexer.scan.each do |t|
-          next if t.pos.first == 0
-          prev_tk = tokens.last
-          position_overlapped = prev_tk && t.pos[0] == prev_tk.pos[0] && t.pos[1] < prev_tk.pos[1] + prev_tk.tok.bytesize
-          if position_overlapped
-            tokens[-1] = t if ERROR_TOKENS.include?(prev_tk.event) && !ERROR_TOKENS.include?(t.event)
-          else
-            tokens << t
+        compile_with_errors_suppressed(code, line_no: line_no) do |inner_code, line_no|
+          lexer = Ripper::Lexer.new(inner_code, '-', line_no)
+          tokens = []
+          lexer.scan.each do |t|
+            next if t.pos.first == 0
+            prev_tk = tokens.last
+            position_overlapped = prev_tk && t.pos[0] == prev_tk.pos[0] && t.pos[1] < prev_tk.pos[1] + prev_tk.tok.bytesize
+            if position_overlapped
+              tokens[-1] = t if ERROR_TOKENS.include?(prev_tk.event) && !ERROR_TOKENS.include?(t.event)
+            else
+              tokens << t
+            end
           end
+          interpolate_ripper_ignored_tokens(original_code, tokens)
         end
-        interpolate_ripper_ignored_tokens(original_code, tokens)
+      ensure
+        $VERBOSE = verbose
       end
-    ensure
-      $VERBOSE = verbose
     end
 
     def check_code_state(code, local_variables:)
@@ -391,13 +400,6 @@ module IRB
       end
     end
 
-    LTYPE_TOKENS = %i[
-      on_heredoc_beg on_tstring_beg
-      on_regexp_beg on_symbeg on_backtick
-      on_symbols_beg on_qsymbols_beg
-      on_words_beg on_qwords_beg
-    ]
-
     def ltype_from_open_tokens(opens)
       start_token = opens.reverse_each.find do |tok|
         LTYPE_TOKENS.include?(tok.event)