ripper_ruby_parser 0.0.1 → 0.0.2

data/test/end_to_end/comments_test.rb

@@ -0,0 +1,73 @@
+require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
+require 'ruby_parser'
+
+describe "Using RipperRubyParser and RubyParser" do
+  def to_comments exp
+    inner = exp.map do |sub_exp|
+      if sub_exp.is_a? Sexp
+        to_comments sub_exp
+      else
+        sub_exp
+      end
+    end
+
+    if exp.comments.nil?
+      s(*inner)
+    else
+      s(:comment, exp.comments, s(*inner))
+    end
+  end
+
+  let :newparser do
+    RipperRubyParser::Parser.new
+  end
+
+  let :oldparser do
+    RubyParser.new
+  end
+
+  describe "for a program with quite some comments" do
+    let :program do
+      <<-END
+      # Foo
+      class Foo
+        # The foo
+        # method
+        def foo
+          bar # bar
+          # internal comment
+        end
+
+        def bar
+          baz
+        end
+      end
+      # Quux
+      module Qux
+        class Quux
+          def bar
+          end
+          def baz
+          end
+        end
+      end
+      END
+    end
+
+    let :original do
+      oldparser.parse program
+    end
+
+    let :imitation do
+      newparser.parse program
+    end
+
+    it "gives the same result" do
+      imitation.must_equal original
+    end
+
+    it "gives the same result with comments" do
+      to_comments(imitation).must_equal to_comments(original)
+    end
+  end
+end

data/test/end_to_end/comparison_test.rb

@@ -52,5 +52,65 @@ describe "Using RipperRubyParser and RubyParser" do
     end
   end
 
+  describe "for an example with yield from Reek" do
+    let :program do
+      'def fred() yield(3) if block_given?; end'
+    end
+
+    it "gives the same result" do
+      original = oldparser.parse program
+      imitation = newparser.parse program
+
+      imitation.must_equal original
+    end
+  end
+
+  describe "for an example with floats from Reek" do
+    let :program do
+      <<-END
+        def total_envy
+          fred = @item
+          total = 0
+          total += fred.price
+          total += fred.tax
+          total *= 1.15
+        end
+      END
+    end
+
+    it "gives the same result" do
+      original = oldparser.parse program
+      imitation = newparser.parse program
+
+      formatted(imitation).must_equal formatted(original)
+    end
+  end
+
+  describe "for a example with operators and explicit block parameter from Reek" do
+    let :program do
+      <<-END
+        def parse(arg, argv, &error)
+          if !(val = arg) and (argv.empty? or /\\A-/ =~ (val = argv[0]))
+            return nil, block, nil
+          end
+          opt = (val = parse_arg(val, &error))[1]
+          val = conv_arg(*val)
+          if opt and !arg
+            argv.shift
+          else
+            val[0] = nil
+          end
+          val
+        end
+      END
+    end
+
+    it "gives the same result" do
+      original = oldparser.parse program
+      imitation = newparser.parse program
+
+      formatted(imitation).must_equal formatted(original)
+    end
+  end
 end
 

data/test/end_to_end/line_numbering_test.rb

@@ -0,0 +1,63 @@
+require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
+require 'ruby_parser'
+
+describe "Using RipperRubyParser and RubyParser" do
+  def to_line_numbers exp
+    exp.map! do |sub_exp|
+      if sub_exp.is_a? Sexp
+        to_line_numbers sub_exp
+      else
+        sub_exp
+      end
+    end
+
+    if exp.sexp_type == :scope
+      exp
+    else
+      s(:line_number, exp.line, exp)
+    end
+  end
+
+  let :newparser do
+    RipperRubyParser::Parser.new
+  end
+
+  let :oldparser do
+    RubyParser.new
+  end
+
+  describe "for a multi-line program" do
+    let :program do
+      <<-END
+      class Foo
+        def foo()
+          bar()
+          baz(qux)
+        end
+      end
+
+      module Bar
+        @@baz = {}
+      end
+      END
+    end
+
+    let :original do
+      oldparser.parse program
+    end
+
+    let :imitation do
+      newparser.parse program
+    end
+
+    it "gives the same result" do
+      imitation.must_equal original
+    end
+
+    it "gives the same result with line numbers" do
+      formatted(to_line_numbers(imitation)).
+        must_equal formatted(to_line_numbers(original))
+    end
+  end
+end
+

data/test/test_helper.rb

@@ -1,5 +1,7 @@
-require 'simplecov'
-SimpleCov.start
+if ENV["SIMPLECOV"]
+  require 'simplecov'
+  SimpleCov.start
+end
 require 'minitest/spec'
 require 'minitest/autorun'
 
@@ -7,6 +9,16 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 require 'ripper_ruby_parser'
 
-def formatted exp
-  exp.to_s.gsub /\), /, "),\n"
+class MiniTest::Unit::TestCase
+  def formatted exp
+    exp.to_s.gsub(/\), /, "),\n")
+  end
+
+  def suppress_warnings
+    old_verbose = $VERBOSE
+    $VERBOSE = nil
+    result = yield
+    $VERBOSE = old_verbose
+    result
+  end
 end

