ripper_ruby_parser 0.0.2 → 0.0.3

data/lib/ripper_ruby_parser/parser.rb

@@ -9,9 +9,10 @@ module RipperRubyParser
       @processor = processor
     end
 
-    def parse source, filename='-', lineno=1
+    def parse source, filename='(string)', lineno=1
       parser = CommentingSexpBuilder.new(source, filename, lineno)
       exp = Sexp.from_array(parser.parse)
+      @processor.filename = filename
       @processor.process exp
     end
   end

data/lib/ripper_ruby_parser/sexp_handlers/arrays.rb

@@ -3,7 +3,15 @@ module RipperRubyParser
     module Arrays
       def process_array exp
         _, elems = exp.shift 2
-        s(:array, *handle_potentially_typeless_sexp(elems))
+        elems = handle_potentially_typeless_sexp(elems)
+        elems.map! do |elem|
+          if elem.first.is_a? Symbol
+            elem
+          else
+            elem.first
+          end
+        end
+        s(:array, *elems)
       end
 
       def process_aref exp

data/lib/ripper_ruby_parser/sexp_handlers/blocks.rb

@@ -84,6 +84,24 @@ module RipperRubyParser
         wrap_in_block s(*map_body(block))
       end
 
+      def process_next exp
+        _, args = exp.shift 2
+        if args.empty?
+          s(:next)
+        else
+          s(:next, handle_return_argument_list(args))
+        end
+      end
+
+      def process_break exp
+        _, args = exp.shift 2
+        if args.empty?
+          s(:break)
+        else
+          s(:break, handle_return_argument_list(args))
+        end
+      end
+
       private
 
       def handle_generic_block exp

data/lib/ripper_ruby_parser/sexp_handlers/hashes.rb

@@ -8,6 +8,22 @@ module RipperRubyParser
 
       def process_assoclist_from_args exp
         _, elems = exp.shift 2
+        make_hash_items elems
+      end
+
+      def process_assoc_new exp
+        _, left, right = exp.shift 3
+        s(process(left), process(right))
+      end
+
+      def process_bare_assoc_hash exp
+        _, elems = exp.shift 2
+        s(:hash, *make_hash_items(elems))
+      end
+
+      private
+
+      def make_hash_items elems
         result = s()
         elems.each {|sub_exp|
           process(sub_exp).each {|elm|
@@ -16,11 +32,6 @@ module RipperRubyParser
         }
         result
       end
-
-      def process_assoc_new exp
-        _, left, right = exp.shift 3
-        s(process(left), process(right))
-      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/helper_methods.rb

@@ -2,12 +2,24 @@ module RipperRubyParser
   module SexpHandlers
     module HelperMethods
       def handle_potentially_typeless_sexp exp
+        if exp.nil?
+          s()
+        elsif exp.first.is_a? Symbol
+          process(exp)
+        else
+          exp.map! { |sub_exp| handle_potentially_typeless_sexp(sub_exp) }
+        end
+      end
+
+      def handle_potentially_typeless_sexp_with_fallback_type type, exp
         if exp.nil?
           s()
         elsif exp.first.is_a? Symbol
           process(exp)
         else
           exp.map! { |sub_exp| process(sub_exp) }
+          exp.unshift type
+          exp
         end
       end
 
@@ -72,6 +84,22 @@ module RipperRubyParser
           s(:block, *statements)
         end
       end
+
+      def handle_return_argument_list arglist
+        arglist = process(arglist)
+        args = arglist[1..-1]
+
+        if args.length == 1
+          arg = args[0]
+          if arg.sexp_type == :splat
+            s(:svalue, arg)
+          else
+            arg
+          end
+        else
+          s(:array, *args)
+        end
+      end
     end
   end
 end

data/lib/ripper_ruby_parser/sexp_handlers/method_calls.rb

@@ -17,13 +17,17 @@ module RipperRubyParser
       def process_command exp
         _, ident, arglist = exp.shift 3
         with_position_from_node_symbol(ident) {|method|
-          s(:call, nil, method, process(arglist)) }
+          s(:call, nil, method,
+            handle_potentially_typeless_sexp_with_fallback_type(:arglist, arglist))
+        }
       end
 
       def process_command_call exp
         _, receiver, _, ident, arguments = exp.shift 5
         with_position_from_node_symbol(ident) {|method|
-          s(:call, process(receiver), method, process(arguments)) }
+          s(:call, process(receiver), method,
+            handle_potentially_typeless_sexp_with_fallback_type(:arglist, arguments))
+        }
       end
 
       def process_vcall exp

data/lib/ripper_ruby_parser/sexp_handlers/methods.rb

