irb 1.6.4 → 1.8.0

data/lib/irb/locale.rb

@@ -15,7 +15,11 @@ module IRB # :nodoc:
     ]x
     LOCALE_DIR = "/lc/"
 
-    @@legacy_encoding_alias_map = {}.freeze
+    LEGACY_ENCODING_ALIAS_MAP = {
+      'ujis' => Encoding::EUC_JP,
+      'euc' => Encoding::EUC_JP
+    }
+
     @@loaded = []
 
     def initialize(locale = nil)
@@ -26,11 +30,11 @@ module IRB # :nodoc:
         @lang, @territory, @encoding_name, @modifier = m[:language], m[:territory], m[:codeset], m[:modifier]
 
         if @encoding_name
-          begin load 'irb/encoding_aliases.rb'; rescue LoadError; end
-          if @encoding = @@legacy_encoding_alias_map[@encoding_name]
+          if @encoding = LEGACY_ENCODING_ALIAS_MAP[@encoding_name]
             warn(("%s is obsolete. use %s" % ["#{@lang}_#{@territory}.#{@encoding_name}", "#{@lang}_#{@territory}.#{@encoding.name}"]), uplevel: 1)
+          else
+            @encoding = Encoding.find(@encoding_name) rescue nil
           end
-          @encoding = Encoding.find(@encoding_name) rescue nil
         end
       end
       @encoding ||= (Encoding.find('locale') rescue Encoding::ASCII_8BIT)
@@ -78,39 +82,12 @@ module IRB # :nodoc:
       super(*ary)
     end
 
-    def require(file, priv = nil)
-      rex = Regexp.new("lc/#{Regexp.quote(file)}\.(so|o|sl|rb)?")
-      return false if $".find{|f| f =~ rex}
-
-      case file
-      when /\.rb$/
-        begin
-          load(file, priv)
-          $".push file
-          return true
-        rescue LoadError
-        end
-      when /\.(so|o|sl)$/
-        return super
-      end
-
-      begin
-        load(f = file + ".rb")
-        $".push f  #"
-        return true
-      rescue LoadError
-        return ruby_require(file)
-      end
-    end
-
-    alias toplevel_load load
-
-    def load(file, priv=nil)
+    def load(file)
       found = find(file)
       if found
         unless @@loaded.include?(found)
           @@loaded << found # cache
-          return real_load(found, priv)
+          Kernel.load(found)
         end
       else
         raise LoadError, "No such file to load -- #{file}"
@@ -129,16 +106,6 @@ module IRB # :nodoc:
       end
     end
 
-    private
-    def real_load(path, priv)
-      src = MagicFile.open(path){|f| f.read}
-      if priv
-        eval("self", TOPLEVEL_BINDING).extend(Module.new {eval(src, nil, path)})
-      else
-        eval(src, TOPLEVEL_BINDING, path)
-      end
-    end
-
     # @param paths load paths in which IRB find a localized file.
     # @param dir directory
     # @param file basename to be localized

data/lib/irb/nesting_parser.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+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_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
+            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
+              end
+            end
+            if args.include?(:arg)
+              case t.event
+              when :on_nl, :on_semicolon
+                # def recever.f;
+                body = :normal
+              when :on_lparen
+                # def recever.f()
+                next_args << :eq
+              else
+                if t.event == :on_op && t.tok == '='
+                  # def receiver.f =
+                  body = :oneliner
+                else
+                  # def recever.f arg
+                  next_args << :arg_without_paren
+                end
+              end
+            end
+            if args.include?(:eq)
+              if t.event == :on_op && t.tok == '='
+                body = :oneliner
+              else
+                body = :normal
+              end
+            end
+            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
+            if body == :oneliner
+              opens.pop
+            elsif body
+              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)
+                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 '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 :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
+        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
+        yield t, opens if block_given?
+      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
+
+    # 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 = []
+          end
+        else
+          line_tokens << [t, t.tok]
+        end
+      end
+      output << [line_tokens, prev_opens, last_opens, min_depth] if line_tokens.any?
+      output
+    end
+  end
+end

data/lib/irb/pager.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+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.
+  class Pager
+    PAGE_COMMANDS = [ENV['RI_PAGER'], ENV['PAGER'], 'less', 'more'].compact.uniq
+
+    class << self
+      def page_content(content)
+        if content_exceeds_screen_height?(content)
+          page do |io|
+            io.puts content
+          end
+        else
+          $stdout.puts content
+        end
+      end
+
+      def page
+        if STDIN.tty? && pager = setup_pager
+          begin
+            pid = pager.pid
+            yield pager
+          ensure
+            pager.close
+          end
+        else
+          yield $stdout
+        end
+      # When user presses Ctrl-C, IRB would raise `IRB::Abort`
+      # But since Pager is implemented by running paging commands like `less` in another process with `IO.popen`,
+      # 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
+        nil
+      rescue Errno::EPIPE
+      end
+
+      private
+
+      def content_exceeds_screen_height?(content)
+        screen_height, screen_width = begin
+          Reline.get_screen_size
+        rescue Errno::EINVAL
+          [24, 80]
+        end
+
+        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)
+      end
+
+      def setup_pager
+        require 'shellwords'
+
+        PAGE_COMMANDS.each do |pager|
+          pager = Shellwords.split(pager)
+          next if pager.empty?
+
+          if pager.first == 'less' || pager.first == 'more'
+            pager << '-R' unless pager.include?('-R')
+          end
+
+          begin
+            io = IO.popen(pager, 'w')
+          rescue
+            next
+          end
+
+          if $? && $?.pid == io.pid && $?.exited? # pager didn't work
+            next
+          end
+
+          return io
+        end
+
+        nil
+      end
+    end
+  end
+end