ripper_ruby_parser 0.0.1 → 0.0.2

data/lib/ripper_ruby_parser/sexp_handlers/loops.rb

@@ -5,6 +5,26 @@ module RipperRubyParser
         _, cond, block = exp.shift 3
         s(:until, process(cond), handle_statement_list(block), true)
       end
+
+      def process_until_mod exp
+        _, cond, block = exp.shift 3
+
+        check_at_start = block.sexp_type != :begin
+
+        s(:until, process(cond), process(block), check_at_start)
+      end
+
+      def process_while exp
+        _, cond, block = exp.shift 3
+        s(:while, process(cond), handle_statement_list(block), true)
+      end
+
+      def process_for exp
+        _, var, coll, block = exp.shift 4
+        s(:for, process(coll),
+          s(:lasgn, process(var)[1]),
+          handle_statement_list(block))
+      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/method_calls.rb

@@ -3,43 +3,39 @@ module RipperRubyParser
     module MethodCalls
       def process_method_add_arg exp
         _, call, parens = exp.shift 3
-        call = process call
-        s(:call, call[1], call[2], process(parens))
+        call = process(call)
+        call[3] = process(parens) unless parens.empty?
+        call
       end
 
       def process_call exp
-        _, receiver, _, method = exp.shift 4
-        s(:call, process(receiver), identifier_node_to_symbol(method), s(:arglist))
+        _, receiver, _, ident = exp.shift 4
+        with_position_from_node_symbol(ident) {|method|
+          s(:call, process(receiver), method, s(:arglist)) }
       end
 
       def process_command exp
         _, ident, arglist = exp.shift 3
-
-        ident = identifier_node_to_symbol ident
-        arglist = process arglist
-
-        s(:call, nil, ident, arglist)
+        with_position_from_node_symbol(ident) {|method|
+          s(:call, nil, method, process(arglist)) }
       end
 
       def process_command_call exp
-        _, receiver, _, method, arguments = exp.shift 5
-        s(:call,
-          process(receiver),
-          identifier_node_to_symbol(method),
-          process(arguments))
+        _, receiver, _, ident, arguments = exp.shift 5
+        with_position_from_node_symbol(ident) {|method|
+          s(:call, process(receiver), method, process(arguments)) }
       end
 
       def process_vcall exp
-        _, ident = exp.shift 3
-
-        ident = identifier_node_to_symbol ident
-
-        s(:call, nil, ident, s(:arglist))
+        _, ident = exp.shift 2
+        with_position_from_node_symbol(ident) {|method|
+          s(:call, nil, method, s(:arglist)) }
       end
 
       def process_fcall exp
-        _, method = exp.shift 2
-        s(:call, nil, identifier_node_to_symbol(method), s(:arglist))
+        _, ident = exp.shift 2
+        with_position_from_node_symbol(ident) {|method|
+          s(:call, nil, method, s(:arglist)) }
       end
     end
   end

data/lib/ripper_ruby_parser/sexp_handlers/methods.rb

@@ -3,21 +3,34 @@ module RipperRubyParser
     module Methods
       def process_def exp
         _, ident, params, body = exp.shift 4
-        ident = identifier_node_to_symbol ident
-        s(:defn, ident, process(params), method_body(body))
+        ident, pos = extract_node_symbol_with_position ident
+        with_position(pos,
+                      s(:defn, ident, process(params), method_body(body)))
       end
 
       def process_defs exp
         _, receiver, _, method, args, body = exp.shift 6
         s(:defs, process(receiver),
-          identifier_node_to_symbol(method),
+          extract_node_symbol(method),
           process(args), process(body))
       end
 
       def process_return exp
         _, arglist = exp.shift 2
+
         arglist = process(arglist)
-        s(:return, arglist[1])
+        args = arglist[1..-1]
+
+        if args.length == 1
+          arg = args[0]
+          if arg.sexp_type == :splat
+            s(:return, s(:svalue, arg))
+          else
+            s(:return, arg)
+          end
+        else
+          s(:return, s(:array, *args))
+        end
       end
 
       def process_return0 exp
