ripper_ruby_parser 1.4.2 → 1.5.0

data/lib/ripper_ruby_parser/sexp_handlers/blocks.rb

@@ -1,29 +1,23 @@
+# frozen_string_literal: true
+
 module RipperRubyParser
   module SexpHandlers
     # Sexp handlers for blocks and related constructs
     module Blocks
       def process_method_add_block(exp)
         _, call, block = exp.shift 3
-        block = process(block)
         _, args, stmt = block
         call = process(call)
-        stmts = stmt.first || s()
-        make_iter call, args, stmts
-      end
-
-      def process_brace_block(exp)
-        handle_generic_block exp
-      end
-
-      def process_do_block(exp)
-        handle_generic_block exp
+        args = process(args)
+        kwrest = kwrest_param(args) if args
+        stmt = with_block_kwrest(kwrest) { process(stmt) }
+        make_iter call, args, safe_unwrap_void_stmt(stmt)
       end
 
       def process_params(exp)
         _, normal, defaults, splat, rest, kwargs, doublesplat, block = exp.shift 8
 
-        args = []
-        args += handle_normal_arguments normal
+        args = handle_normal_arguments normal
         args += handle_default_arguments defaults
         args += handle_splat splat
         args += handle_normal_arguments rest
@@ -34,6 +28,11 @@ module RipperRubyParser
         s(:args, *args)
       end
 
+      def process_rest_param(exp)
+        _, ident = exp.shift 2
+        s(:splat, process(ident))
+      end
+
       def process_kwrest_param(exp)
         _, sym, = exp.shift 3
         process(sym)
@@ -44,34 +43,41 @@ module RipperRubyParser
 
         names = process(args)
 
-        convert_special_args names
+        convert_block_args names
       end
 
       def process_begin(exp)
         _, body = exp.shift 2
 
-        body = process(body)
-        convert_empty_to_nil_symbol(body)
+        body = convert_empty_to_nil_symbol process(body)
+        s(:begin, body)
       end
 
       def process_rescue(exp)
         _, eclass, evar, block, after = exp.shift 5
-        rescue_block = map_process_sexp_body_compact(block)
+        rescue_block = map_process_list_compact block.sexp_body
         rescue_block << nil if rescue_block.empty?
 
-        arr = []
-        if eclass
-          if eclass.first.is_a? Symbol
-            arr += process(eclass).sexp_body
-          else
-            arr << process(eclass[0])
-          end
-        end
-
-        arr << create_assignment_sub_type(process(evar), s(:gvar, :$!)) if evar
+        capture = if eclass
+                    if eclass.first.is_a? Symbol
+                      eclass = process(eclass)
+                      body = eclass.sexp_body
+                      if eclass.sexp_type == :mrhs
+                        body.first
+                      else
+                        s(:array, *body)
+                      end
+                    else
+                      s(:array, process(eclass.first))
+                    end
+                  else
+                    s(:array)
+                  end
+
+        capture << create_assignment_sub_type(process(evar), s(:gvar, :$!)) if evar
 
         s(
-          s(:resbody, s(:array, *arr), *rescue_block),
+          s(:resbody, capture, *rescue_block),
           *process(after))
       end
 
@@ -80,7 +86,7 @@ module RipperRubyParser
 
         body = s()
 
-        main = wrap_in_block map_process_sexp_body_compact(main)
+        main = wrap_in_block map_process_list_compact main.sexp_body
         body << main if main
 
         if rescue_block
@@ -132,8 +138,8 @@ module RipperRubyParser
       def process_lambda(exp)
         _, args, statements = exp.shift 3
         old_type = args.sexp_type
-        args = convert_special_args(process(args))
-        args = 0 if args == s(:args) && old_type == :params
+        args = convert_method_args(process(args))
+        args = nil if args == s(:args) && old_type == :params
         make_iter(s(:call, nil, :lambda),
                   args,
                   safe_unwrap_void_stmt(process(statements)))
@@ -141,20 +147,20 @@ module RipperRubyParser
 
       private
 
-      def handle_generic_block(exp)
-        type, args, stmts = exp.shift 3
-        args = process(args)
-        s(type, args, s(unwrap_nil(process(stmts))))
-      end
-
       def handle_normal_arguments(normal)
         return [] unless normal
+
         map_process_list normal
       end
 
       def handle_default_arguments(defaults)
         return [] unless defaults
-        defaults.map { |sym, val| s(:lasgn, process(sym)[1], process(val)) }
+
+        defaults.map do |sym, val|
+          s(:lasgn,
+            extract_node_symbol(process(sym)),
+            process(val))
+        end
       end
 
       def handle_splat(splat)
@@ -167,8 +173,9 @@ module RipperRubyParser
 
       def handle_kwargs(kwargs)
         return [] unless kwargs