data/test/unit/commenting_sexp_builder_test.rb

@@ -0,0 +1,75 @@
+require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
+
+describe RipperRubyParser::CommentingSexpBuilder do
+  def parse_with_builder str
+    builder = RipperRubyParser::CommentingSexpBuilder.new str
+    builder.parse
+  end
+
+  describe "handling comments" do
+    it "produces a comment node surrounding a commented def" do
+      result = parse_with_builder "# Foo\ndef foo; end"
+      result.must_equal [:program,
+                         [[:comment,
+                           "# Foo\n",
+                           [:def,
+                            [:@ident, "foo", [2, 4]],
+                            [:params, nil, nil, nil, nil, nil],
+                            [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]]
+    end
+
+    it "produces a blank comment node surrounding a def that has no comment" do
+      result = parse_with_builder "def foo; end"
+      result.must_equal [:program,
+                         [[:comment,
+                           "",
+                           [:def,
+                           [:@ident, "foo", [1, 4]],
+                           [:params, nil, nil, nil, nil, nil],
+                           [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]]
+    end
+
+    it "produces a comment node surrounding a commented class" do
+      result = parse_with_builder "# Foo\nclass Foo; end"
+      result.must_equal [:program,
+                         [[:comment,
+                           "# Foo\n",
+                           [:class,
+                            [:const_ref, [:@const, "Foo", [2, 6]]],
+                            nil,
+                            [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]]
+    end
+
+    it "produce a blank comment node surrounding a class that has no comment" do
+      result = parse_with_builder "class Foo; end"
+      result.must_equal [:program,
+                         [[:comment,
+                           "",
+                           [:class,
+                           [:const_ref, [:@const, "Foo", [1, 6]]],
+                           nil,
+                           [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]]
+    end
+
+    it "produces a comment node surrounding a commented module" do
+      result = parse_with_builder "# Foo\nmodule Foo; end"
+      result.must_equal [:program,
+                         [[:comment,
+                           "# Foo\n",
+                           [:module,
+                            [:const_ref, [:@const, "Foo", [2, 7]]],
+                            [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]]
+    end
+
+    it "produces a blank comment node surrounding a module that has no comment" do
+      result = parse_with_builder "module Foo; end"
+      result.must_equal [:program,
+                         [[:comment,
+                           "",
+                           [:module,
+                           [:const_ref, [:@const, "Foo", [1, 7]]],
+                           [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]]
+    end
+  end
+end
+

data/test/unit/parser_test.rb

@@ -19,6 +19,25 @@ describe RipperRubyParser::Parser do
       sexp_p.verify
     end
 
+    describe "for a class declaration" do
+      it "works with a namespaced class name" do
+        result = parser.parse "class Foo::Bar; end"
+        result.must_equal s(:class,
+                            s(:colon2, s(:const, :Foo), :Bar),
+                            nil,
+                            s(:scope))
+      end
+    end
+
+    describe "for a module declaration" do
+      it "works with a namespaced module name" do
+        result = parser.parse "module Foo::Bar; end"
+        result.must_equal s(:module,
+                            s(:colon2, s(:const, :Foo), :Bar),
+                            s(:scope))
+      end
+    end
+
     describe "for if" do
       it "works in the postfix case" do
         result = parser.parse "foo if bar"
@@ -28,6 +47,14 @@ describe RipperRubyParser::Parser do
                             nil)
       end
 
+      it "works in the block case" do
+        result = parser.parse "if foo; bar; end"
+        result.must_equal s(:if,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:call, nil, :bar, s(:arglist)),
+                            nil)
+      end
+
       it "works with an else clause" do
         result = parser.parse "if foo; bar; else; baz; end"
         result.must_equal s(:if,
@@ -132,33 +159,219 @@ describe RipperRubyParser::Parser do
         result.must_equal s(:return,
                             s(:call, nil, :foo, s(:arglist)))
       end
+
+      it "works with a splat argument" do
+        result = parser.parse "return *foo"
+        result.must_equal s(:return,
+                            s(:svalue,
+                              s(:splat,
+                                s(:call, nil, :foo, s(:arglist)))))
+      end
+
+      it "works with multiple arguments" do
+        result = parser.parse "return foo, bar"
+        result.must_equal s(:return,
+                            s(:array,
+                              s(:call, nil, :foo, s(:arglist)),
+                              s(:call, nil, :bar, s(:arglist))))
+      end
+
+      it "works with a regular argument and a splat argument" do
+        result = parser.parse "return foo, *bar"
+        result.must_equal s(:return,
+                            s(:array,
+                              s(:call, nil, :foo, s(:arglist)),
+                              s(:splat,
+                                s(:call, nil, :bar, s(:arglist)))))
+      end
     end
 
     describe "for the until statement" do
-      it "works with do" do
+      it "works in the prefix block case with do" do
         result = parser.parse "until foo do; bar; end"
         result.must_equal s(:until,
                             s(:call, nil, :foo, s(:arglist)),
                             s(:call, nil, :bar, s(:arglist)), true)
       end
 
-      it "works without do" do
+      it "works in the prefix block case without do" do
         result = parser.parse "until foo; bar; end"
         result.must_equal s(:until,
                             s(:call, nil, :foo, s(:arglist)),
                             s(:call, nil, :bar, s(:arglist)), true)
       end
+
+      it "works in the single-line postfix case" do
+        result = parser.parse "foo until bar"
+        result.must_equal s(:until,
+                            s(:call, nil, :bar, s(:arglist)),
+                            s(:call, nil, :foo, s(:arglist)), true)
+      end
+
+      it "works in the block postfix case" do
+        result = parser.parse "begin; foo; end until bar"
+        result.must_equal s(:until,
+                            s(:call, nil, :bar, s(:arglist)),
+                            s(:call, nil, :foo, s(:arglist)), false)
+      end
     end
 
-    describe "for identifiers" do
-      it "works for an ivar" do
-        result = parser.parse "@foo"
-        result.must_equal s(:ivar, :@foo)
+    describe "for the while statement" do
+      it "works with do" do
+        result = parser.parse "while foo do; bar; end"
+        result.must_equal s(:while,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:call, nil, :bar, s(:arglist)), true)
       end
 
-      it "works for self" do
-        result = parser.parse "self"
-        result.must_equal s(:self)
+      it "works without do" do
+        result = parser.parse "while foo; bar; end"
+        result.must_equal s(:while,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:call, nil, :bar, s(:arglist)), true)
+      end
+    end
+
+    describe "for the for statement" do
+      it "works with do" do
+        result = suppress_warnings {
+          parser.parse "for foo in bar do; baz; end" }
+        result.must_equal s(:for,
+                            s(:call, nil, :bar, s(:arglist)),
+                            s(:lasgn, :foo),
+                            s(:call, nil, :baz, s(:arglist)))
+      end
+
+      it "works without do" do
+        result = suppress_warnings {
+          parser.parse "for foo in bar; baz; end" }
+        result.must_equal s(:for,
+                            s(:call, nil, :bar, s(:arglist)),
+                            s(:lasgn, :foo),
+                            s(:call, nil, :baz, s(:arglist)))
+      end
+    end
+
+    describe "for a begin..end block" do
+      it "works with no statements" do
+        result = parser.parse "begin; end"
+        result.must_equal s(:nil)
+      end
+
+      it "works with one statement" do
+        result = parser.parse "begin; foo; end"
+        result.must_equal s(:call, nil, :foo, s(:arglist))
+      end
+
+      it "works with multiple statements" do
+        result = parser.parse "begin; foo; bar; end"
+        result.must_equal s(:block,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:call, nil, :bar, s(:arglist)))
+      end
+    end
+
+    describe "for the rescue statement" do
+      it "works with single statement main and rescue bodies" do
+        result = parser.parse "begin; foo; rescue; bar; end"
+        result.must_equal s(:rescue,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:resbody,
+                              s(:array),
+                              s(:call, nil, :bar, s(:arglist))))
+      end
+
+      it "works with multi-statement main and rescue bodies" do
+        result = parser.parse "begin; foo; bar; rescue; baz; qux; end"
+        result.must_equal s(:rescue,
+                            s(:block,
+                              s(:call, nil, :foo, s(:arglist)),
+                              s(:call, nil, :bar, s(:arglist))),
+                            s(:resbody,
+                              s(:array),
+                              s(:block,
+                                s(:call, nil, :baz, s(:arglist)),
+                                s(:call, nil, :qux, s(:arglist)))))
+      end
+
+      it "works with assignment to an error variable" do
+        result = suppress_warnings {
+          parser.parse "begin; foo; rescue => e; bar; end" }
+        result.must_equal s(:rescue,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:resbody,
+                              s(:array, s(:lasgn, :e, s(:gvar, :$!))),
+                              s(:call, nil, :bar, s(:arglist))))
+      end
+
+      it "works with filtering of the exception type" do
+        result = parser.parse "begin; foo; rescue Bar; baz; end"
+        result.must_equal s(:rescue,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:resbody,
+                              s(:array, s(:const, :Bar)),
+                              s(:call, nil, :baz, s(:arglist))))
+      end
+
+      it "works with filtering of the exception type and assignment to an error variable" do
+        result = suppress_warnings {
+          parser.parse "begin; foo; rescue Bar => e; baz; end" }
+        result.must_equal s(:rescue,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:resbody,
+                              s(:array,
+                                s(:const, :Bar),
+                                s(:lasgn, :e, s(:gvar, :$!))),
+                              s(:call, nil, :baz, s(:arglist))))
+      end
+
+      it "works rescuing multiple exception types" do
+        result = parser.parse "begin; foo; rescue Bar, Baz; qux; end"
+        result.must_equal s(:rescue,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:resbody,
+                              s(:array, s(:const, :Bar), s(:const, :Baz)),
+                              s(:call, nil, :qux, s(:arglist))))
+      end
+
+      it "works in the postfix case" do
+        result = parser.parse "foo rescue bar"
+        result.must_equal s(:rescue,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:resbody,
+                              s(:array),
+                              s(:call, nil, :bar, s(:arglist))))
+      end
+    end
+
+    describe "for the ensure statement" do
+      it "works with single statement main and ensure bodies" do
+        result = parser.parse "begin; foo; ensure; bar; end"
+        result.must_equal s(:ensure,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:call, nil, :bar, s(:arglist)))
+      end
+
+      it "works with multi-statement main and ensure bodies" do
+        result = parser.parse "begin; foo; bar; ensure; baz; qux; end"
+        result.must_equal s(:ensure,
+                            s(:block,
+                              s(:call, nil, :foo, s(:arglist)),
+                              s(:call, nil, :bar, s(:arglist))),
+                            s(:block,
+                              s(:call, nil, :baz, s(:arglist)),
+                              s(:call, nil, :qux, s(:arglist))))
+      end
+
+      it "works together with rescue" do
+        result = parser.parse "begin; foo; rescue; bar; ensure; baz; end"
+        result.must_equal s(:ensure,
+                            s(:rescue,
+                              s(:call, nil, :foo, s(:arglist)),
+                              s(:resbody,
+                                s(:array),
+                                s(:call, nil, :bar, s(:arglist)))),
+                            s(:call, nil, :baz, s(:arglist)))
       end
     end
 
@@ -181,6 +394,14 @@ describe RipperRubyParser::Parser do
                               s(:call, nil, :bar, s(:arglist)),
                               s(:splat, s(:call, nil, :baz, s(:arglist)))))
       end
+
+      it "works for a simple case passing a block" do
+        result = parser.parse "foo &bar"
+        result.must_equal s(:call, nil, :foo,
+                            s(:arglist,
+                              s(:block_pass,
+                                s(:call, nil, :bar, s(:arglist)))))
+      end
     end
 
     describe "for array literals" do
@@ -226,6 +447,13 @@ describe RipperRubyParser::Parser do
       end
     end
 
+    describe "for number literals" do
+      it "works for floats" do
+        result = parser.parse "3.14"
+        result.must_equal s(:lit, 3.14)
+      end
+    end
+
     describe "for collection indexing" do
       it "works in the simple case" do
         result = parser.parse "foo[bar]"
@@ -273,6 +501,81 @@ describe RipperRubyParser::Parser do
                             s(:args, :bar),
                             s(:scope, s(:block, s(:nil))))
       end
+
+      it "works with a simple splat" do
+        result = parser.parse "def foo *bar; end"
+        result.must_equal s(:defn,
+                            :foo,
+                            s(:args, :"*bar"),
+                            s(:scope, s(:block, s(:nil))))
+      end
+
+      it "works with a regular argument plus splat" do
+        result = parser.parse "def foo bar, *baz; end"
+        result.must_equal s(:defn,
+                            :foo,
+                            s(:args, :bar, :"*baz"),
+                            s(:scope, s(:block, s(:nil))))
+      end
+
+      it "works with a nameless splat" do
+        result = parser.parse "def foo *; end"
+        result.must_equal s(:defn,
+                            :foo,
+                            s(:args, :"*"),
+                            s(:scope, s(:block, s(:nil))))
+      end
+
+      it "works for a simple case with explicit block parameter" do
+        result = parser.parse "def foo &bar; end"
+        result.must_equal s(:defn,
+                            :foo,
+                            s(:args, :"&bar"),
+                            s(:scope, s(:block, s(:nil))))
+      end
+
+      it "works with a regular argument plus explicit block parameter" do
+        result = parser.parse "def foo bar, &baz; end"
+        result.must_equal s(:defn,
+                            :foo,
+                            s(:args, :bar, :"&baz"),
+                            s(:scope, s(:block, s(:nil))))
+      end
+
+      it "works with a argument with default value plus explicit block parameter" do
+        result = parser.parse "def foo bar=1, &baz; end"
+        result.must_equal s(:defn,
+                            :foo,
+                            s(:args,
+                              :bar, :"&baz",
+                              s(:block,
+                                s(:lasgn, :bar, s(:lit, 1)))),
+                            s(:scope, s(:block, s(:nil))))
+      end
+
+      it "works with a splat plus explicit block parameter" do
+        result = parser.parse "def foo *bar, &baz; end"
+        result.must_equal s(:defn,
+                            :foo,
+                            s(:args, :"*bar", :"&baz"),
+                            s(:scope, s(:block, s(:nil))))
+      end
+
+      it "works with an argument with default value plus splat" do
+        result = parser.parse "def foo bar=1, *baz; end"
+        result.must_equal s(:defn,
+                            :foo,
+                            s(:args, :bar, :"*baz",
+                              s(:block,
+                                s(:lasgn, :bar, s(:lit, 1)))),
+                            s(:scope, s(:block, s(:nil))))
+      end
+
+      it "works when the method name is an operator" do
+        result = parser.parse "def +; end"
+        result.must_equal s(:defn, :+, s(:args),
+                            s(:scope, s(:block, s(:nil))))
+      end
     end
 
     describe "for method calls" do
@@ -289,10 +592,20 @@ describe RipperRubyParser::Parser do
                               s(:arglist, s(:call, nil, :bar, s(:arglist))))
         end
 
+        it "works with an empty parameter list and no brackets" do
+          result = parser.parse "foo"
+          result.must_equal s(:call, nil, :foo, s(:arglist))
+        end
+
         it "works with brackets around an empty parameter list" do
           result = parser.parse "foo()"
           result.must_equal s(:call, nil, :foo, s(:arglist))
         end
+
+        it "works for methods ending in a question mark" do
+          result = parser.parse "foo?"
+          result.must_equal s(:call, nil, :foo?, s(:arglist))
+        end
       end
 
       describe "with a reciever" do
@@ -351,6 +664,49 @@ describe RipperRubyParser::Parser do
       end
     end
 
+    describe "for yield" do
+      it "works with no arguments and no brackets" do
+        result = parser.parse "yield"
+        result.must_equal s(:yield)
+      end
+
+      it "works with brackets but no arguments" do
+        result = parser.parse "yield()"
+        result.must_equal s(:yield)
+      end
+
+      it "works with one argument and no brackets" do
+        result = parser.parse "yield foo"
+        result.must_equal s(:yield, s(:call, nil, :foo, s(:arglist)))
+      end
+
+      it "works with one argument and brackets" do
+        result = parser.parse "yield(foo)"
+        result.must_equal s(:yield, s(:call, nil, :foo, s(:arglist)))
+      end
+
+      it "works with multiple arguments and no brackets" do
+        result = parser.parse "yield foo, bar"
+        result.must_equal s(:yield,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:call, nil, :bar, s(:arglist)))
+      end
+
+      it "works with multiple arguments and brackets" do
+        result = parser.parse "yield(foo, bar)"
+        result.must_equal s(:yield,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:call, nil, :bar, s(:arglist)))
+      end
+
+      it "works with splat" do
+        result = parser.parse "yield foo, *bar"
+        result.must_equal s(:yield,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:splat, s(:call, nil, :bar, s(:arglist))))
+      end
+    end
+
     describe "for literals" do
       it "works for symbols" do
         result = parser.parse ":foo"
