ripper_ruby_parser 0.0.1 → 0.0.2

data/lib/ripper_ruby_parser/commenting_sexp_builder.rb

@@ -0,0 +1,48 @@
+require 'ripper'
+module RipperRubyParser
+  class CommentingSexpBuilder < Ripper::SexpBuilderPP
+    def initialize *args
+      super
+      @comment = nil
+      @comment_stack = []
+    end
+
+    def on_comment tok
+      @comment ||= ""
+      @comment += tok
+      super
+    end
+
+    def on_kw tok
+      case tok
+      when "class", "def", "module"
+        @comment_stack.push @comment
+        @comment = nil
+      end
+      super
+    end
+
+    def on_class *args
+      commentize(super)
+    end
+
+    def on_def *args
+      commentize(super)
+    end
+
+    def on_module *args
+      commentize(super)
+    end
+
+    private
+
+    def commentize exp
+      comment = @comment_stack.pop
+      if comment.nil?
+        [:comment, "", exp]
+      else
+        [:comment, comment, exp]
+      end
+    end
+  end
+end

data/lib/ripper_ruby_parser/parser.rb

@@ -1,4 +1,4 @@
-require 'ripper'
+require 'ripper_ruby_parser/commenting_sexp_builder'
 require 'ripper_ruby_parser/sexp_processor'
 
 module RipperRubyParser
@@ -9,8 +9,9 @@ module RipperRubyParser
       @processor = processor
     end
 
-    def parse source
-      exp = Sexp.from_array(Ripper.sexp source)
+    def parse source, filename='-', lineno=1
+      parser = CommentingSexpBuilder.new(source, filename, lineno)
+      exp = Sexp.from_array(parser.parse)
       @processor.process exp
     end
   end

data/lib/ripper_ruby_parser/sexp_handlers/arguments.rb

@@ -2,8 +2,12 @@ module RipperRubyParser
   module SexpHandlers
     module Arguments
       def process_args_add_block exp
-        _, content, _ = exp.shift 3
-        s(:arglist, *handle_list_with_optional_splat(content))
+        _, regular, block = exp.shift 3
+        args = handle_potentially_typeless_sexp(regular)
+        if block
+          args << s(:block_pass, process(block))
+        end
+        s(:arglist, *args)
       end
 
       def process_args_add_star exp

data/lib/ripper_ruby_parser/sexp_handlers/arrays.rb

@@ -3,7 +3,7 @@ module RipperRubyParser
     module Arrays
       def process_array exp
         _, elems = exp.shift 2
-        s(:array, *handle_list_with_optional_splat(elems))
+        s(:array, *handle_potentially_typeless_sexp(elems))
       end
 
       def process_aref exp

data/lib/ripper_ruby_parser/sexp_handlers/assignment.rb

@@ -7,23 +7,22 @@ module RipperRubyParser
         lvalue = process(lvalue)
         value = process(value)
 
-        create_assignment_sub_type lvalue, value
+        with_line_number(lvalue.line,
+                         create_regular_assignment_sub_type(lvalue, value))
       end
 
       def process_massign exp
         _, left, right = exp.shift 3
 
-        left = handle_list_with_optional_splat left
+        left = handle_potentially_typeless_sexp left
 
-        left.each do |item|
-          case item.sexp_type
-          when :splat
-            item[1][0] = :lasgn
-          else
-            item[0] = :lasgn
-          end
+        if left.first == :masgn
+          left = left[1]
+          left.shift
         end
 
+        left = create_multiple_assignement_sub_types left
+
         right = process(right)
 
         unless right.sexp_type == :array
@@ -44,36 +43,90 @@ module RipperRubyParser
         generic_add_star exp
       end
 
+      def process_mlhs_paren exp
+        _, contents = exp.shift 2
+        items = handle_potentially_typeless_sexp(contents)
+
+        items = create_multiple_assignement_sub_types items
+
+        s(:masgn, s(:array, *items))
+      end
+
       def process_opassign exp
         _, lvalue, operator, value = exp.shift 4
 
         lvalue = process(lvalue)
         value = process(value)
         operator = operator[1].gsub(/=/, '').to_sym
-        operator_call = s(:call, lvalue, operator, s(:arglist, value))
 
+        create_operator_assignment_sub_type lvalue, value, operator
+      end
+
+      private
+
+      def create_multiple_assignement_sub_types sexp_list
+        sexp_list.map! do |item|
+          if item.sexp_type == :splat
+            s(:splat, create_valueless_assignment_sub_type(item[1]))
+          else
+            create_valueless_assignment_sub_type item
+          end
+        end
+      end
+
+      def create_valueless_assignment_sub_type(item)
+        item = with_line_number(item.line,
+                                create_regular_assignment_sub_type(item, nil))
+        if item.sexp_type == :attrasgn
+          item.last.pop
+        else
+          item.pop
+        end
+        return item
+      end
+
+      def create_operator_assignment_sub_type lvalue, value, operator
         case lvalue.sexp_type