+
         kwargs.map do |sym, val|
-          symbol = process(sym)[1]
+          symbol = extract_node_symbol process(sym)
           if val
             s(:kwarg, symbol, process(val))
           else
@@ -179,11 +186,13 @@ module RipperRubyParser
 
       def handle_double_splat(doublesplat)
         return [] unless doublesplat
+
         [s(:dsplat, process(doublesplat))]
       end
 
       def handle_block_argument(block)
         return [] unless block
+
         [process(block)]
       end
 
@@ -197,6 +206,7 @@ module RipperRubyParser
       end
 
       def make_iter(call, args, stmt)
+        args.pop if args && args.last == s(:excessed_comma)
         args ||= 0
         if stmt.empty?
           s(:iter, call, args)
@@ -215,6 +225,35 @@ module RipperRubyParser
           s(:block, *statements)
         end
       end
+
+      def convert_block_args(args)
+        args.map! do |item|
+          if item.is_a? Symbol
+            item
+          else
+            case item.sexp_type
+            when :lvar
+              item.last
+            when :masgn
+              args = item[1]
+              args.shift
+              s(:masgn, *convert_block_args(args))
+            when :lasgn
+              if item.length == 2
+                item[1]
+              else
+                item
+              end
+            when *Methods::SPECIAL_ARG_MARKER.keys
+              marker = Methods::SPECIAL_ARG_MARKER[item.sexp_type]
+              name = extract_node_symbol item[1]
+              :"#{marker}#{name}"
+            else
+              item
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/conditionals.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RipperRubyParser
   module SexpHandlers
     # Sexp handlers for conditionals
@@ -14,7 +16,7 @@ module RipperRubyParser
         _, cond, truepart, falsepart = exp.shift 4
 
         s(:if,
-          process(cond),
+          unwrap_begin(process(cond)),
           handle_consequent(truepart),
           handle_consequent(falsepart))
       end
@@ -23,7 +25,7 @@ module RipperRubyParser
         _, cond, truepart = exp.shift 3
 
         construct_conditional(handle_condition(cond),
-                              handle_operator_argument(truepart),
+                              process(truepart),
                               nil)
       end
 
@@ -40,7 +42,7 @@ module RipperRubyParser
 
         construct_conditional(handle_condition(cond),
                               nil,
-                              handle_operator_argument(truepart))
+                              process(truepart))
       end
 
       def process_case(exp)
@@ -59,11 +61,10 @@ module RipperRubyParser
         elsif falsepart.first.is_a? Symbol
           falsepart = s(falsepart)
         end
-        falsepart = [nil] if falsepart.empty?
 
-        values = handle_argument_list values
+        values = process(values).sexp_body
 
