ripper_ruby_parser 1.1.2 → 1.2.0

data/lib/ripper_ruby_parser/sexp_handlers/operators.rb

@@ -1,11 +1,12 @@
 module RipperRubyParser
   module SexpHandlers
+    # Sexp handlers for operators
     module Operators
       BINARY_OPERATOR_MAP = {
-        :"&&" => :and,
-        :"||" => :or,
-        :and => :and,
-        :or => :or
+        '&&': :and,
+        '||': :or,
+        and: :and,
+        or: :or
       }.freeze
 
       UNARY_OPERATOR_MAP = {
@@ -13,10 +14,12 @@ module RipperRubyParser
       }.freeze
 
       NEGATED_BINARY_OPERATOR_MAP = {
-        :"!~" => :=~
+        '!~': :=~
       }.freeze
 
-      def process_binary exp
+      SHIFT_OPERATORS = [:<<, :>>].freeze
+
+      def process_binary(exp)
         _, left, op, right = exp.shift 4
 
         if op == :=~
@@ -25,37 +28,21 @@ module RipperRubyParser
           s(:not, make_regexp_match_operator(mapped, left, right))
         elsif (mapped = BINARY_OPERATOR_MAP[op])
           make_boolean_operator(mapped, left, right)
-        else
+        elsif SHIFT_OPERATORS.include? op
           s(:call, process(left), op, process(right))
-        end
-      end
-
-      def make_boolean_operator op, left, right
-        if left.first == :paren
-          s(op, process(left), process(right))
-        else
-          rebalance_binary(s(op, process(left), process(right)))
-        end
-      end
-
-      def make_regexp_match_operator op, left, right
-        if left.sexp_type == :regexp_literal
-          s(:match2, process(left), process(right))
-        elsif right.sexp_type == :regexp_literal
-          s(:match3, process(right), process(left))
         else
-          s(:call, process(left), op, process(right))
+          s(:call, handle_operator_argument(left), op, handle_operator_argument(right))
         end
       end
 
-      def process_unary exp
+      def process_unary(exp)
         _, op, arg = exp.shift 3
-        arg = process(arg)
+        arg = handle_operator_argument(arg)
         op = UNARY_OPERATOR_MAP[op] || op
         s(:call, arg, op)
       end
 
-      def process_dot2 exp
+      def process_dot2(exp)
         _, left, right = exp.shift 3
         left = process(left)
         right = process(right)
@@ -66,7 +53,7 @@ module RipperRubyParser
         end
       end
 
-      def process_dot3 exp
+      def process_dot3(exp)
         _, left, right = exp.shift 3
         left = process(left)
         right = process(right)
@@ -77,20 +64,45 @@ module RipperRubyParser
         end
       end
 
-      def process_ifop exp
+      def process_ifop(exp)
         _, cond, truepart, falsepart = exp.shift 4
-        s(:if, process(cond), process(truepart), process(falsepart))
+        s(:if,
+          handle_operator_argument(cond),
+          handle_operator_argument(truepart),
+          handle_operator_argument(falsepart))
       end
 
       private
 
-      def rebalance_binary exp
-        op, left, right = exp
+      def make_boolean_operator(op, left, right)
+        _, left, _, right = rebalance_binary(s(:binary, left, op, right))
+        s(op, process(left), handle_operator_argument(right))
+      end
+
+      def make_regexp_match_operator(op, left, right)
+        if left.sexp_type == :regexp_literal
+          s(:match2, process(left), process(right))
+        elsif right.sexp_type == :regexp_literal
+          s(:match3, process(right), process(left))
+        else
+          s(:call, process(left), op, process(right))
+        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
 
-        if op == left.sexp_type
-          s(op, left[1], rebalance_binary(s(op, left[2], right)))
+      def handle_operator_argument(exp)
+        if exp.sexp_type == :begin
+          s(:begin, process(exp))
         else
-          s(op, left, right)
+          process(exp)
         end
       end
     end

data/lib/ripper_ruby_parser/sexp_processor.rb

@@ -3,12 +3,13 @@ require 'ripper_ruby_parser/sexp_handlers'
 
 module RipperRubyParser
   # Processes the sexp created by Ripper to what RubyParser would produce.