@@ -440,10 +796,17 @@ describe RipperRubyParser::Parser do
         result.must_equal s(:lit, /\)\n\\/)
       end
 
-      it "works for symbols created by prefixing a simple string with :" do
+      it "works for simple dsyms" do
         result = parser.parse ':"foo"'
         result.must_equal s(:lit, :foo)
       end
+
+      it "works for dsyms with interpolations" do
+        result = parser.parse ':"foo#{bar}"'
+        result.must_equal s(:dsym,
+                            "foo",
+                            s(:evstr, s(:call, nil, :bar, s(:arglist))))
+      end
     end
 
     describe "for the __FILE__ keyword" do
@@ -458,9 +821,26 @@ describe RipperRubyParser::Parser do
         result = parser.parse "::Foo"
         result.must_equal s(:colon3, :Foo)
       end
+
+      it "works with a three-level constant lookup" do
+        result = parser.parse "Foo::Bar::Baz"
+        result.must_equal s(:colon2,
+                            s(:colon2, s(:const, :Foo), :Bar),
+                            :Baz)
+      end
     end
 
     describe "for variable references" do
+      it "works for self" do
+        result = parser.parse "self"
+        result.must_equal s(:self)
+      end
+
+      it "works for instance variables" do
+        result = parser.parse "@foo"
+        result.must_equal s(:ivar, :@foo)
+      end
+
       it "works for global variables" do
         result = parser.parse "$foo"
         result.must_equal s(:gvar, :$foo)