@@ -25,6 +38,17 @@ module RipperRubyParser
         s(:return)
       end
 
+      def process_yield exp
+        _, arglist = exp.shift 2
+        arglist = process arglist
+        s(:yield, *arglist[1..-1])
+      end
+
+      def process_yield0 exp
+        _ = exp.shift
+        s(:yield)
+      end
+
       def method_body exp
         scope = process exp
         block = scope[1]

data/lib/ripper_ruby_parser/sexp_handlers/operators.rb

@@ -1,28 +1,52 @@
 module RipperRubyParser
   module SexpHandlers
     module Operators
-      OPERATOR_MAP = {
+      BINARY_OPERTOR_MAP = {
         "&&".to_sym => :and,
-        "||".to_sym => :or
+        "||".to_sym => :or,
+        :and => :and,
+        :or => :or
+      }
+
+      UNARY_OPERATOR_MAP = {
+        :"!" => :not,
+        :not => :not
       }
 
       def process_binary exp
         _, left, op, right = exp.shift 4
-        mapped = OPERATOR_MAP[op]
-        if mapped
-          s(mapped, process(left), process(right))
+        if op == :=~
+          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, s(:arglist, process(right)))
+          end
+        elsif op == :"!="
+          s(:not, s(:call, process(left), :==, s(:arglist, process(right))))
         else
-          s(:call, process(left), op, s(:arglist, process(right)))
+          mapped = BINARY_OPERTOR_MAP[op]
+          if mapped
+            s(mapped, process(left), process(right))
+          else
+            s(:call, process(left), op, s(:arglist, process(right)))
+          end
         end
       end
 
       def process_unary exp
-        _, _, arg = exp.shift 3
+        _, op, arg = exp.shift 3
         arg = process(arg)
-        if is_literal? arg
-          s(:lit, -arg[1])
+        mapped = UNARY_OPERATOR_MAP[op]
+        if mapped
+          s(mapped, arg)
         else
-          s(:call, arg, :-@, s(:arglist))
+          if is_literal? arg
+            s(:lit, arg[1].send(op))
+          else
+            s(:call, arg, op, s(:arglist))
+          end
         end
       end
 
@@ -36,6 +60,11 @@ module RipperRubyParser
           s(:dot2, left, right)
         end
       end
+
+      def process_ifop exp
+        _, cond, truepart, falsepart = exp.shift 4
+        s(:if, process(cond), process(truepart), process(falsepart))
+      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_processor.rb

@@ -7,10 +7,15 @@ module RipperRubyParser
   class SexpProcessor < ::SexpProcessor
     def initialize
       super
+
       # TODO: Find these automatically
+
       @processors[:@int] = :process_at_int
+      @processors[:@float] = :process_at_float
+
       @processors[:@const] = :process_at_const
       @processors[:@ident] = :process_at_ident
+      @processors[:@cvar] = :process_at_cvar
       @processors[:@gvar] = :process_at_gvar
       @processors[:@ivar] = :process_at_ivar
       @processors[:@kw] = :process_at_kw
@@ -23,7 +28,9 @@ module RipperRubyParser
       return nil if exp.nil?
       exp.fix_empty_type
 
-      super
+      result = super
+      trickle_up_line_numbers result
+      trickle_down_line_numbers result
     end
 
     include SexpHandlers
@@ -41,23 +48,39 @@ module RipperRubyParser
 
     def process_module exp
       _, const_ref, body = exp.shift 3
-      const = const_node_to_symbol const_ref[1]
-      s(:module, const, class_or_module_body(body))
+      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
       _, const_ref, parent, body = exp.shift 4
-      const = const_node_to_symbol const_ref[1]
+      const, line = const_ref_to_const_with_line_number const_ref
       parent = process(parent)
-      s(:class, const, parent, class_or_module_body(body))
+      with_line_number(line,
+                       s(:class, const, parent, class_or_module_body(body)))
     end
 
     def process_bodystmt exp