-        when :ivar
-          s(:iasgn, lvalue[1], operator_call)
         when :aref_field
           s(:op_asgn1, lvalue[1], s(:arglist, lvalue[2][1]), operator, value)
+        when :field
+          s(:op_asgn2, lvalue[1], :"#{lvalue[3][1]}=", operator, value)
         else
-          s(:lasgn, lvalue[1], operator_call)
+          if operator == :"||"
+            s(:op_asgn_or, lvalue, create_assignment_sub_type(lvalue, value))
+          else
+            operator_call = s(:call, lvalue, operator, s(:arglist, value))
+            create_assignment_sub_type lvalue, operator_call
+          end
         end
       end
 
-      def create_assignment_sub_type lvalue, value
+      def create_regular_assignment_sub_type lvalue, value
         case lvalue.sexp_type
-        when :ivar
-          s(:iasgn, lvalue[1], value)
         when :aref_field
           s(:attrasgn, lvalue[1], :[]=, s(:arglist, lvalue[2][1], value))
-        when :const
-          s(:cdecl, lvalue[1], value)
+        when :field
+          s(:attrasgn, lvalue[1], :"#{lvalue[3][1]}=", s(:arglist, value))
         else
-          s(:lasgn, lvalue[1], value)
+          create_assignment_sub_type lvalue, value
         end
       end
+
+      ASSIGNMENT_SUB_TYPE_MAP = {
+        :ivar => :iasgn,
+        :const => :cdecl,
+        :lvar => :lasgn,
+        :cvar => :cvdecl,
+        :gvar => :gasgn
+      }
+
+      def create_assignment_sub_type lvalue, value
+        s(map_assignment_lvalue_type(lvalue.sexp_type), lvalue[1], value)
+      end
+
+      def map_assignment_lvalue_type type
+        ASSIGNMENT_SUB_TYPE_MAP[type] || type
+      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/blocks.rb

@@ -18,32 +18,96 @@ module RipperRubyParser
       end
 
       def process_params exp
-        _, normal, defaults, *_ = exp.shift 6
+        _, normal, defaults, rest, _, block = exp.shift 6
 
         args = [*normal].map do |id|
-          identifier_node_to_symbol id
+          extract_node_symbol id
         end
 
         assigns = [*defaults].map do |pair|
-          sym = identifier_node_to_symbol pair[0]
+          sym = extract_node_symbol pair[0]
+          args << sym
           val = process pair[1]
           s(:lasgn, sym, val)
         end
 
+        add_arg_unless_nil(rest, args) {|name| :"*#{name}" }
+
+        add_arg_unless_nil(block, args) {|name| :"&#{name}" }
+
         if assigns.length > 0
-          args += assigns.map {|lasgn| lasgn[1]}
           args << s(:block, *assigns)
         end
 
         s(:args, *args)
       end
 
+      def process_begin exp
+        _, body = exp.shift 2
+
+        block = process(body)[1]
+
+        strip_wrapping_block(block)
+      end
+
+      def process_rescue exp
+        _, eclass, evar, block, _ = exp.shift 5
+        rescue_block = s(*map_body(block))
+
+        arr = []
+        if eclass
+          eclass = handle_potentially_typeless_sexp eclass
+          if eclass.first.is_a? Symbol
+            arr += eclass[1..-1]
+          else
+            arr << eclass[0]
+          end
+        end
+
+        if evar
+          evar = process(evar)[1]
+          easgn = s(:lasgn, :e, s(:gvar, :$!))
+          arr << easgn
+        end
+
+        s(:resbody, s(:array, *arr),
+          wrap_in_block(rescue_block))
+      end
+
+      def process_rescue_mod exp
+        _, scary, safe = exp.shift 3
+        s(:rescue, process(scary), s(:resbody, s(:array), process(safe)))
+      end
+
+      def process_ensure exp
+        _, block = exp.shift 2
+        wrap_in_block s(*map_body(block))
+      end
+
       private
 
       def handle_generic_block exp
         _, args, stmts = exp.shift 3
         s(:block, process(args), s(handle_statement_list(stmts)))
       end
+
+      def strip_wrapping_block(block)
+        case block.length
+        when 1
+          s(:nil)
+        when 2
+          block[1]
+        else
+          block
+        end
+      end
+
+      def add_arg_unless_nil(item, args)
+        unless item.nil?
+          name = extract_node_symbol item[1]
+          args << yield(name)
+        end
+      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/helper_methods.rb