@@ -470,6 +850,11 @@ describe RipperRubyParser::Parser do
         result = parser.parse "$1"
         result.must_equal s(:nth_ref, 1)
       end
+
+      it "works for class variables" do
+        result = parser.parse "@@foo"
+        result.must_equal s(:cvar, :@@foo)
+      end
     end
 
     describe "for single assignment" do
@@ -496,11 +881,33 @@ describe RipperRubyParser::Parser do
                               s(:call, nil, :bar, s(:arglist)),
                               s(:call, nil, :baz, s(:arglist))))
       end
+
+      it "works when assigning to an attribute" do
+        result = parser.parse "foo.bar = baz"
+        result.must_equal s(:attrasgn,
+                            s(:call, nil, :foo, s(:arglist)),
+                            :bar=,
+                            s(:arglist, s(:call, nil, :baz, s(:arglist))))
+      end
+
+      it "works when assigning to a class variable" do
+        result = parser.parse "@@foo = bar"
+        result.must_equal s(:cvdecl,
+                            :@@foo,
+                            s(:call, nil, :bar, s(:arglist)))
+      end
+
+      it "works when assigning to a global variable" do
+        result = parser.parse "$foo = bar"
+        result.must_equal s(:gasgn,
+                            :$foo,
+                            s(:call, nil, :bar, s(:arglist)))
+      end
     end
 
     describe "for operator assignment" do
       it "works with +=" do