@@ -17,20 +17,7 @@ module RipperRubyParser
 
       def process_return exp
         _, arglist = exp.shift 2
-
-        arglist = process(arglist)
-        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
+        s(:return, handle_return_argument_list(arglist))
       end
 
       def process_return0 exp
@@ -49,6 +36,36 @@ module RipperRubyParser
         s(:yield)
       end
 
+      def process_undef exp
+        _, args = exp.shift 2
+
+        args.map! do |sub_exp|
+          s(:undef, make_method_name_literal(sub_exp))
+        end
+
+        if args.size == 1
+          args[0]
+        else
+          s(:block, *args)
+        end
+      end
+
+      def process_alias exp
+        _, *args = exp.shift 3
+
+        args.map! do |sub_exp|
+          make_method_name_literal sub_exp
+        end
+
+        s(:alias, *args)
+      end
+
+      private
+
+      def make_method_name_literal exp
+        process(exp).tap {|it| it[0] = :lit}
+      end
+
       def method_body exp
         scope = process exp
         block = scope[1]

data/lib/ripper_ruby_parser/sexp_processor.rb

@@ -5,6 +5,8 @@ require 'ripper_ruby_parser/sexp_ext'
 module RipperRubyParser
   # Processes the sexp created by Ripper to what RubyParser would produce.
   class SexpProcessor < ::SexpProcessor
+    attr_accessor :filename
+
     def initialize
       super
 
@@ -12,6 +14,8 @@ module RipperRubyParser
 
       @processors[:@int] = :process_at_int
       @processors[:@float] = :process_at_float
+      @processors[:@CHAR] = :process_at_CHAR
+      @processors[:@label] = :process_at_label
 
       @processors[:@const] = :process_at_const
       @processors[:@ident] = :process_at_ident
@@ -19,6 +23,7 @@ module RipperRubyParser
       @processors[:@gvar] = :process_at_gvar
       @processors[:@ivar] = :process_at_ivar
       @processors[:@kw] = :process_at_kw
+      @processors[:@op] = :process_at_op
       @processors[:@backref] = :process_at_backref
 
       @processors[:@tstring_content] = :process_at_tstring_content
@@ -128,13 +133,20 @@ module RipperRubyParser
 
     # number literals
     def process_at_int exp
-      _, val, pos = exp.shift 3
-      with_position(pos, s(:lit, val.to_i))
+      make_literal(exp) {|val| val.to_i }
     end
 
     def process_at_float exp
-      _, val, pos = exp.shift 3
-      with_position(pos, s(:lit, val.to_f))
+      make_literal(exp) {|val| val.to_f }
+    end
+
+    # character literals
+    def process_at_CHAR exp
+      make_literal(exp) {|val| eval(val) }
+    end
+
+    def process_at_label exp
+      make_literal(exp) {|val| val.chop.to_sym }
     end
 
     # symbol-like sexps
@@ -158,10 +170,17 @@ module RipperRubyParser
       make_identifier(:lvar, exp)
     end
 
+    def process_at_op exp
+      make_identifier(:op, exp)
+    end
+
     def process_at_kw exp
       sym, pos = extract_node_symbol_with_position(exp)
-      result = if sym == :__FILE__
-                 s(:str, "(string)")
+      result = case sym
+               when :__FILE__
+                 s(:str, @filename)
+               when :__LINE__
+                 s(:lit, pos[0])
                else
                  s(sym)
                end
@@ -200,6 +219,11 @@ module RipperRubyParser
         s(type, ident) }
     end
 
+    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

data/lib/ripper_ruby_parser/version.rb

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

data/test/unit/parser_test.rb

@@ -11,6 +11,7 @@ describe RipperRubyParser::Parser do
     it "post-processes its result with the passed sexp processor" do
       sexp_p = MiniTest::Mock.new
       sexp_p.expect :process, s(:result), [Sexp]
+      sexp_p.expect :filename=, nil, ['(string)']
 
       parser = RipperRubyParser::Parser.new sexp_p
       result = parser.parse "any code"
@@ -375,6 +376,52 @@ describe RipperRubyParser::Parser do
       end
     end
 