@@ -1,13 +1,13 @@
 module RipperRubyParser
   module SexpHandlers
     module HelperMethods
-      def handle_list_with_optional_splat exp
+      def handle_potentially_typeless_sexp exp
         if exp.nil?
-          []
+          s()
         elsif exp.first.is_a? Symbol
           process(exp)
         else
-          exp.map { |sub_exp| process(sub_exp) }
+          exp.map! { |sub_exp| process(sub_exp) }
         end
       end
 
@@ -16,24 +16,38 @@ module RipperRubyParser
       end
 
       def handle_statement_list exp
-        statements = exp.
-          map { |sub_exp| process(sub_exp) }.
-          reject { |sub_exp| sub_exp.sexp_type == :void_stmt }
+        statements = map_body exp
 
-        if statements.length == 1
-          statements.first
-        else
-          s(:block, *statements)
-        end
+        wrap_in_block(statements)
       end
 
-      def identifier_node_to_symbol exp
-        assert_type exp, :@ident
-        _, ident, _ = exp.shift 3
+      def extract_node_symbol_with_position exp
+        return nil if exp.nil?
+        _, ident, pos = exp.shift 3
+        return ident.to_sym, pos
+      end
 
+      def extract_node_symbol exp
+        return nil if exp.nil?
+        _, ident, _ = exp.shift 3
         ident.to_sym
       end
 
+      def with_position pos, exp
+        (line, _) = pos
+        with_line_number line, exp
+      end
+
+      def with_line_number line, exp
+        exp.line = line
+        exp
+      end
+
+      def with_position_from_node_symbol exp
+        sym, pos = extract_node_symbol_with_position exp
+        with_position(pos, yield(sym))
+      end
+
       def generic_add_star exp
         _, args, splatarg = exp.shift 3
         items = args.map { |sub| process(sub) }
@@ -44,6 +58,20 @@ module RipperRubyParser
       def is_literal? exp
         exp.sexp_type == :lit
       end
+
+      def map_body body
+        body.
+          map { |sub_exp| process(sub_exp) }.
+          reject { |sub_exp| sub_exp.sexp_type == :void_stmt }
+      end
+
+      def wrap_in_block statements
+        if statements.length == 1
+          statements.first
+        else
+          s(:block, *statements)
+        end
+      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/literals.rb

@@ -7,27 +7,9 @@ module RipperRubyParser
       end
 
       def process_string_content exp
-        _, inner = exp.shift 2
+        exp.shift
 
-        string = extract_inner_string(inner)
-        rest = []
-
-        if string.sexp_type == :str
-          string = string[1]
-        else
-          rest << string
-          string = ""
-        end
-
-        string = unescape(string)
-
-        until exp.empty? do
-          result = process(exp.shift)
-          if result.sexp_type == :str
-            result[1] = unescape(result[1])
-          end
-          rest << result
-        end
+        string, rest = extract_string_parts exp
 
         if rest.empty?
           s(:str, string)
@@ -51,15 +33,23 @@ module RipperRubyParser
 
       def process_symbol_literal exp
         _, symbol = exp.shift 2
-        sym = symbol[1]
-        s(:lit, extract_node_symbol(sym))
+        process(symbol)
+      end
+
+      def process_symbol exp
+        _, node = exp.shift 2
+        with_position_from_node_symbol(node) {|sym| s(:lit, sym) }
       end
 
       def process_dyna_symbol exp
         _, list = exp.shift 2
 
-        string = process list[0]
-        s(:lit, string[1].to_sym)
+        string, rest = extract_string_parts list
+        if rest.empty?
+          s(:lit, string.to_sym)
+        else
+          s(:dsym, string, *rest)
+        end
       end
 
       def process_at_tstring_content exp
@@ -73,8 +63,34 @@ module RipperRubyParser
         process(exp) || s(:str, "")
       end
 
+      def extract_string_parts exp
+        inner = exp.shift
+
+        string = extract_inner_string(inner)
+        rest = []
+
+        if string.sexp_type == :str
+          string = string[1]
+        else
+          rest << string
+          string = ""
+        end
+
+        string = unescape(string)
+
+        until exp.empty? do
+          result = process(exp.shift)
+          if result.sexp_type == :str
+            result[1] = unescape(result[1])
+          end
+          rest << result
+        end
+
+        return string, rest
+      end
+
       def unescape string
-        string.gsub /(\\[n\\"])/ do
+        string.gsub(/(\\[n\\"])/) do
           eval "\"#{$1}\""
         end
       end