+  #
+  # @api private
   class SexpProcessor < ::SexpProcessor
-    attr_accessor :filename
-    attr_accessor :extra_compatible
+    attr_reader :filename
 
-    def initialize
-      super
+    def initialize(filename: nil)
+      super()
 
       # TODO: Find these automatically
 
@@ -28,36 +29,29 @@ module RipperRubyParser
 
       @processors[:@tstring_content] = :process_at_tstring_content
 
+      @filename = filename
+
       @errors = []
 
       @in_method_body = false
     end
 
-    def process exp
-      return nil if exp.nil?
-
-      result = super
-      trickle_up_line_numbers result
-      trickle_down_line_numbers result
-    end
-
     include SexpHandlers
 
-    def process_program exp
+    def process_program(exp)
       _, content = exp.shift 2
 
-      statements = content.map { |sub_exp| process(sub_exp) }
-      safe_wrap_in_block statements
+      process content
     end
 
-    def process_module exp
+    def process_module(exp)
       _, const_ref, body = exp.shift 3
       const, line = const_ref_to_const_with_line_number const_ref
       with_line_number(line,
                        s(:module, const, *class_or_module_body(body)))
     end
 
-    def process_class exp
+    def process_class(exp)
       _, const_ref, parent, body = exp.shift 4
       const, line = const_ref_to_const_with_line_number const_ref
       parent = process(parent)
@@ -65,125 +59,144 @@ module RipperRubyParser
                        s(:class, const, parent, *class_or_module_body(body)))
     end
 
-    def process_sclass exp
+    def process_sclass(exp)
       _, klass, block = exp.shift 3
       s(:sclass, process(klass), *class_or_module_body(block))
     end
 
-    def process_var_ref exp
+    def process_stmts(exp)
+      _, *statements = shift_all(exp)
+      statements = reject_void_stmt map_process_list statements
+      case statements.count
+      when 0
+        s(:void_stmt)
+      when 1
+        statements.first
+      else
+        first = statements.shift
+        if first.sexp_type == :block
+          first.shift
+          s(:block, *first, *statements)
+        else
+          s(:block, first, *statements)
+        end
+      end
+    end
+
+    def process_var_ref(exp)
       _, contents = exp.shift 2
       process(contents)
     end
 
-    def process_var_field exp
+    def process_var_field(exp)
       _, contents = exp.shift 2
       process(contents)
     end
 
-    def process_var_alias exp
+    def process_var_alias(exp)
       _, left, right = exp.shift 3
       s(:valias, left[1].to_sym, right[1].to_sym)
     end
 
-    def process_const_path_ref exp
+    def process_const_path_ref(exp)
       _, left, right = exp.shift 3
       s(:colon2, process(left), extract_node_symbol(right))
     end
 
-    def process_const_path_field exp
+    def process_const_path_field(exp)
       s(:const, process_const_path_ref(exp))
     end
 
-    def process_const_ref exp
+    def process_const_ref(exp)
       _, ref = exp.shift 3
       process(ref)
     end
 
-    def process_top_const_ref exp
+    def process_top_const_ref(exp)
       _, ref = exp.shift 2
       s(:colon3, extract_node_symbol(ref))
     end
 
-    def process_top_const_field exp
+    def process_top_const_field(exp)
       s(:const, process_top_const_ref(exp))
     end
 
-    def process_paren exp
+    def process_paren(exp)
       _, body = exp.shift 2
-      if body.empty?
-        s()
-      elsif body.first.is_a? Symbol
-        process body
+      result = process body
+      if result.sexp_type == :void_stmt
+        s(:nil)
       else
-        body.map! { |it| convert_void_stmt_to_nil process it }
-        safe_wrap_in_block body
+        result
       end
     end
 
-    def process_comment exp
+    def process_comment(exp)
       _, comment, inner = exp.shift 3
       sexp = process(inner)
       sexp.comments = comment
       sexp
     end
 
-    def process_BEGIN exp
+    def process_BEGIN(exp)
       _, body = exp.shift 2