+    describe "for the undef statement" do
+      it "works with a single bareword identifier" do
+        result = parser.parse "undef foo"
+        result.must_equal s(:undef, s(:lit, :foo))
+      end
+
+      it "works with a single symbol" do
+        result = parser.parse "undef :foo"
+        result.must_equal s(:undef, s(:lit, :foo))
+      end
+
+      it "works with multiple bareword identifiers" do
+        result = parser.parse "undef foo, bar"
+        result.must_equal s(:block,
+                            s(:undef, s(:lit, :foo)),
+                            s(:undef, s(:lit, :bar)))
+      end
+
+      it "works with multiple bareword symbols" do
+        result = parser.parse "undef :foo, :bar"
+        result.must_equal s(:block,
+                            s(:undef, s(:lit, :foo)),
+                            s(:undef, s(:lit, :bar)))
+      end
+    end
+
+    describe "for the alias statement" do
+      it "works with regular barewords" do
+        result = parser.parse "alias foo bar"
+        result.must_equal s(:alias,
+                            s(:lit, :foo), s(:lit, :bar))
+      end
+
+      it "works with symbols" do
+        result = parser.parse "alias :foo :bar"
+        result.must_equal s(:alias,
+                            s(:lit, :foo), s(:lit, :bar))
+      end
+
+      it "works with operator barewords" do
+        result = parser.parse "alias + -"
+        result.must_equal s(:alias,
+                            s(:lit, :+), s(:lit, :-))
+      end
+    end
+
     describe "for arguments" do
       it "works for a simple case with splat" do
         result = parser.parse "foo *bar"
@@ -402,6 +449,15 @@ describe RipperRubyParser::Parser do
                               s(:block_pass,
                                 s(:call, nil, :bar, s(:arglist)))))
       end
+
+      it "works for a bare hash" do
+        result = parser.parse "foo bar => baz"
+        result.must_equal s(:call, nil, :foo,
+                            s(:arglist,
+                              s(:hash,
+                                s(:call, nil, :bar, s(:arglist)),
+                                s(:call, nil, :baz, s(:arglist)))))
+      end
     end
 
     describe "for array literals" do
@@ -422,6 +478,11 @@ describe RipperRubyParser::Parser do
                             s(:call, nil, :foo, s(:arglist)),
                             s(:splat, s(:call, nil, :bar, s(:arglist))))
       end
+
+      it "works for an array created with %W" do
+        result = parser.parse "%W(foo bar)"
+        result.must_equal s(:array, s(:str, "foo"), s(:str, "bar"))
+      end
     end
 
     describe "for hash literals" do
@@ -445,6 +506,15 @@ describe RipperRubyParser::Parser do
                             s(:call, nil, :baz, s(:arglist)),
                             s(:call, nil, :qux, s(:arglist)))
       end
+
+      it "works for a hash with label keys (Ruby 1.9 only)" do
+        result = parser.parse "{foo: bar, baz: qux}"
+        result.must_equal s(:hash,
+                            s(:lit, :foo),
+                            s(:call, nil, :bar, s(:arglist)),
+                            s(:lit, :baz),
+                            s(:call, nil, :qux, s(:arglist)))
+      end
     end
 
     describe "for number literals" do
@@ -606,6 +676,15 @@ describe RipperRubyParser::Parser do
           result = parser.parse "foo?"
           result.must_equal s(:call, nil, :foo?, s(:arglist))
         end
+
+        it "works with nested calls without brackets" do
+          result = parser.parse "foo bar baz"
+          result.must_equal s(:call, nil, :foo,
+                              s(:arglist,
+                                s(:call, nil, :bar,
+                                  s(:arglist,
+                                    s(:call, nil, :baz, s(:arglist))))))
+        end
       end
 
       describe "with a reciever" do
@@ -635,6 +714,17 @@ describe RipperRubyParser::Parser do
                                   s(:arglist,
                                     s(:call, nil, :qux, s(:arglist))))))
         end
+
+        it "works with nested calls without brackets" do
+          result = parser.parse "foo.bar baz qux"
+          result.must_equal s(:call,
+                              s(:call, nil, :foo, s(:arglist)),
+                              :bar,
+                              s(:arglist,
+                                s(:call, nil, :baz,
+                                  s(:arglist,
+                                    s(:call, nil, :qux, s(:arglist))))))
+        end
       end
 
       describe "with blocks" do
@@ -664,6 +754,70 @@ describe RipperRubyParser::Parser do
       end
     end
 