-      _, body, _, _, _ = exp.shift 5
-      body = body.
-        map { |sub_exp| process(sub_exp) }.
-        reject { |sub_exp| sub_exp.sexp_type == :void_stmt }
-      s(:scope, s(:block, *body))
+      _, body, rescue_block, _, ensure_block = exp.shift 5
+
+      body = map_body body
+
+      unless rescue_block or ensure_block
+        return s(:scope, s(:block, *body))
+      end
+
+      body = wrap_in_block(body)
+
+      if rescue_block
+        body = s(:rescue, body, process(rescue_block))
+      end
+
+      if ensure_block
+        body = s(:ensure, body, process(ensure_block))
+      end
+
+      s(:scope, body)
     end
 
     def process_var_ref exp
@@ -72,68 +95,93 @@ module RipperRubyParser
 
     def process_const_path_ref exp
       _, left, right = exp.shift 3
-      s(:colon2, process(left), const_node_to_symbol(right))
+      s(:colon2, process(left), extract_node_symbol(right))
+    end
+
+    def process_const_ref exp
+      _, ref = exp.shift 3
+      process(ref)
     end
 
     def process_top_const_ref exp
       _, ref = exp.shift 2
-      s(:colon3, const_node_to_symbol(ref))
+      s(:colon3, extract_node_symbol(ref))
     end
 
     def process_paren exp
       _, body = exp.shift 2
-      process(body)
+      if body.size == 0
+        s()
+      elsif body.first.is_a? Symbol
+        process body
+      else
+        process body[0]
+      end
+    end
+
+    def process_comment exp
+      _, comment, inner = exp.shift 3
+      sexp = process(inner)
+      sexp.comments = comment
+      sexp
     end
 
+    # number literals
     def process_at_int exp
-      _, val, _ = exp.shift 3
-      s(:lit, val.to_i)
+      _, val, pos = exp.shift 3
+      with_position(pos, s(:lit, val.to_i))
+    end
+
+    def process_at_float exp
+      _, val, pos = exp.shift 3
+      with_position(pos, s(:lit, val.to_f))
     end
 
     # symbol-like sexps
     def process_at_const exp
-      s(:const, extract_node_symbol(exp))
+      make_identifier(:const, exp)
+    end
+
+    def process_at_cvar exp
+      make_identifier(:cvar, exp)
     end
 
     def process_at_gvar exp
-      s(:gvar, extract_node_symbol(exp))
+      make_identifier(:gvar, exp)
     end
 
     def process_at_ivar exp
-      s(:ivar, extract_node_symbol(exp))
+      make_identifier(:ivar, exp)
     end
 
     def process_at_ident exp
-      s(:lvar, extract_node_symbol(exp))
+      make_identifier(:lvar, exp)
     end
 
     def process_at_kw exp
-      sym = extract_node_symbol(exp)
-      if sym == :__FILE__
-        s(:str, "(string)")
-      else
-        s(sym)
-      end
+      sym, pos = extract_node_symbol_with_position(exp)
+      result = if sym == :__FILE__
+                 s(:str, "(string)")
+               else
+                 s(sym)
+               end
+      with_position(pos, result)
     end
 
     def process_at_backref exp
-      _, str, _ = exp.shift 3
-      s(:nth_ref, str[1..-1].to_i)
+      _, str, pos = exp.shift 3
+      with_position(pos, s(:nth_ref, str[1..-1].to_i))
     end
 
     private
 
-    def const_node_to_symbol exp
-      assert_type exp, :@const
-      _, ident, _ = exp.shift 3
-
-      ident.to_sym
-    end
-
-    def extract_node_symbol exp
-      _, ident, _ = exp.shift 3
-
-      ident.to_sym
+    def const_ref_to_const_with_line_number const_ref
+      const = process(const_ref)
+      line = const.line
+      if const.sexp_type == :const
+        const = const[1]
+      end
+      return const, line
     end
 
     def class_or_module_body exp
@@ -146,5 +194,28 @@ module RipperRubyParser
         s(:scope, s(:block, *block))
       end
     end
+
+    def make_identifier(type, exp)
+      with_position_from_node_symbol(exp) {|ident|
+        s(type, ident) }
+    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
   end
 end

data/lib/ripper_ruby_parser/version.rb

@@ -1,3 +1,3 @@
 module RipperRubyParser
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end