ripper_ruby_parser 1.4.2 → 1.5.0

data/lib/ripper_ruby_parser/sexp_handlers/loops.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RipperRubyParser
   module SexpHandlers
     # Sexp handlers for loops
@@ -21,12 +23,14 @@ module RipperRubyParser
       def process_for(exp)
         _, var, coll, block = exp.shift 4
         coll = process(coll)
-        assgn = s(:lasgn, process(var)[1])
+        var = process(var)
+
+        var.sexp_type = :lasgn if var.sexp_type == :lvar
         block = unwrap_nil process(block)
         if block
-          s(:for, coll, assgn, block)
+          s(:for, coll, var, block)
         else
-          s(:for, coll, assgn)
+          s(:for, coll, var)
         end
       end
 
@@ -40,7 +44,7 @@ module RipperRubyParser
         _, cond, body = exp.shift 3
 
         construct_conditional_loop(type, negated_type,
-                                   process(cond),
+                                   unwrap_begin(process(cond)),
                                    unwrap_nil(process(body)),
                                    true)
       end
@@ -50,8 +54,8 @@ module RipperRubyParser
 
         check_at_start = check_at_start?(body)
         construct_conditional_loop(type, negated_type,
-                                   process(cond),
-                                   process(body),
+                                   unwrap_begin(process(cond)),
+                                   unwrap_begin(process(body)),
                                    check_at_start)
       end
 

data/lib/ripper_ruby_parser/sexp_handlers/method_calls.rb

@@ -1,18 +1,38 @@
+# frozen_string_literal: true
+
 module RipperRubyParser
   module SexpHandlers
     # Sexp handlers for method calls
     module MethodCalls
+      def process_args_add_star(exp)
+        generic_add_star exp
+      end
+
+      def process_args_add_block(exp)
+        _, regular, block = exp.shift 3
+        args = process(regular)
+        args << s(:block_pass, process(block)) if block
+        args
+      end
+
+      def process_arg_paren(exp)
+        _, args = exp.shift 2
+        return s() if args.nil?
+
+        process(args)
+      end
+
       def process_method_add_arg(exp)
         _, call, parens = exp.shift 3
         call = process(call)
-        unless parens.empty?
-          parens = process(parens)
-          parens.shift
-        end
-        parens.each do |arg|
-          call << arg
-        end
-        call
+        parens = process(parens)
+        call.push(*parens.sexp_body)
+      end
+
+      # Handle implied hashes, such as at the end of argument lists.
+      def process_bare_assoc_hash(exp)
+        _, elems = exp.shift 2
+        s(:hash, *make_hash_items(elems))
       end
 
       CALL_OP_MAP = {
@@ -23,13 +43,13 @@ module RipperRubyParser
 
       def process_call(exp)
         _, receiver, op, ident = exp.shift 4
-        type = CALL_OP_MAP.fetch op
+        type = map_call_op op
         case ident
         when :call
           s(type, process(receiver), :call)
         else
           with_position_from_node_symbol(ident) do |method|
-            s(type, process(receiver), method)
+            s(type, unwrap_begin(process(receiver)), method)
           end
         end
       end
@@ -37,24 +57,33 @@ module RipperRubyParser
       def process_command(exp)
         _, ident, arglist = exp.shift 3
         with_position_from_node_symbol(ident) do |method|
-          args = handle_argument_list(arglist)
+          args = process(arglist).sexp_body
           s(:call, nil, method, *args)
         end
       end
 
       def process_command_call(exp)
         _, receiver, op, ident, arguments = exp.shift 5
-        type = CALL_OP_MAP.fetch op
+        type = map_call_op op
         with_position_from_node_symbol(ident) do |method|
-          args = handle_argument_list(arguments)
+          args = process(arguments).sexp_body
           s(type, process(receiver), method, *args)
         end
       end
 
+      def map_call_op(call_op)
+        call_op = call_op.sexp_body.first.to_sym if call_op.is_a? Sexp
+        CALL_OP_MAP.fetch(call_op)
+      end
+
       def process_vcall(exp)
         _, ident = exp.shift 2
         with_position_from_node_symbol(ident) do |method|
-          s(:call, nil, method)
+          if replace_kwrest_arg_call? method
+            s(:lvar, method)
+          else
+            s(:call, nil, method)
+          end
         end
       end
 
@@ -65,12 +94,28 @@ module RipperRubyParser
         end
       end
 
+      def process_aref(exp)
+        _, coll, idx = exp.shift 3
+
+        coll = process(coll)
+        idx = process(idx) || []
+        idx.shift
+        s(:call, coll, :[], *idx)
+      end
+
       def process_super(exp)
         _, args = exp.shift 2
         args = process(args)
         args.shift
         s(:super, *args)
       end
+
+      private
+
+      def replace_kwrest_arg_call?(method)
+        method_kwrest_arg?(method) ||
+          !extra_compatible && block_kwrest_arg?(method)
+      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/methods.rb

@@ -1,23 +1,36 @@
+# frozen_string_literal: true
+
 module RipperRubyParser
   module SexpHandlers
     # Sexp handers for method definitions and related constructs
     module Methods
       def process_def(exp)
         _, ident, params, body = exp.shift 4
+
         ident, pos = extract_node_symbol_with_position ident
-        params = convert_special_args(process(params))
-        with_position(pos,
-                      s(:defn, ident, params, *method_body(body)))
+
+        in_method do
+          params = convert_method_args(process(params))
+          kwrest = kwrest_param(params)
+          body = with_kwrest(kwrest) { method_body(body) }
+        end
+
+        with_position(pos, s(:defn, ident, params, *body))
       end
 
       def process_defs(exp)
         _, receiver, _, method, params, body = exp.shift 6
-        params = convert_special_args(process(params))
+
+        in_method do
+          params = convert_method_args(process(params))
+          kwrest = kwrest_param(params)
+          body = with_kwrest(kwrest) { method_body(body) }
+        end
 
         s(:defs,
           process(receiver),
-          extract_node_symbol(method),
-          params, *method_body(body))
+          extract_node_symbol(process(method)),
+          params, *body)
       end
 
       def process_return(exp)
