ripper_ruby_parser 1.0.0 → 1.1.0

data/test/test_helper.rb

@@ -1,9 +1,6 @@
-begin
-  require 'simplecov'
-  SimpleCov.start do
-    add_filter "/test/"
-  end
-rescue LoadError
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/test/"
 end
 
 require 'minitest/autorun'
@@ -12,45 +9,50 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 require 'ripper_ruby_parser'
 
-class MiniTest::Spec
-  def formatted exp
-    exp.to_s.gsub(/\), /, "),\n")
-  end
+module MiniTest
+  class Spec
+    def formatted exp
+      exp.to_s.gsub(/\), /, "),\n")
+    end
 
-  def to_comments exp
-    inner = exp.map do |sub_exp|
-      if sub_exp.is_a? Sexp
-        to_comments sub_exp
+    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
+
+      comments = exp.comments.to_s.gsub(/\n\s*\n/, "\n")
+      if comments.empty?
+        s(*inner)
       else
-        sub_exp
+        s(:comment, comments, s(*inner))
       end
     end
 
-    comments = exp.comments.to_s.gsub(/\n\s*\n/, "\n")
-    if comments.empty?
-      s(*inner)
-    else
-      s(:comment, comments, s(*inner))
+    def assert_parsed_as sexp, code
+      parser = RipperRubyParser::Parser.new
+      result = parser.parse code
+      if sexp.nil?
+        assert_nil result
+      else
+        assert_equal sexp, result
+      end
     end
-  end
 
-  def assert_parsed_as sexp, code
-    parser = RipperRubyParser::Parser.new
-    result = parser.parse code
-    assert_equal sexp, result
+    def assert_parsed_as_before code
+      oldparser = RubyParser.new
+      newparser = RipperRubyParser::Parser.new
+      expected = oldparser.parse code.dup
+      result = newparser.parse code
+      assert_equal formatted(expected), formatted(result)
+    end
   end
 
-  def assert_parsed_as_before code
-    oldparser = RubyParser.new
-    newparser = RipperRubyParser::Parser.new
-    expected = oldparser.parse code.dup
-    result = newparser.parse code
-    assert_equal formatted(expected), formatted(result)
+  module Expectations
+    infect_an_assertion :assert_parsed_as, :must_be_parsed_as
+    infect_an_assertion :assert_parsed_as_before, :must_be_parsed_as_before, :unary
   end
 end
-
-module MiniTest::Expectations
-  infect_an_assertion :assert_parsed_as, :must_be_parsed_as
-  infect_an_assertion :assert_parsed_as_before, :must_be_parsed_as_before, :unary
-end
-

data/test/unit/commenting_ripper_parser_test.rb

@@ -11,111 +11,109 @@ describe RipperRubyParser::CommentingRipperParser do
                              num_params = RUBY_VERSION < "2.0.0" ? 5 : 7
                              s(:params, *([nil] * num_params))
                            end