-        truepart = map_process_sexp_body_compact(truepart)
+        truepart = map_process_list_compact truepart.sexp_body
         truepart = [nil] if truepart.empty?
 
         s(s(:when,
@@ -80,16 +81,16 @@ module RipperRubyParser
       private
 
       def handle_condition(cond)
-        cond = process(cond)
-        if (cond.sexp_type == :lit) && cond[1].is_a?(Regexp)
-          s(:match, cond)
-        elsif cond.sexp_type == :dot2
-          s(:flip2, *cond[1..-1])
-        elsif cond.sexp_type == :dot3
-          s(:flip3, *cond[1..-1])
-        else
-          cond
+        cond = unwrap_begin process(cond)
+        case cond.sexp_type
+        when :lit
+          return s(:match, cond) if cond.last.is_a?(Regexp)
+        when :dot2
+          return s(:flip2, *cond.sexp_body)
+        when :dot3
+          return s(:flip3, *cond.sexp_body)
         end
+        cond
       end
 
       def handle_consequent(exp)

data/lib/ripper_ruby_parser/sexp_handlers/helper_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RipperRubyParser
   module SexpHandlers
     # Utility methods used in several of the sexp handler modules
@@ -9,7 +11,9 @@ module RipperRubyParser
 
       def extract_node_symbol(exp)
         return nil if exp.nil?
-        _, ident, = exp.shift 3
+        raise "Unexpected number of children: #{exp.length}" if exp.length != 2
+
+        _, ident = exp.shift 2
         ident.to_sym
       end
 
@@ -32,7 +36,7 @@ module RipperRubyParser
       def generic_add_star(exp)
         _, args, splatarg, *rest = shift_all exp
         items = process args
-        items.push s(:splat, process(splatarg))
+        items.push s(:splat, unwrap_begin(process(splatarg)))
         items.push(*map_process_list(rest))
       end
 
@@ -44,18 +48,18 @@ module RipperRubyParser
         body.reject { |sub_exp| sub_exp.sexp_type == :void_stmt }
       end
 
-      def map_process_sexp_body_compact(list)
-        reject_void_stmt map_process_sexp_body list
-      end
-
-      def map_process_sexp_body(list)
-        map_process_list(list.sexp_body)
+      def map_process_list_compact(list)
+        reject_void_stmt map_unwrap_begin_list map_process_list list
       end
 
       def map_process_list(list)
         list.map { |exp| process(exp) }
       end
 
+      def map_unwrap_begin_list(list)
+        list.map { |exp| unwrap_begin(exp) }
+      end
+
       def unwrap_nil(exp)
         if exp.sexp_type == :void_stmt
           nil
@@ -68,12 +72,16 @@ module RipperRubyParser
         unwrap_nil(exp) || s()
       end
 
-      def handle_argument_list(exp)
-        process(exp).tap(&:shift)
+      def unwrap_begin(exp)
+        if exp.sexp_type == :begin
+          exp[1]
+        else
+          exp
+        end
       end
 
       def handle_return_argument_list(arglist)
-        args = handle_argument_list(arglist)
+        args = process(arglist).sexp_body
 
         case args.length
         when 0
@@ -90,10 +98,6 @@ module RipperRubyParser
         end
       end
 
-      def handle_array_elements(elems)
-        process(elems).sexp_body
-      end
-
       def shift_all(exp)
         [].tap do |result|
           result << exp.shift until exp.empty?

data/lib/ripper_ruby_parser/sexp_handlers/literals.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module RipperRubyParser
   module SexpHandlers
-    # Sexp handlers for literals, except hash and array literals
+    # Sexp handlers for literals
     module Literals
       def process_string_literal(exp)
         _, content = exp.shift 2
@@ -29,16 +31,16 @@ module RipperRubyParser
         when :str
           val
         when :void_stmt
-          s(:dstr, '', s(:evstr))
+          s(:dstr, s(:evstr))
         else
-          s(:dstr, '', s(:evstr, val))
+          s(:dstr, s(:evstr, val))
         end
       end
 
       def process_string_dvar(exp)
         _, list = exp.shift 2
         val = process(list)
-        s(:dstr, '', s(:evstr, val))
+        s(:dstr, s(:evstr, val))
       end
 
       def process_string_concat(exp)
@@ -72,31 +74,25 @@ module RipperRubyParser
       def process_regexp_literal(exp)
         _, content, (_, flags,) = exp.shift 3
 
-        string, rest = process(content).sexp_body
+        content = process(content)
         numflags = character_flags_to_numerical flags
 
-        if rest.empty?
-          s(:lit, Regexp.new(string, numflags))
-        else
-          rest << numflags if numflags > 0
-          sexp_type = if flags =~ /o/
-                        :dregx_once
-                      else
-                        :dregx
-                      end
-          s(sexp_type, string, *rest)
-        end
+        return s(:lit, Regexp.new(content.last, numflags)) if content.length == 2
+
+        content.sexp_type = :dregx_once if flags =~ /o/
+        content << numflags unless numflags == 0
+        content
       end
 
       def process_regexp(exp)
         _, *rest = shift_all exp
         string, rest = extract_string_parts(rest)
-        s(:regexp, string, rest)
+        s(:dregx, string, *rest)
       end
 
       def process_symbol_literal(exp)
         _, symbol = exp.shift 2
-        process(symbol)
+        handle_symbol_content(symbol)
       end
 
       def process_symbol(exp)
@@ -121,20 +117,70 @@ module RipperRubyParser
         s(:symbols, *items)
       end
 
+      INTERPOLATING_HEREDOC = /^<<[-~]?[^-~']/.freeze
+      NON_INTERPOLATING_HEREDOC = /^<<[-~]?'/.freeze
+      INTERPOLATING_STRINGS = ['"', '`', ':"', /^%Q.$/, /^%.$/].freeze
+      NON_INTERPOLATING_STRINGS = ["'", ":'", /^%q.$/].freeze
+      INTERPOLATING_WORD_LIST = /^%[WI].$/.freeze
+      NON_INTERPOLATING_WORD_LIST = /^%[wi].$/.freeze
+      REGEXP_LITERALS = ['/', /^%r.$/].freeze
+
       def process_at_tstring_content(exp)
-        _, string, = exp.shift 3
+        _, content, _, delim = exp.shift 4
+        string = handle_string_unescaping(content, delim)
+        string = handle_string_encoding(string, delim)
         s(:str, string)
       end
 
+      def process_array(exp)
+        _, elems = exp.shift 2
+        return s(:array) if elems.nil?
+
+        process(elems).tap { |arr| arr.sexp_type = :array }
+      end
+
+      # Handle hash literals sexps. These can be either empty, or contain a
+      # nested :assoclist_from_args Sexp.
+      #
+      # @example Empty hash
+      #   s(:hash, nil)
+      # @example Hash with contents
+      #   s(:hash, s(:assoclist_from_args, ...))
+      def process_hash(exp)
+        _, body = exp.shift 2
+        return s(:hash) unless body
+
+        _, elems = body
+        s(:hash, *make_hash_items(elems))
+      end
+
+      # @example
+      #   s(:assoc_splat, s(:vcall, s(:@ident, "bar")))
+      def process_assoc_splat(exp)
+        _, param = exp.shift 2
+        s(:kwsplat, process(param))
+      end
+
       private
 
       def extract_string_parts(list)
-        parts = map_process_list list
+        parts = []
+
+        unless list.empty?
+          parts << process(list.shift)
+          list.each do |item|
+            parts << if extra_compatible && item.sexp_type == :@tstring_content
+                       alternative_process_at_tstring_content(item)
+                     else
+                       process(item)
+                     end
+          end
+        end
 
         string = ''
         while !parts.empty? && parts.first.sexp_type == :str
           str = parts.shift
-          string += str[1]
+          string += str.last
         end
 
         rest = parts.map { |se| se.sexp_type == :dstr ? se.last : se }
@@ -142,15 +188,27 @@ module RipperRubyParser
         return string, rest
       end
 
+      def alternative_process_at_tstring_content(exp)
+        _, content, _, delim = exp.shift 4
+        string = case delim
+                 when *INTERPOLATING_STRINGS
+                   unescape(content)
+                 else
+                   content
+                 end
+        string.force_encoding('ascii-8bit') if string == "\0"
+        s(:str, string)
+      end
+
       def character_flags_to_numerical(flags)
         numflags = 0
 
-        flags =~ /m/ and numflags |= Regexp::MULTILINE
-        flags =~ /x/ and numflags |= Regexp::EXTENDED
-        flags =~ /i/ and numflags |= Regexp::IGNORECASE
+        numflags = Regexp::MULTILINE if flags =~ /m/
+        numflags |= Regexp::EXTENDED if flags =~ /x/
+        numflags |= Regexp::IGNORECASE if flags =~ /i/
 
-        flags =~ /n/ and numflags |= Regexp::NOENCODING
-        flags =~ /[ues]/ and numflags |= Regexp::FIXEDENCODING
+        numflags |= Regexp::NOENCODING if flags =~ /n/
+        numflags |= Regexp::FIXEDENCODING if flags =~ /[ues]/
 
         numflags
       end
@@ -162,17 +220,22 @@ module RipperRubyParser
           s(:lit, body.first.to_sym)
         when :dstr, :dxstr
           s(:dsym, *body)
-        else
-          raise type.to_s
         end
       end
 
       def handle_symbol_content(node)
-        with_position_from_node_symbol(node) { |sym| s(:lit, sym) }
+        if node.sexp_type == :'@kw'
+          symbol, position = extract_node_symbol_with_position(node)
+        else
+          processed = process(node)
+          symbol = processed.last.to_sym
+          position = processed.line
+        end
+        with_line_number(position, s(:lit, symbol))
       end
 
       def merge_left_into_right(left, right)
-        right[1] = left[1] + right[1]
+        right[1] = left.last + right[1]
         right
       end
 
@@ -185,6 +248,51 @@ module RipperRubyParser
           left.push(*rest)
         end
       end
+
+      def handle_string_unescaping(content, delim)
+        case delim
+        when INTERPOLATING_HEREDOC, *INTERPOLATING_STRINGS
+          unescape(content)
+        when INTERPOLATING_WORD_LIST
+          unescape_wordlist_word(content)
+        when *NON_INTERPOLATING_STRINGS
+          simple_unescape(content)
+        when *REGEXP_LITERALS
+          unescape_regexp(content)
+        when NON_INTERPOLATING_WORD_LIST
+          simple_unescape_wordlist_word(content)
+        else
+          content
+        end
+      end
+
+      def handle_string_encoding(string, delim)
+        case delim
+        when INTERPOLATING_HEREDOC, INTERPOLATING_WORD_LIST
+          if extra_compatible
+            string
+          else
+            fix_encoding string
+          end
+        when *INTERPOLATING_STRINGS
+          fix_encoding string
+        else
+          string
+        end
+      end
+
+      # Process list of items that can be either :assoc_new or :assoc_splat
+      def make_hash_items(elems)
+        result = s()
+        elems.each do |sub_exp|
+          if sub_exp.sexp_type == :assoc_new
+            sub_exp.sexp_body.each { |elem| result << process(elem) }
+          else # :assoc_splat
+            result << process(sub_exp)
+          end
+        end
+        result
+      end
     end
   end
 end