@@ -26,17 +39,17 @@ module RipperRubyParser
       end
 
       def process_return0(exp)
-        _ = exp.shift
+        exp.shift
         s(:return)
       end
 
       def process_yield(exp)
         _, arglist = exp.shift 2
-        s(:yield, *handle_argument_list(arglist))
+        s(:yield, *process(arglist).sexp_body)
       end
 
       def process_yield0(exp)
-        _ = exp.shift
+        exp.shift
         s(:yield)
       end
 
@@ -44,11 +57,11 @@ module RipperRubyParser
         _, args = exp.shift 2
 
         args.map! do |sub_exp|
-          s(:undef, make_method_name_literal(sub_exp))
+          s(:undef, process(sub_exp))
         end
 
         if args.size == 1
-          args[0]
+          args.first
         else
           s(:block, *args)
         end
@@ -57,9 +70,7 @@ module RipperRubyParser
       def process_alias(exp)
         _, left, right = exp.shift 3
 
-        s(:alias,
-          make_method_name_literal(left),
-          make_method_name_literal(right))
+        s(:alias, process(left), process(right))
       end
 
       private
@@ -71,12 +82,8 @@ module RipperRubyParser
         result
       end
 
-      def make_method_name_literal(exp)
-        process(exp).tap { |it| it[0] = :lit }
-      end
-
       def method_body(exp)
-        block = in_method { process exp }
+        block = process exp
         case block.length
         when 0
           [s(:nil)]
@@ -95,27 +102,17 @@ module RipperRubyParser
         blockarg: '&'
       }.freeze
 
-      def convert_special_args(args)
+      def convert_method_args(args)
         args.map! do |item|
           if item.is_a? Symbol
             item
           else
             case item.sexp_type
             when :lvar
-              item[1]
-            when :masgn
-              args = item[1]
-              args.shift
-              s(:masgn, *convert_special_args(args))
-            when :lasgn
-              if item.length == 2
-                item[1]
-              else
-                item
-              end
+              item.last
             when *SPECIAL_ARG_MARKER.keys
               marker = SPECIAL_ARG_MARKER[item.sexp_type]
-              name = extract_node_symbol item[1]
+              name = extract_node_symbol item.last
               :"#{marker}#{name}"
             else
               item
@@ -123,6 +120,33 @@ module RipperRubyParser
           end
         end
       end