-        result = parser.parse "foo += bar"
+        result = suppress_warnings { parser.parse "foo += bar" }
         result.must_equal s(:lasgn,
                             :foo,
                             s(:call,
@@ -510,7 +917,7 @@ describe RipperRubyParser::Parser do
       end
 
       it "works with -=" do
-        result = parser.parse "foo -= bar"
+        result = suppress_warnings { parser.parse "foo -= bar" }
         result.must_equal s(:lasgn,
                             :foo,
                             s(:call,
@@ -519,6 +926,14 @@ describe RipperRubyParser::Parser do
                               s(:arglist, s(:call, nil, :bar, s(:arglist)))))
       end
 
+      it "works with ||=" do
+        result = suppress_warnings { parser.parse "foo ||= bar" }
+        result.must_equal s(:op_asgn_or,
+                            s(:lvar, :foo),
+                            s(:lasgn, :foo,
+                              s(:call, nil, :bar, s(:arglist))))
+      end
+
       it "works when assigning to an instance variable" do
         result = parser.parse "@foo += bar"
         result.must_equal s(:iasgn,
@@ -537,11 +952,38 @@ describe RipperRubyParser::Parser do
                             :+,
                             s(:call, nil, :baz, s(:arglist)))
       end
+
+      it "works with ||= when assigning to a collection element" do
+        result = parser.parse "foo[bar] ||= baz"
+        result.must_equal s(:op_asgn1,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:arglist, s(:call, nil, :bar, s(:arglist))),
+                            :"||",
+                            s(:call, nil, :baz, s(:arglist)))
+      end
+
+      it "works when assigning to an attribute" do
+        result = parser.parse "foo.bar += baz"
+        result.must_equal s(:op_asgn2,
+                            s(:call, nil, :foo, s(:arglist)),
+                            :bar=,
+                            :+,
+                            s(:call, nil, :baz, s(:arglist)))
+      end
+
+      it "works with ||= when assigning to an attribute" do
+        result = parser.parse "foo.bar ||= baz"
+        result.must_equal s(:op_asgn2,
+                            s(:call, nil, :foo, s(:arglist)),
+                            :bar=,
+                            :"||",
+                            s(:call, nil, :baz, s(:arglist)))
+      end
     end
 
     describe "for multiple assignment" do
       it "works the same number of items on each side" do
-        result = parser.parse "foo, bar = baz, qux"
+        result = suppress_warnings { parser.parse "foo, bar = baz, qux" }
         result.must_equal s(:masgn,
                             s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
                             s(:array,
@@ -550,7 +992,7 @@ describe RipperRubyParser::Parser do
       end
 
       it "works with a single item on the right-hand side" do
-        result = parser.parse "foo, bar = baz"
+        result = suppress_warnings { parser.parse "foo, bar = baz" }
         result.must_equal s(:masgn,
                             s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
                             s(:to_ary,
@@ -558,16 +1000,117 @@ describe RipperRubyParser::Parser do
       end
 
       it "works with left-hand splat" do
-        result = parser.parse "foo, *bar = baz, qux"
+        result = suppress_warnings { parser.parse "foo, *bar = baz, qux" }
         result.must_equal s(:masgn,
                             s(:array, s(:lasgn, :foo), s(:splat, s(:lasgn, :bar))),
                             s(:array,
                               s(:call, nil, :baz, s(:arglist)),
                               s(:call, nil, :qux, s(:arglist))))
       end
+
+      it "works with brackets around the left-hand side" do
+        result = suppress_warnings { parser.parse "(foo, bar) = baz" }
+        result.must_equal s(:masgn,
+                            s(:array, s(:lasgn, :foo), s(:lasgn, :bar)),
+                            s(:to_ary,
+                              s(:call, nil, :baz, s(:arglist))))
+      end
+
+      it "works with complex destructuring" do
+        result = suppress_warnings { parser.parse "foo, (bar, baz) = qux" }
+        result.must_equal s(:masgn,
+                            s(:array,
+                              s(:lasgn, :foo),
+                              s(:masgn,
+                                s(:array,
+                                  s(:lasgn, :bar),
+                                  s(:lasgn, :baz)))),
+                            s(:to_ary,
+                              s(:call, nil, :qux, s(:arglist))))
+      end
+
+      it "works with instance variables" do
+        result = parser.parse "@foo, @bar = baz"
+        result.must_equal s(:masgn,
+                            s(:array, s(:iasgn, :@foo), s(:iasgn, :@bar)),
+                            s(:to_ary,
+                              s(:call, nil, :baz, s(:arglist))))
+      end
+
+      it "works with class variables" do
+        result = parser.parse "@@foo, @@bar = baz"
+        result.must_equal s(:masgn,
+                            s(:array, s(:cvdecl, :@@foo), s(:cvdecl, :@@bar)),
+                            s(:to_ary,
+                              s(:call, nil, :baz, s(:arglist))))
+      end
+
+      it "works with attributes" do
+        result = parser.parse "foo.bar, foo.baz = qux"
+        result.must_equal s(:masgn,
+                            s(:array,
+                              s(:attrasgn,
+                                s(:call, nil, :foo, s(:arglist)),
+                                :bar=,
+                                s(:arglist)),
+                              s(:attrasgn,
+                                s(:call, nil, :foo, s(:arglist)),
+                                :baz=,
+                                s(:arglist))),
+                            s(:to_ary,
+                              s(:call, nil, :qux, s(:arglist))))
+      end
+
+      it "works with collection elements" do
+        result = parser.parse "foo[1], bar[2] = baz"
+        result.must_equal s(:masgn,
+                            s(:array,
+                              s(:attrasgn,
+                                s(:call, nil, :foo, s(:arglist)),
+                                :[]=,
+                                s(:arglist, s(:lit, 1))),
+                              s(:attrasgn,
+                                s(:call, nil, :bar, s(:arglist)),
+                                :[]=,
+                                s(:arglist, s(:lit, 2)))),
+                            s(:to_ary, s(:call, nil, :baz, s(:arglist))))
+      end
+
+      it "works with constants" do
+        result = parser.parse "Foo, Bar = baz"
+        result.must_equal s(:masgn,
+                            s(:array, s(:cdecl, :Foo), s(:cdecl, :Bar)),
+                            s(:to_ary,
+                              s(:call, nil, :baz, s(:arglist))))
+      end
+
+      it "works with instance variables and splat" do
+        result = parser.parse "@foo, *@bar = baz"
+        result.must_equal s(:masgn,
+                            s(:array,
+                              s(:iasgn, :@foo),
+                              s(:splat, s(:iasgn, :@bar))),
+                            s(:to_ary,
+                              s(:call, nil, :baz, s(:arglist))))
+      end
+
     end
 
     describe "for operators" do
+      it "handles :and" do
+        result = parser.parse "foo and bar"
+        result.must_equal s(:and,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:call, nil, :bar, s(:arglist)))
+      end
+
+      it "handles :or" do
+        result = parser.parse "foo or bar"
+        result.must_equal s(:or,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:call, nil, :bar, s(:arglist)))
+      end
+
       it "converts :&& to :and" do
         result = parser.parse "foo && bar"
         result.must_equal s(:and,
@@ -582,6 +1125,38 @@ describe RipperRubyParser::Parser do
                             s(:call, nil, :bar, s(:arglist)))
       end
 
+      it "handles :!=" do
+        result = parser.parse "foo != bar"
+        result.must_equal s(:not,
+                              s(:call,
+                                s(:call, nil, :foo, s(:arglist)),
+                                :==,
+                                s(:arglist,
+                                  s(:call, nil, :bar, s(:arglist)))))
+      end
+
+      it "handles :=~ with two non-literals" do
+        result = parser.parse "foo =~ bar"
+        result.must_equal s(:call,
+                            s(:call, nil, :foo, s(:arglist)),
+                            :=~,
+                            s(:arglist, s(:call, nil, :bar, s(:arglist))))
+      end
+
+      it "handles :=~ with literal regexp on the left hand side" do
+        result = parser.parse "/foo/ =~ bar"
+        result.must_equal s(:match2,
+                            s(:lit, /foo/),
+                            s(:call, nil, :bar, s(:arglist)))
+      end
+
+      it "handles :=~ with literal regexp on the right hand side" do
+        result = parser.parse "foo =~ /bar/"
+        result.must_equal s(:match3,
+                            s(:lit, /bar/),
+                            s(:call, nil, :foo, s(:arglist)))
+      end
+
       it "handles unary minus with a number literal" do
         result = parser.parse "-1"
         result.must_equal s(:lit, -1)
@@ -595,6 +1170,29 @@ describe RipperRubyParser::Parser do
                             s(:arglist))
       end
 
+      it "handles unary plus with a number literal" do
+        result = parser.parse "+ 1"
+        result.must_equal s(:lit, 1)
+      end
+
+      it "handles unary plus with a non-literal" do
+        result = parser.parse "+ foo"
+        result.must_equal s(:call,
+                            s(:call, nil, :foo, s(:arglist)),
+                            :+@,
+                            s(:arglist))
+      end
+
+      it "handles unary not" do
+        result = parser.parse "not foo"
+        result.must_equal s(:not, s(:call, nil, :foo, s(:arglist)))
+      end
+
+      it "converts :! to :not" do
+        result = parser.parse "!foo"
+        result.must_equal s(:not, s(:call, nil, :foo, s(:arglist)))
+      end
+
       it "handles the range operator with positive number literals" do
         result = parser.parse "1..2"
         result.must_equal s(:lit, 1..2)
@@ -618,6 +1216,203 @@ describe RipperRubyParser::Parser do
                             s(:call, nil, :foo, s(:arglist)),
                             s(:call, nil, :bar, s(:arglist)))
       end
+
+      it "handles the ternary operator" do
+        result = parser.parse "foo ? bar : baz"
+        result.must_equal s(:if,
+                            s(:call, nil, :foo, s(:arglist)),
+                            s(:call, nil, :bar, s(:arglist)),
+                            s(:call, nil, :baz, s(:arglist)))
+      end
+    end
+
+    describe "for expressions" do
+      it "handles assignment inside binary operator expressions" do
+        result = suppress_warnings { parser.parse "foo + (bar = baz)" }
+        result.must_equal s(:call,
+                            s(:call, nil, :foo, s(:arglist)),
+                            :+,
+                            s(:arglist,
+                              s(:lasgn,
+                                :bar,
+                                s(:call, nil, :baz, s(:arglist)))))
+      end
+
+      it "handles assignment inside unary operator expressions" do
+        result = suppress_warnings { parser.parse "+(foo = bar)" }
+        result.must_equal s(:call,
+                            s(:lasgn, :foo, s(:call, nil, :bar, s(:arglist))),
+                            :+@,
+                            s(:arglist))
+      end
+    end
+
+    # Note: differences in the handling of comments are not caught by Sexp's
+    # implementation of equality.
+    describe "for comments" do
+      it "handles method comments" do
+        result = parser.parse "# Foo\ndef foo; end"
+        result.must_equal s(:defn,
+                            :foo,
+                            s(:args), s(:scope, s(:block, s(:nil))))
+        result.comments.must_equal "# Foo\n"
+      end
+
+      it "matches comments to the correct entity" do
+        result = parser.parse "# Foo\nclass Foo\n# Bar\ndef bar\nend\nend"
+        result.must_equal s(:class, :Foo, nil,
+                            s(:scope,
+                              s(:defn, :bar,
+                                s(:args), s(:scope, s(:block, s(:nil))))))
+        result.comments.must_equal "# Foo\n"
+        defn = result[3][1]
+        defn.sexp_type.must_equal :defn
+        defn.comments.must_equal "# Bar\n"
+      end
+
+      it "combines multi-line comments" do
+        result = parser.parse "# Foo\n# Bar\ndef foo; end"
+        result.must_equal s(:defn,
+                            :foo,
+                            s(:args), s(:scope, s(:block, s(:nil))))
+        result.comments.must_equal "# Foo\n# Bar\n"
+      end
+    end
+
+    # Note: differences in the handling of line numbers are not caught by
+    # Sexp's implementation of equality.
+    describe "assigning line numbers" do
+      it "works for a plain method call" do
+        result = parser.parse "foo"
+        result.line.must_equal 1
+      end
+
+      it "works for a method call with brackets" do
+        result = parser.parse "foo()"
+        result.line.must_equal 1
+      end
+
+      it "works for a method call with reciever" do
+        result = parser.parse "foo.bar"
+        result.line.must_equal 1
+      end
+
+      it "works for a method call with reciever and arguments" do
+        result = parser.parse "foo.bar baz"
+        result.line.must_equal 1
+      end
+
+      it "works for a method call with arguments" do
+        result = parser.parse "foo bar"
+        result.line.must_equal 1
+      end
+
+      it "works for a block with two lines" do
+        result = parser.parse "foo\nbar\n"
+        result.sexp_type.must_equal :block
+        result[1].line.must_equal 1
+        result[2].line.must_equal 2
+        result.line.must_equal 1
+      end
+
+      it "works for a constant reference" do
+        result = parser.parse "Foo"
+        result.line.must_equal 1
+      end
+
+      it "works for an instance variable" do
+        result = parser.parse "@foo"
+        result.line.must_equal 1
+      end
+
+      it "works for a global variable" do
+        result = parser.parse "$foo"
+        result.line.must_equal 1
+      end
+
+      it "works for a class variable" do
+        result = parser.parse "@@foo"
+        result.line.must_equal 1
+      end
+
+      it "works for a local variable" do
+        result = parser.parse "foo = bar\nfoo\n"
+        result.sexp_type.must_equal :block
+        result[1].line.must_equal 1
+        result[2].line.must_equal 2
+        result.line.must_equal 1
+      end
+
+      it "works for an integer literal" do
+        result = parser.parse "42"
+        result.line.must_equal 1
+      end
+
+      it "works for a float literal" do
+        result = parser.parse "3.14"
+        result.line.must_equal 1
+      end
+
+      it "works for a regular expression back reference" do
+        result = parser.parse "$1"
+        result.line.must_equal 1
+      end
+
+      it "works for self" do
+        result = parser.parse "self"
+        result.line.must_equal 1
+      end
+
+      it "works for __FILE__" do
+        result = parser.parse "__FILE__"
+        result.line.must_equal 1
+      end
+
+      it "works for nil" do
+        result = parser.parse "nil"
+        result.line.must_equal 1
+      end
+
+      it "works for a symbol literal" do
+        result = parser.parse ":foo"
+        result.line.must_equal 1
+      end
+
+      it "works for a class definition" do
+        result = parser.parse "class Foo; end"
+        result.line.must_equal 1
+      end
+
+      it "works for a module definition" do
+        result = parser.parse "module Foo; end"
+        result.line.must_equal 1
+      end
+
+      it "works for a method definition" do
+        result = parser.parse "def foo; end"
+        result.line.must_equal 1
+      end
+
+      it "works for assignment of the empty hash" do
+        result = suppress_warnings { parser.parse "foo = {}" }
+        result.line.must_equal 1
+      end
+
+      it "works for multiple assignment of empty hashes" do
+        result = suppress_warnings { parser.parse "foo, bar = {}, {}" }
+        result.line.must_equal 1
+      end
+
+      it "assigns line numbers to all nested sexps" do
+        result = parser.parse "foo() do\nend\n"
+        result.must_equal s(:iter,
+                            s(:call,
+                              nil, :foo, s(:arglist)), nil, s(:block))
+        arglist = result[1][3]
+        block = result[3]
+        nums = [ arglist.line, block.line ]
+        nums.must_equal [1, 1]
+      end
     end
   end
 end