-
   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 s(:program,
-                         s(s(:comment,
-                           "# Foo\n",
-                           s(:def,
-                            s(:@ident, "foo", s(2, 4)),
-                            empty_params_list,
-                            s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+                          s(s(:comment,
+                              "# Foo\n",
+                              s(:def,
+                                s(:@ident, "foo", s(2, 4)),
+                                empty_params_list,
+                                s(:bodystmt, s(s(: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 s(:program,
-                         s(s(:comment,
-                           "",
-                           s(:def,
-                           s(:@ident, "foo", s(1, 4)),
-                           empty_params_list,
-                           s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+                          s(s(:comment,
+                              "",
+                              s(:def,
+                                s(:@ident, "foo", s(1, 4)),
+                                empty_params_list,
+                                s(:bodystmt, s(s(: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 s(:program,
-                         s(s(:comment,
-                           "# Foo\n",
-                           s(:class,
-                            s(:const_ref, s(:@const, "Foo", s(2, 6))),
-                            nil,
-                            s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+                          s(s(:comment,
+                              "# Foo\n",
+                              s(:class,
+                                s(:const_ref, s(:@const, "Foo", s(2, 6))),
+                                nil,
+                                s(:bodystmt, s(s(: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 s(:program,
-                         s(s(:comment,
-                           "",
-                           s(:class,
-                           s(:const_ref, s(:@const, "Foo", s(1, 6))),
-                           nil,
-                           s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+                          s(s(:comment,
+                              "",
+                              s(:class,
+                                s(:const_ref, s(:@const, "Foo", s(1, 6))),
+                                nil,
+                                s(:bodystmt, s(s(: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 s(:program,
-                         s(s(:comment,
-                           "# Foo\n",
-                           s(:module,
-                            s(:const_ref, s(:@const, "Foo", s(2, 7))),
-                            s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+                          s(s(:comment,
+                              "# Foo\n",
+                              s(:module,
+                                s(:const_ref, s(:@const, "Foo", s(2, 7))),
+                                s(:bodystmt, s(s(: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 s(:program,
-                         s(s(:comment,
-                           "",
-                           s(:module,
-                           s(:const_ref, s(:@const, "Foo", s(1, 7))),
-                           s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+                          s(s(:comment,
+                              "",
+                              s(:module,
+                                s(:const_ref, s(:@const, "Foo", s(1, 7))),
+                                s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
     end
 
     it "is not confused by a symbol containing a keyword" do
       result = parse_with_builder ":class; def foo; end"
       result.must_equal s(:program,
-                         s(s(:symbol_literal, s(:symbol, s(:@kw, "class", s(1, 1)))),
-                          s(:comment,
-                           "",
-                           s(:def,
-                            s(:@ident, "foo", s(1, 12)),
-                            empty_params_list,
-                            s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+                          s(s(:symbol_literal, s(:symbol, s(:@kw, "class", s(1, 1)))),
+                            s(:comment,
+                              "",
+                              s(:def,
+                                s(:@ident, "foo", s(1, 12)),
+                                empty_params_list,
+                                s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
     end
 
     it "is not confused by a dynamic symbol" do
       result = parse_with_builder ":'foo'; def bar; end"
       result.must_equal s(:program,
-                         s(s(:dyna_symbol, s(s(:@tstring_content, "foo", s(1, 2)))),
-                          s(:comment,
-                           "",
-                           s(:def,
-                            s(:@ident, "bar", s(1, 12)),
-                            empty_params_list,
-                            s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
+                          s(s(:dyna_symbol, s(s(:@tstring_content, "foo", s(1, 2)))),
+                            s(:comment,
+                              "",
+                              s(:def,
+                                s(:@ident, "bar", s(1, 12)),
+                                empty_params_list,
+                                s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))
     end
 
     it "is not confused by a dynamic symbol containing a class definition" do
       result = parse_with_builder ":\"foo\#{class Bar;end}\""
       result.must_equal s(:program,
-                         s(s(:dyna_symbol,
-                           s(s(:@tstring_content, "foo", s(1, 2)),
-                            s(:string_embexpr,
-                             s(s(:comment,
-                               "",
-                               s(:class,
-                                s(:const_ref, s(:@const, "Bar", s(1, 13))),
-                                nil,
-                                s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))))))
+                          s(s(:dyna_symbol,
+                              s(s(:@tstring_content, "foo", s(1, 2)),
+                                s(:string_embexpr,
+                                  s(s(:comment,
+                                      "",
+                                      s(:class,
+                                        s(:const_ref, s(:@const, "Bar", s(1, 13))),
+                                        nil,
+                                        s(:bodystmt, s(s(:void_stmt)), nil, nil, nil)))))))))
     end
   end
 end
-

data/test/unit/parser_blocks_test.rb

@@ -33,11 +33,19 @@ describe RipperRubyParser::Parser do
                               s(:args, :bar, :"&baz"))
       end
 
+      it "handles absent parameter specs" do
+        "foo do; bar; end".
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :foo),
+                              0,
+                              s(:call, nil, :bar))
+      end
+
       it "handles empty parameter specs" do
         "foo do ||; bar; end".
           must_be_parsed_as s(:iter,
                               s(:call, nil, :foo),
-                              0,
+                              s(:args),
                               s(:call, nil, :bar))
       end
 
@@ -261,7 +269,15 @@ describe RipperRubyParser::Parser do
           must_be_parsed_as s(:iter,
                               s(:call, nil, :lambda),
                               s(:args, :foo),
-                              s(:call, nil, :bar)) 
+                              s(:call, nil, :bar))
+      end
+
+      it "works when there are zero arguments" do
+        "->() { bar }".
+          must_be_parsed_as s(:iter,
+                              s(:call, nil, :lambda),
+                              s(:args),
+                              s(:call, nil, :bar))
       end
 
       it "works when there are no arguments" do
@@ -269,7 +285,7 @@ describe RipperRubyParser::Parser do
           must_be_parsed_as s(:iter,
                               s(:call, nil, :lambda),
                               0,
-                              s(:call, nil, :bar)) 
+                              s(:call, nil, :bar))
       end
     end
   end

data/test/unit/parser_conditionals_test.rb

@@ -264,7 +264,6 @@ describe RipperRubyParser::Parser do
                                   s(:splat, s(:call, nil, :bar))),
                                 s(:call, nil, :baz)),
                               nil)
-
       end
     end
   end

data/test/unit/parser_literals_test.rb

@@ -1,4 +1,3 @@
-# coding: utf-8
 require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 
 describe RipperRubyParser::Parser do
@@ -140,7 +139,7 @@ describe RipperRubyParser::Parser do
         result[1].encoding.to_s.must_equal "UTF-8"
       end
 
-      describe "with escape sequences" do
+      describe "with double-quoted strings with escape sequences" do
         it "works for strings with escape sequences" do
           "\"\\n\"".
             must_be_parsed_as s(:str, "\n")
@@ -156,12 +155,12 @@ describe RipperRubyParser::Parser do
             must_be_parsed_as s(:str, "\\n")
         end
 
-        it "works for a double-quoted string representing a regex literal with escaped right bracket" do
+        it "works for a representation of a regex literal with escaped right bracket" do
           "\"/\\\\)/\"".
             must_be_parsed_as s(:str, "/\\)/")
         end
 
-        it "works for a double-quoted string containing a uselessly escaped right bracket" do
+        it "works for a uselessly escaped right bracket" do
           "\"/\\)/\"".
             must_be_parsed_as s(:str, "/)/")
         end
@@ -247,8 +246,8 @@ describe RipperRubyParser::Parser do
 
           it "works for cvars" do
             "\"foo\#@@bar\"".must_be_parsed_as s(:dstr,
-                                                "foo",
-                                                s(:evstr, s(:cvar, :@@bar)))
+                                                 "foo",
+                                                 s(:evstr, s(:cvar, :@@bar)))
           end
         end
 
@@ -288,10 +287,10 @@ describe RipperRubyParser::Parser do
 
           it "works for strings with interpolations followed by escape sequences" do
             '"#{foo}\\n"'.
-              must_be_parsed_as  s(:dstr,
-                                   "",
-                                   s(:evstr, s(:call, nil, :foo)),
-                                   s(:str, "\n"))
+              must_be_parsed_as s(:dstr,
+                                  "",
+                                  s(:evstr, s(:call, nil, :foo)),
+                                  s(:str, "\n"))
           end
 
           it "works with an empty interpolation" do
@@ -324,21 +323,23 @@ describe RipperRubyParser::Parser do
                                 s(:str, "baz"))
         end
 
-        it "performs the concatenation when both strings have interpolations" do
-          "\"foo\#{bar}\" \"baz\#{qux}\"".
-            must_be_parsed_as s(:dstr,
-                                "foo",
-                                s(:evstr, s(:call, nil, :bar)),
-                                s(:str, "baz"),
-                                s(:evstr, s(:call, nil, :qux)))
-        end
+        describe "when both strings have interpolations" do
+          it "performs the concatenation" do
+            "\"foo\#{bar}\" \"baz\#{qux}\"".
+              must_be_parsed_as s(:dstr,
+                                  "foo",
+                                  s(:evstr, s(:call, nil, :bar)),
+                                  s(:str, "baz"),
+                                  s(:evstr, s(:call, nil, :qux)))
+          end
 
-        it "removes empty substrings from the concatenation when both strings have interpolations" do
-          "\"foo\#{bar}\" \"\#{qux}\"".
-            must_be_parsed_as s(:dstr,
-                                "foo",
-                                s(:evstr, s(:call, nil, :bar)),
-                                s(:evstr, s(:call, nil, :qux)))
+          it "removes empty substrings from the concatenation" do
+            "\"foo\#{bar}\" \"\#{qux}\"".
+              must_be_parsed_as s(:dstr,
+                                  "foo",
+                                  s(:evstr, s(:call, nil, :bar)),
+                                  s(:evstr, s(:call, nil, :qux)))
+          end
         end
       end
     end
@@ -514,6 +515,5 @@ describe RipperRubyParser::Parser do
           must_be_parsed_as s(:lit, 448)
       end
     end
-
   end
 end

data/test/unit/parser_method_calls_test.rb

@@ -103,8 +103,8 @@ describe RipperRubyParser::Parser do
                                 s(:call,
                                   s(:call, nil, :foo),
                                   :bar),
-                                  s(:args),
-                                  s(:call, nil, :baz))
+                                0,
+                                s(:call, nil, :baz))
         end
 
         it "works for a do block with several statements" do
@@ -113,33 +113,38 @@ describe RipperRubyParser::Parser do
                                 s(:call,
                                   s(:call, nil, :foo),
                                   :bar),
-                                  s(:args),
-                                  s(:block,
-                                    s(:call, nil, :baz),
-                                    s(:call, nil, :qux)))
+                                0,
+                                s(:block,
+                                  s(:call, nil, :baz),
+                                  s(:call, nil, :qux)))
         end
       end
     end
 
     describe "for calls to super" do
       specify { "super".must_be_parsed_as s(:zsuper) }
-      specify { "super foo".must_be_parsed_as s(:super,
-                                                s(:call, nil, :foo)) }
-      specify {
+      specify do
+        "super foo".must_be_parsed_as s(:super,
+                                        s(:call, nil, :foo))
+      end
+      specify do
         "super foo, bar".must_be_parsed_as s(:super,
                                              s(:call, nil, :foo),
-                                             s(:call, nil, :bar)) }
-      specify {
+                                             s(:call, nil, :bar))
+      end
+      specify do
         "super foo, *bar".must_be_parsed_as s(:super,
                                               s(:call, nil, :foo),
                                               s(:splat,
-                                                s(:call, nil, :bar))) }
-      specify {
+                                                s(:call, nil, :bar)))
+      end
+      specify do
         "super foo, *bar, &baz".
           must_be_parsed_as s(:super,
                               s(:call, nil, :foo),
                               s(:splat, s(:call, nil, :bar)),
-                              s(:block_pass, s(:call, nil, :baz))) }
+                              s(:block_pass, s(:call, nil, :baz)))
+      end
     end
 
     it "handles calling a proc" do
@@ -148,4 +153,3 @@ describe RipperRubyParser::Parser do
     end
   end
 end
-