+
+      def kwrest_param(params)
+        found = params.find { |param| param.to_s =~ /^\*\*(.+)/ }
+        Regexp.last_match[1].to_sym if found
+      end
+
+      def with_kwrest(kwrest)
+        @kwrest.push kwrest
+        result = yield
+        @kwrest.pop
+        result
+      end
+
+      def with_block_kwrest(kwrest)
+        @block_kwrest.push kwrest
+        result = yield
+        @block_kwrest.pop
+        result
+      end
+
+      def method_kwrest_arg?(method)
+        @kwrest.include?(method)
+      end
+
+      def block_kwrest_arg?(method)
+        @block_kwrest.include?(method)
+      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/operators.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RipperRubyParser
   module SexpHandlers
     # Sexp handlers for operators
@@ -23,21 +25,21 @@ module RipperRubyParser
         _, left, op, right = exp.shift 4
 
         if op == :=~
-          make_regexp_match_operator(op, left, right)
+          make_regexp_match_operator(left, op, right)
         elsif (mapped = NEGATED_BINARY_OPERATOR_MAP[op])
-          s(:not, make_regexp_match_operator(mapped, left, right))
+          s(:not, make_regexp_match_operator(left, mapped, right))
         elsif (mapped = BINARY_OPERATOR_MAP[op])
-          make_boolean_operator(mapped, left, right)
+          make_boolean_operator(left, mapped, right)
         elsif SHIFT_OPERATORS.include? op
-          s(:call, process(left), op, process(right))
+          s(:call, unwrap_begin(process(left)), op, unwrap_begin(process(right)))
         else
-          s(:call, handle_operator_argument(left), op, handle_operator_argument(right))
+          s(:call, process(left), op, process(right))
         end
       end
 
       def process_unary(exp)
         _, op, arg = exp.shift 3
-        arg = handle_operator_argument(arg)
+        arg = process(arg)
         op = UNARY_OPERATOR_MAP[op] || op
         s(:call, arg, op)
       end
@@ -67,19 +69,19 @@ module RipperRubyParser
       def process_ifop(exp)
         _, cond, truepart, falsepart = exp.shift 4
         s(:if,
-          handle_operator_argument(cond),
-          handle_operator_argument(truepart),
-          handle_operator_argument(falsepart))
+          process(cond),
+          process(truepart),
+          process(falsepart))
       end
 
       private
 
-      def make_boolean_operator(operator, left, right)
-        _, left, _, right = rebalance_binary(s(:binary, left, operator, right))
-        s(operator, process(left), handle_operator_argument(right))
+      def make_boolean_operator(left, operator, right)
+        _, left, _, right = rebalance_binary(left, operator, right)
+        s(operator, unwrap_begin(process(left)), process(right))
       end
 
-      def make_regexp_match_operator(operator, left, right)
+      def make_regexp_match_operator(left, operator, right)
         if left.sexp_type == :regexp_literal
           s(:match2, process(left), process(right))
         elsif right.sexp_type == :regexp_literal
@@ -89,21 +91,12 @@ module RipperRubyParser
         end
       end
 
-      def rebalance_binary(exp)
-        _, left, op, right = exp
-        if left.sexp_type == :binary && BINARY_OPERATOR_MAP[op] == BINARY_OPERATOR_MAP[left[2]]
-          _, left, _, middle = rebalance_binary(left)
-          right = rebalance_binary(s(:binary, middle, op, right))
-        end
-        s(:binary, left, op, right)
-      end
-
-      def handle_operator_argument(exp)
-        if exp.sexp_type == :begin
-          s(:begin, process(exp))
-        else
-          process(exp)
+      def rebalance_binary(left, operator, right)
+        if BINARY_OPERATOR_MAP[operator] == BINARY_OPERATOR_MAP[left[2]]
+          _, left, _, middle = rebalance_binary(*left.sexp_body)
+          right = rebalance_binary(middle, operator, right)
         end
+        s(:binary, left, operator, right)
       end
     end
   end

data/lib/ripper_ruby_parser/sexp_processor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'sexp_processor'
 require 'ripper_ruby_parser/sexp_handlers'
 require 'ripper_ruby_parser/unescape'
@@ -7,15 +9,17 @@ module RipperRubyParser
   #
   # @api private
   class SexpProcessor < ::SexpProcessor