+    describe "for blocks" do
+      it "works with next with no arguments" do
+        result = parser.parse "foo do; next; end"
+        result.must_equal s(:iter,
+                            s(:call, nil, :foo, s(:arglist)),
+                            nil,
+                            s(:next))
+      end
+
+      it "works with next with one argument" do
+        result = parser.parse "foo do; next bar; end"
+        result.must_equal s(:iter,
+                            s(:call, nil, :foo, s(:arglist)),
+                            nil,
+                            s(:next, s(:call, nil, :bar, s(:arglist))))
+      end
+
+      it "works with next with several arguments" do
+        result = parser.parse "foo do; next bar, baz; end"
+        result.must_equal s(:iter,
+                            s(:call, nil, :foo, s(:arglist)),
+                            nil,
+                            s(:next,
+                              s(:array,
+                                s(:call, nil, :bar, s(:arglist)),
+                                s(:call, nil, :baz, s(:arglist)))))
+      end
+
+      it "works with break with no arguments" do
+        result = parser.parse "foo do; break; end"
+        result.must_equal s(:iter,
+                            s(:call, nil, :foo, s(:arglist)),
+                            nil,
+                            s(:break))
+      end
+
+      it "works with break with one argument" do
+        result = parser.parse "foo do; break bar; end"
+        result.must_equal s(:iter,
+                            s(:call, nil, :foo, s(:arglist)),
+                            nil,
+                            s(:break, s(:call, nil, :bar, s(:arglist))))
+      end
+
+      it "works with break with several arguments" do
+        result = parser.parse "foo do; break bar, baz; end"
+        result.must_equal s(:iter,
+                            s(:call, nil, :foo, s(:arglist)),
+                            nil,
+                            s(:break,
+                              s(:array,
+                                s(:call, nil, :bar, s(:arglist)),
+                                s(:call, nil, :baz, s(:arglist)))))
+      end
+
+      it "works with redo" do
+        result = parser.parse "foo do; redo; end"
+        result.must_equal s(:iter,
+                            s(:call, nil, :foo, s(:arglist)),
+                            nil,
+                            s(:redo))
+      end
+    end
+
     describe "for yield" do
       it "works with no arguments and no brackets" do
         result = parser.parse "yield"
@@ -807,12 +961,35 @@ describe RipperRubyParser::Parser do
                             "foo",
                             s(:evstr, s(:call, nil, :bar, s(:arglist))))
       end
+
+      it "works for character literals (which are string literals in Ruby 1.9.3)" do
+        result = parser.parse "?a"
+        result.must_equal s(:lit, "a")
+      end
     end
 
     describe "for the __FILE__ keyword" do
-      it "creates a string sexp with value '(string)'" do
-        result = parser.parse "__FILE__"
-        result.must_equal s(:str, "(string)")
+      describe "when not passing a file name" do
+        it "creates a string sexp with value '(string)'" do
+          result = parser.parse "__FILE__"
+          result.must_equal s(:str, "(string)")
+        end
+      end
+
+      describe "when passing a file name" do
+        it "creates a string sexp with the file name" do
+          result = parser.parse "__FILE__", "foo"
+          result.must_equal s(:str, "foo")
+        end
+      end
+    end
+
+    describe "for the __LINE__ keyword" do
+      it "creates a literal sexp with value of the line number" do
+        result = parser.parse "__LINE__"
+        result.must_equal s(:lit, 1)
+        result = parser.parse "\n__LINE__"
+        result.must_equal s(:lit, 2)
       end
     end
 
@@ -1413,6 +1590,18 @@ describe RipperRubyParser::Parser do
         nums = [ arglist.line, block.line ]
         nums.must_equal [1, 1]
       end
+
+      describe "when a line number is passed" do
+        it "shifts all line numbers as appropriate" do
+          result = parser.parse "foo\nbar\n", '(string)', 3
+          result.must_equal s(:block,
+                              s(:call, nil, :foo, s(:arglist)),
+                              s(:call, nil, :bar, s(:arglist)))
+          result.line.must_equal 3
+          result[1].line.must_equal 3
+          result[2].line.must_equal 4
+        end
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ripper_ruby_parser
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,22 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-19 00:00:00.000000000 Z
+date: 2012-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sexp_processor
-  requirement: &13025240 !ruby/object:Gem::Requirement
+  requirement: &16124900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.0.10
+        version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *13025240
+  version_requirements: *16124900
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: &13024720 !ruby/object:Gem::Requirement
+  requirement: &16124380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 2.11.2
   type: :development
   prerelease: false
-  version_requirements: *13024720
+  version_requirements: *16124380
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &13024240 !ruby/object:Gem::Requirement
+  requirement: &16123900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 0.9.2
   type: :development
   prerelease: false
-  version_requirements: *13024240
+  version_requirements: *16123900
 - !ruby/object:Gem::Dependency
   name: ruby_parser
-  requirement: &13023760 !ruby/object:Gem::Requirement
+  requirement: &16123420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 2.3.1
   type: :development
   prerelease: false
-  version_requirements: *13023760
+  version_requirements: *16123420
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &13023380 !ruby/object:Gem::Requirement
+  requirement: &16123040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +65,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *13023380
+  version_requirements: *16123040
 description: 
 email:
 - matijs@matijs.net