-      s(:iter, s(:preexe), s(:args), *map_body(body))
+      s(:iter, s(:preexe), s(:args), *map_process_sexp_body_compact(body))
     end
 
-    def process_END exp
+    def process_END(exp)
       _, body = exp.shift 2
-      s(:iter, s(:postexe), 0, *map_body(body))
+      s(:iter, s(:postexe), 0, *map_process_sexp_body_compact(body))
     end
 
     # number literals
-    def process_at_int exp
+    def process_at_int(exp)
       make_literal(exp) { |val| Integer(val) }
     end
 
-    def process_at_float exp
+    def process_at_float(exp)
       make_literal(exp, &:to_f)
     end
 
     # character literals
-    def process_at_CHAR exp
+    def process_at_CHAR(exp)
       _, val, pos = exp.shift 3
       with_position(pos, s(:str, unescape(val[1..-1])))
     end
 
-    def process_at_label exp
+    def process_at_label(exp)
       make_literal(exp) { |val| val.chop.to_sym }
     end
 
     # symbol-like sexps
-    def process_at_const exp
+    def process_at_const(exp)
       make_identifier(:const, exp)
     end
 
-    def process_at_cvar exp
+    def process_at_cvar(exp)
       make_identifier(:cvar, exp)
     end
 
-    def process_at_gvar exp
+    def process_at_gvar(exp)
       make_identifier(:gvar, exp)
     end
 
-    def process_at_ivar exp
+    def process_at_ivar(exp)
       make_identifier(:ivar, exp)
     end
 
-    def process_at_ident exp
+    def process_at_ident(exp)
       make_identifier(:lvar, exp)
     end
 
-    def process_at_op exp
+    def process_at_op(exp)
       make_identifier(:op, exp)
     end
 
-    def process_at_kw exp
+    def process_at_kw(exp)
       sym, pos = extract_node_symbol_with_position(exp)
       result = case sym
+               when :__ENCODING__
+                 s(:colon2, s(:const, :Encoding), :UTF_8)
                when :__FILE__
                  s(:str, @filename)
                when :__LINE__
@@ -194,7 +207,7 @@ module RipperRubyParser
       with_position(pos, result)
     end
 
-    def process_at_backref exp
+    def process_at_backref(exp)
       _, str, pos = exp.shift 3
       name = str[1..-1]
       with_position pos do
@@ -208,59 +221,33 @@ module RipperRubyParser
 
     private
 
-    def const_ref_to_const_with_line_number const_ref
+    def const_ref_to_const_with_line_number(const_ref)
       const = process(const_ref)
       line = const.line
       const = const[1] if const.sexp_type == :const
       return const, line
     end
 
-    def class_or_module_body exp
+    def class_or_module_body(exp)
       body = process(exp)
 
-      if body.length == 1 && body.first.sexp_type == :block
-        body = body.first
-        body.shift
+      return body if body.empty?
+      if body.sexp_type == :block
+        body.sexp_body
+      else
+        [body]
       end
-
-      body
     end
 
-    def make_identifier type, exp
+    def make_identifier(type, exp)
       with_position_from_node_symbol(exp) do |ident|
         s(type, ident)
       end
     end
 
-    def make_literal exp
+    def make_literal(exp)
       _, val, pos = exp.shift 3
       with_position(pos, s(:lit, yield(val)))
     end
-
-    def trickle_up_line_numbers exp
-      exp.each do |sub_exp|
-        if sub_exp.is_a? Sexp
-          trickle_up_line_numbers sub_exp
-          exp.line ||= sub_exp.line
-        end
-      end
-    end
-
-    def trickle_down_line_numbers exp
-      exp.each do |sub_exp|
-        if sub_exp.is_a? Sexp
-          sub_exp.line ||= exp.line
-          trickle_down_line_numbers sub_exp
-        end
-      end
-    end
-
-    def convert_void_stmt_to_nil sexp
-      if sexp == s(:void_stmt)
-        s(:nil)
-      else
-        sexp
-      end
-    end
   end
 end

data/lib/ripper_ruby_parser/version.rb

@@ -1,3 +1,3 @@
 module RipperRubyParser
-  VERSION = '1.1.2'.freeze
+  VERSION = '1.2.0'.freeze
 end