+    include Unescape
+
     attr_reader :filename
+    attr_reader :extra_compatible
 
-    def initialize(filename: nil)
+    def initialize(filename: nil, extra_compatible: nil)
       super()
 
-      # TODO: Find these automatically
-
       @processors[:@int] = :process_at_int
       @processors[:@float] = :process_at_float
+      @processors[:@rational] = :process_at_rational
       @processors[:@CHAR] = :process_at_CHAR
       @processors[:@label] = :process_at_label
 
@@ -27,14 +31,18 @@ module RipperRubyParser
       @processors[:@kw] = :process_at_kw
       @processors[:@op] = :process_at_op
       @processors[:@backref] = :process_at_backref
+      @processors[:@period] = :process_at_period
 
       @processors[:@tstring_content] = :process_at_tstring_content
 
       @filename = filename
+      @extra_compatible = extra_compatible
 
       @errors = []
 
       @in_method_body = false
+      @kwrest = []
+      @block_kwrest = []
     end
 
     include SexpHandlers
@@ -67,7 +75,7 @@ module RipperRubyParser
 
     def process_stmts(exp)
       _, *statements = shift_all(exp)
-      statements = reject_void_stmt map_process_list statements
+      statements = map_process_list_compact statements
       case statements.count
       when 0
         s(:void_stmt)
@@ -101,7 +109,7 @@ module RipperRubyParser
 
     def process_const_path_ref(exp)
       _, left, right = exp.shift 3
-      s(:colon2, process(left), extract_node_symbol(right))
+      s(:colon2, process(left), extract_node_symbol(process(right)))
     end
 
     def process_const_path_field(exp)
@@ -115,7 +123,7 @@ module RipperRubyParser
 
     def process_top_const_ref(exp)
       _, ref = exp.shift 2
-      s(:colon3, extract_node_symbol(ref))
+      s(:colon3, extract_node_symbol(process(ref)))
     end
 
     def process_top_const_field(exp)
@@ -141,12 +149,14 @@ module RipperRubyParser
 
     def process_BEGIN(exp)
       _, body = exp.shift 2
-      s(:iter, s(:preexe), s(:args), *map_process_sexp_body_compact(body))
+      body = reject_void_stmt map_process_list body.sexp_body
+      s(:iter, s(:preexe), s(:args), *body)
     end
 
     def process_END(exp)
       _, body = exp.shift 2
-      s(:iter, s(:postexe), 0, *map_process_sexp_body_compact(body))
+      body = map_process_list_compact body.sexp_body
+      s(:iter, s(:postexe), 0, *body)
     end
 
     # number literals
@@ -158,10 +168,14 @@ module RipperRubyParser
       make_literal(exp, &:to_f)
     end
 
+    def process_at_rational(exp)
+      make_literal(exp, &:to_r)
+    end
+
     # character literals
     def process_at_CHAR(exp)
       _, val, pos = exp.shift 3
-      with_position(pos, s(:str, Unescape.unescape(val[1..-1])))
+      with_position(pos, s(:str, unescape(val[1..-1])))
     end
 
     def process_at_label(exp)
@@ -186,7 +200,13 @@ module RipperRubyParser
     end
 
     def process_at_ident(exp)
-      make_identifier(:lvar, exp)
+      with_position_from_node_symbol(exp) do |ident|
+        if replace_kwrest_arg_lvar? ident
+          s(:call, nil, ident)
+        else
+          s(:lvar, ident)
+        end
+      end
     end
 
     def process_at_op(exp)
@@ -220,6 +240,11 @@ module RipperRubyParser
       end
     end
 
+    def process_at_period(exp)
+      _, period, = exp.shift 3
+      s(:period, period)
+    end
+
     private
 
     def const_ref_to_const_with_line_number(const_ref)
@@ -233,6 +258,7 @@ module RipperRubyParser
       body = process(exp)
 
       return body if body.empty?
+
       if body.sexp_type == :block
         body.sexp_body
       else
@@ -250,5 +276,9 @@ module RipperRubyParser
       _, val, pos = exp.shift 3
       with_position(pos, s(:lit, yield(val)))
     end
+
+    def replace_kwrest_arg_lvar?(ident)
+      extra_compatible && @block_kwrest.include?(ident)
+    end
   end
 end