irb 1.13.2 → 1.15.2

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] unless t.state == Ripper::EXPR_ARG
+            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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'reline'
+
 module IRB
   # The implementation of this class is borrowed from RDoc's lib/rdoc/ri/driver.rb.
   # Please do NOT use this class directly outside of IRB.
@@ -33,17 +35,56 @@ 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
+          begin
+            Process.kill("TERM", pid) if pid
+          rescue Errno::EINVAL
+            # SIGTERM not supported (windows)
+            Process.kill("KILL", pid)
+          end
+        rescue Errno::ESRCH
+          # Pager process already terminated
+        end
         nil
       rescue Errno::EPIPE
       end
 
-      private
-
       def should_page?
         IRB.conf[:USE_PAGER] && STDIN.tty? && (ENV.key?("TERM") && ENV["TERM"] != "dumb")
       end
 
+      def page_with_preview(width, height, formatter_proc)
+        overflow_callback = ->(lines) do
+          modified_output = formatter_proc.call(lines.join, true)
+          content, = take_first_page(width, [height - 2, 0].max) {|o| o.write modified_output }
+          content = content.chomp
+          content = "#{content}\e[0m" if Color.colorable?
+          $stdout.puts content
+          $stdout.puts 'Preparing full inspection value...'
+        end
+        out = PageOverflowIO.new(width, height, overflow_callback, delay: 0.1)
+        yield out
+        content = formatter_proc.call(out.string, out.multipage?)
+        if out.multipage?
+          page(retain_content: true) do |io|
+            io.puts content
+          end
+        else
+          $stdout.puts content
+        end
+      end
+
+      def take_first_page(width, height)
+        overflow_callback = proc do |lines|
+          return lines.join, true
+        end
+        out = Pager::PageOverflowIO.new(width, height, overflow_callback)
+        yield out
+        [out.string, false]
+      end
+
+      private
+
       def content_exceeds_screen_height?(content)
         screen_height, screen_width = begin
           Reline.get_screen_size
@@ -53,10 +94,10 @@ module IRB
 
         pageable_height = screen_height - 3 # leave some space for previous and the current prompt
 
-        # If the content has more lines than the pageable height
-        content.lines.count > pageable_height ||
-          # Or if the content is a few long lines
-          pageable_height * screen_width < Reline::Unicode.calculate_width(content, true)
+        return true if content.lines.size > pageable_height
+
+        _, overflow = take_first_page(screen_width, pageable_height) {|out| out.write content }
+        overflow
       end
 
       def setup_pager(retain_content:)
@@ -87,5 +128,86 @@ module IRB
         nil
       end
     end
+
+    # Writable IO that has page overflow callback
+    class PageOverflowIO
+      attr_reader :string, :first_page_lines
+
+      # Maximum size of a single cell in terminal
+      # Assumed worst case: "\e[1;3;4;9;38;2;255;128;128;48;2;128;128;255mA\e[0m"
+      # bold, italic, underline, crossed_out, RGB forgound, RGB background
+      MAX_CHAR_PER_CELL = 50
+
+      def initialize(width, height, overflow_callback, delay: nil)
+        @lines = []
+        @first_page_lines = nil
+        @width = width
+        @height = height
+        @buffer = +''
+        @overflow_callback = overflow_callback
+        @col = 0
+        @string = +''
+        @multipage = false
+        @delay_until = (Time.now + delay if delay)
+      end
+
+      def puts(text = '')
+        text = text.to_s unless text.is_a?(String)
+        write(text)
+        write("\n") unless text.end_with?("\n")
+      end
+
+      def write(text)
+        text = text.to_s unless text.is_a?(String)
+        @string << text
+        if @multipage
+          if @delay_until && Time.now > @delay_until
+            @overflow_callback.call(@first_page_lines)
+            @delay_until = nil
+          end
+          return
+        end
+
+        overflow_size = (@width * (@height - @lines.size) + @width - @col) * MAX_CHAR_PER_CELL
+        if text.size >= overflow_size
+          text = text[0, overflow_size]
+          overflow = true
+        end
+        @buffer << text
+        @col += Reline::Unicode.calculate_width(text, true)
+        if text.include?("\n") || @col >= @width
+          @buffer.lines.each do |line|
+            wrapped_lines = Reline::Unicode.split_by_width(line.chomp, @width).first.compact
+            wrapped_lines.pop if wrapped_lines.last == ''
+            @lines.concat(wrapped_lines)
+            if line.end_with?("\n")
+              if @lines.empty? || @lines.last.end_with?("\n")
+                @lines << "\n"
+              else
+                @lines[-1] += "\n"
+              end
+            end
+          end
+          @buffer.clear
+          @buffer << @lines.pop if !@lines.empty? && !@lines.last.end_with?("\n")
+          @col = Reline::Unicode.calculate_width(@buffer, true)
+        end
+        if overflow || @lines.size > @height || (@lines.size == @height && @col > 0)
+          @first_page_lines = @lines.take(@height)
+          if !@delay_until || Time.now > @delay_until
+            @overflow_callback.call(@first_page_lines)
+            @delay_until = nil
+          end
+          @multipage = true
+        end
+      end
+
+      def multipage?
+        @multipage
+      end
+
+      alias print write
+      alias << write
+    end
   end
 end