ripper_ruby_parser 0.0.8 → 1.0.0

data/test/unit/parser_conditionals_test.rb

@@ -2,25 +2,267 @@ require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 
 describe RipperRubyParser::Parser do
   describe "#parse" do
+    describe "for regular if" do
+      it "works with a single statement" do
+        "if foo; bar; end".
+          must_be_parsed_as s(:if,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar),
+                              nil)
+      end
+
+      it "works with multiple statements" do
+        "if foo; bar; baz; end".
+          must_be_parsed_as s(:if,
+                              s(:call, nil, :foo),
+                              s(:block,
+                                s(:call, nil, :bar),
+                                s(:call, nil, :baz)),
+                              nil)
+      end
+
+      it "works with an else clause" do
+        "if foo; bar; else; baz; end".
+          must_be_parsed_as s(:if,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar),
+                              s(:call, nil, :baz))
+      end
+
+      it "works with an elsif clause" do
+        "if foo; bar; elsif baz; qux; end".
+          must_be_parsed_as s(:if,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar),
+                              s(:if,
+                                s(:call, nil, :baz),
+                                s(:call, nil, :qux),
+                                nil))
+      end
+
+      it "handles a negative condition correctly" do
+        "if not foo; bar; end".
+          must_be_parsed_as s(:if,
+                              s(:call, s(:call, nil, :foo), :!),
+                              s(:call, nil, :bar),
+                              nil)
+      end
+
+      it "handles a negative condition in elsif correctly" do
+        "if foo; bar; elsif not baz; qux; end".
+          must_be_parsed_as s(:if,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar),
+                              s(:if,
+                                s(:call, s(:call, nil, :baz), :!),
+                                s(:call, nil, :qux), nil))
+      end
+
+      it "handles bare regex literal in condition" do
+        "if /foo/; bar; end".
+          must_be_parsed_as s(:if,
+                              s(:match, s(:lit, /foo/)),
+                              s(:call, nil, :bar),
+                              nil)
+      end
+
+      it "handles interpolated regex in condition" do
+        'if /#{foo}/; bar; end'.
+          must_be_parsed_as s(:if,
+                              s(:dregx, "", s(:evstr, s(:call, nil, :foo))),
+                              s(:call, nil, :bar),
+                              nil)
+      end
+
+      it "handles block conditions" do
+        "if (foo; bar); baz; end".
+          must_be_parsed_as s(:if,
+                              s(:block, s(:call, nil, :foo), s(:call, nil, :bar)),
+                              s(:call, nil, :baz),
+                              nil)
+      end
+
+      it "converts :dot2 to :flip2" do
+        "if foo..bar; baz; end".
+          must_be_parsed_as s(:if,
+                              s(:flip2, s(:call, nil, :foo), s(:call, nil, :bar)),
+                              s(:call, nil, :baz),
+                              nil)
+      end
+
+      it "converts :dot3 to :flip3" do
+        "if foo...bar; baz; end".
+          must_be_parsed_as s(:if,
+                              s(:flip3, s(:call, nil, :foo), s(:call, nil, :bar)),
+                              s(:call, nil, :baz),
+                              nil)
+      end
+    end
+
     describe "for postfix if" do
-      it "normalizes negative conditions" do
+      it "works with a simple condition" do
+        "foo if bar".
+          must_be_parsed_as s(:if,
+                              s(:call, nil, :bar),
+                              s(:call, nil, :foo),
+                              nil)
+      end
+
+      it "handles negative conditions" do
         "foo if not bar".
           must_be_parsed_as s(:if,
-                              s(:call, nil, :bar, s(:arglist)),
+                              s(:call, s(:call, nil, :bar), :!),
+                              s(:call, nil, :foo),
+                              nil)
+      end
+
+      it "handles bare regex literal in condition" do
+        "foo if /bar/".
+          must_be_parsed_as s(:if,
+                              s(:match, s(:lit, /bar/)),
+                              s(:call, nil, :foo),
+                              nil)
+      end
+
+      it "handles interpolated regex in condition" do
+        'foo if /#{bar}/'.
+          must_be_parsed_as s(:if,
+                              s(:dregx, "", s(:evstr, s(:call, nil, :bar))),
+                              s(:call, nil, :foo),
+                              nil)
+      end
+    end
+
+    describe "for regular unless" do
+      it "works with a single statement" do
+        "unless bar; foo; end".
+          must_be_parsed_as s(:if,
+                              s(:call, nil, :bar),
+                              nil,
+                              s(:call, nil, :foo))
+      end
+
+      it "works with an else clause" do
+        "unless foo; bar; else; baz; end".
+          must_be_parsed_as s(:if,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :baz),
+                              s(:call, nil, :bar))
+      end
+      it "handles bare regex literal in condition" do
+        "unless /foo/; bar; end".
+          must_be_parsed_as s(:if,
+                              s(:match, s(:lit, /foo/)),
+                              nil,
+                              s(:call, nil, :bar))
+      end
+
+      it "handles interpolated regex in condition" do
+        'unless /#{foo}/; bar; end'.
+          must_be_parsed_as s(:if,
+                              s(:dregx, "", s(:evstr, s(:call, nil, :foo))),
+                              nil,
+                              s(:call, nil, :bar))
+      end
+    end
+
+    describe "for postfix unless" do
+      it "works with a simple condition" do
+        "foo unless bar".
+          must_be_parsed_as s(:if,
+                              s(:call, nil, :bar),
+                              nil,
+                              s(:call, nil, :foo))
+      end
+
+      it "handles bare regex literal in condition" do
+        "foo unless /bar/".
+          must_be_parsed_as s(:if,
+                              s(:match, s(:lit, /bar/)),
+                              nil,
+                              s(:call, nil, :foo))
+      end
+
+      it "handles interpolated regex in condition" do
+        'foo unless /#{bar}/'.
+          must_be_parsed_as s(:if,
+                              s(:dregx, "", s(:evstr, s(:call, nil, :bar))),
                               nil,
-                              s(:call, nil, :foo, s(:arglist)))
+                              s(:call, nil, :foo))
       end
     end
 
-    describe "for case" do
-      it "emulates RubyParser's strange handling of splat" do
+    describe "for case block" do
+      it "works with a single when clause" do
+        "case foo; when bar; baz; end".
+          must_be_parsed_as s(:case,
+                              s(:call, nil, :foo),
+                              s(:when,
+                                s(:array, s(:call, nil, :bar)),
+                                s(:call, nil, :baz)),
+                              nil)
+      end
+
+      it "works with multiple when clauses" do
+        "case foo; when bar; baz; when qux; quux; end".
+          must_be_parsed_as s(:case,
+                              s(:call, nil, :foo),
+                              s(:when,
+                                s(:array, s(:call, nil, :bar)),
+                                s(:call, nil, :baz)),
+                              s(:when,
+                                s(:array, s(:call, nil, :qux)),
+                                s(:call, nil, :quux)),
+                              nil)
+      end
+
+      it "works with multiple statements in the when block" do
+        "case foo; when bar; baz; qux; end".
+          must_be_parsed_as s(:case,
+                              s(:call, nil, :foo),
+                              s(:when,
+                                s(:array, s(:call, nil, :bar)),
+                                s(:call, nil, :baz),
+                                s(:call, nil, :qux)),
+                              nil)
+      end
+
+      it "works with an else clause" do
+        "case foo; when bar; baz; else; qux; end".
+          must_be_parsed_as s(:case,
+                              s(:call, nil, :foo),
+                              s(:when,
+                                s(:array, s(:call, nil, :bar)),
+                                s(:call, nil, :baz)),
+                              s(:call, nil, :qux))
+      end
+
+      it "works with an empty when block" do
+        "case foo; when bar; end".
+          must_be_parsed_as s(:case,
+                              s(:call, nil, :foo),
+                              s(:when, s(:array, s(:call, nil, :bar)), nil),
+                              nil)
+      end
+
+      it "works with an empty else block" do
+        "case foo; when bar; baz; else; end".
+          must_be_parsed_as s(:case,
+                              s(:call, nil, :foo),
+                              s(:when,
+                                s(:array, s(:call, nil, :bar)),
+                                s(:call, nil, :baz)),
+                              nil)
+      end
+
+      it "works with a splat in the when clause" do
         "case foo; when *bar; baz; end".
-          must_be_parsed_as s(:case, s(:call, nil, :foo, s(:arglist)),
+          must_be_parsed_as s(:case,
+                              s(:call, nil, :foo),
                               s(:when,
                                 s(:array,
-                                  s(:when, s(:call, nil, :bar, s(:arglist)),
-                                  nil)),
-                                s(:call, nil, :baz, s(:arglist))),
+                                  s(:splat, s(:call, nil, :bar))),
+                                s(:call, nil, :baz)),
                               nil)
 
       end

data/test/unit/parser_literals_test.rb

@@ -4,6 +4,41 @@ require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
 describe RipperRubyParser::Parser do
   describe "#parse" do
     describe "for regexp literals" do
+      it "works for a simple regex literal" do
+        "/foo/".
+          must_be_parsed_as s(:lit, /foo/)
+      end
+
+      it "works for regex literals with escaped right bracket" do
+        '/\\)/'.
+          must_be_parsed_as s(:lit, /\)/)
+      end
+
+      it "works for regex literals with escape sequences" do
+        '/\\)\\n\\\\/'.
+          must_be_parsed_as s(:lit, /\)\n\\/)
+      end
+
+      it "works for a regex literal with the multiline flag" do
+        "/foo/m".
+          must_be_parsed_as s(:lit, /foo/m)
+      end
+
+      it "works for a regex literal with the extended flag" do
+        "/foo/x".
+          must_be_parsed_as s(:lit, /foo/x)
+      end
+
+      it "works for a regex literal with the ignorecase flag" do
+        "/foo/i".
+          must_be_parsed_as s(:lit, /foo/i)
+      end
+
+      it "works for a regex literal with a combination of flags" do
+        "/foo/ixm".
+          must_be_parsed_as s(:lit, /foo/ixm)
+      end
+
       it "works with the no-encoding flag" do
         parser = RipperRubyParser::Parser.new
         result = parser.parse "/foo/n"
@@ -13,12 +48,28 @@ describe RipperRubyParser::Parser do
       end
 
       describe "with interpolations" do
+        it "works for a simple interpolation" do
+          '/foo#{bar}baz/'.
+            must_be_parsed_as s(:dregx,
+                                "foo",
+                                s(:evstr, s(:call, nil, :bar)),
+                                s(:str, "baz"))
+        end
+
+        it "works for a regex literal with flags and interpolation" do
+          '/foo#{bar}/ixm'.
+            must_be_parsed_as s(:dregx,
+                                "foo",
+                                s(:evstr, s(:call, nil, :bar)),
+                                7)
+        end
+
         it "works with the no-encoding flag" do
           '/foo#{bar}/n'.
             must_be_parsed_as s(:dregx,
                                 "foo",
                                 s(:evstr,
-                                  s(:call, nil, :bar, s(:arglist))), 32)
+                                  s(:call, nil, :bar)), 32)
         end
 
         it "works with the unicode-encoding flag" do
@@ -26,7 +77,7 @@ describe RipperRubyParser::Parser do
             must_be_parsed_as s(:dregx,
                                 "foo",
                                 s(:evstr,
-                                  s(:call, nil, :bar, s(:arglist))), 16)
+                                  s(:call, nil, :bar)), 16)
         end
 
         it "works with the euc-encoding flag" do
@@ -34,7 +85,7 @@ describe RipperRubyParser::Parser do
             must_be_parsed_as s(:dregx,
                                 "foo",
                                 s(:evstr,
-                                  s(:call, nil, :bar, s(:arglist))), 16)
+                                  s(:call, nil, :bar)), 16)
         end
 
         it "works with the sjis-encoding flag" do
@@ -42,7 +93,22 @@ describe RipperRubyParser::Parser do
             must_be_parsed_as s(:dregx,
                                 "foo",
                                 s(:evstr,
-                                  s(:call, nil, :bar, s(:arglist))), 16)
+                                  s(:call, nil, :bar)), 16)
+        end
+
+        it "works for a regex literal with interpolate-once flag" do
+          '/foo#{bar}/o'.
+            must_be_parsed_as s(:dregx_once,
+                                "foo",
+                                s(:evstr, s(:call, nil, :bar)))
+        end
+
+        it "works with an empty interpolation" do
+          '/foo#{}bar/'.
+            must_be_parsed_as s(:dregx,
+                                "foo",
+                                s(:evstr),
+                                s(:str, "bar"))
         end
 
         describe "containing just a literal string" do
@@ -62,7 +128,49 @@ describe RipperRubyParser::Parser do
     end
 
     describe "for string literals" do
+      it "works for empty strings" do
+        "''".
+          must_be_parsed_as s(:str, "")
+      end
+
+      it "sets the encoding for literal strings to utf8 even if ascii would do" do
+        parser = RipperRubyParser::Parser.new
+        result = parser.parse "\"foo\""
+        result.must_equal s(:str, "foo")
+        result[1].encoding.to_s.must_equal "UTF-8"
+      end
+
       describe "with escape sequences" do
+        it "works for strings with escape sequences" do
+          "\"\\n\"".
+            must_be_parsed_as s(:str, "\n")
+        end
+
+        it "works for strings with useless escape sequences" do
+          "\"F\\OO\"".
+            must_be_parsed_as s(:str, "FOO")
+        end
+
+        it "works for strings with escaped backslashes" do
+          "\"\\\\n\"".
+            must_be_parsed_as s(:str, "\\n")
+        end
+
+        it "works for a double-quoted string representing 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
+          "\"/\\)/\"".
+            must_be_parsed_as s(:str, "/)/")
+        end
+
+        it "works for a string containing escaped quotes" do
+          "\"\\\"\"".
+            must_be_parsed_as s(:str, "\"")
+        end
+
         it "works with hex escapes" do
           "\"\\x36\"".must_be_parsed_as s(:str, "6")
           "\"\\x4a\"".must_be_parsed_as s(:str, "J")
@@ -143,6 +251,57 @@ describe RipperRubyParser::Parser do
                                                 s(:evstr, s(:cvar, :@@bar)))
           end
         end
+
+        describe "with braces" do
+          it "works for trivial interpolated strings" do
+            '"#{foo}"'.
+              must_be_parsed_as s(:dstr,
+                                  "",
+                                  s(:evstr,
+                                    s(:call, nil, :foo)))
+          end
+
+          it "works for basic interpolated strings" do
+            '"foo#{bar}"'.
+              must_be_parsed_as s(:dstr,
+                                  "foo",
+                                  s(:evstr,
+                                    s(:call, nil, :bar)))
+          end
+
+          it "works for strings with several 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
+
+          it "correctly handles two interpolations in a row" do
+            "\"\#{bar}\#{qux}\"".
+              must_be_parsed_as s(:dstr,
+                                  "",
+                                  s(:evstr, s(:call, nil, :bar)),
+                                  s(:evstr, s(:call, nil, :qux)))
+          end
+
+          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"))
+          end
+
+          it "works with an empty interpolation" do
+            "\"foo\#{}bar\"".
+              must_be_parsed_as s(:dstr,
+                                  "foo",
+                                  s(:evstr),
+                                  s(:str, "bar"))
+          end
+        end
       end
 
       describe "with string concatenation" do
@@ -154,14 +313,14 @@ describe RipperRubyParser::Parser do
           "\"foo\" \"bar\#{baz}\"".
             must_be_parsed_as s(:dstr,
                                 "foobar",
-                                s(:evstr, s(:call, nil, :baz, s(:arglist))))
+                                s(:evstr, s(:call, nil, :baz)))
         end
 
         it "performs the concatenation when the left string has interpolations" do
           "\"foo\#{bar}\" \"baz\"".
             must_be_parsed_as s(:dstr,
                                 "foo",
-                                s(:evstr, s(:call, nil, :bar, s(:arglist))),
+                                s(:evstr, s(:call, nil, :bar)),
                                 s(:str, "baz"))
         end
 
@@ -169,11 +328,192 @@ describe RipperRubyParser::Parser do
           "\"foo\#{bar}\" \"baz\#{qux}\"".
             must_be_parsed_as s(:dstr,
                                 "foo",
-                                s(:evstr, s(:call, nil, :bar, s(:arglist))),
+                                s(:evstr, s(:call, nil, :bar)),
                                 s(:str, "baz"),
-                                s(:evstr, s(:call, nil, :qux, s(:arglist))))
+                                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)))
         end
       end
     end
+
+    describe "for word list literals" do
+      it "correctly handles interpolation" do
+        "%W(foo \#{bar} baz)".
+          must_be_parsed_as  s(:array,
+                               s(:str, "foo"),
+                               s(:dstr, "", s(:evstr, s(:call, nil, :bar))),
+                               s(:str, "baz"))
+      end
+
+      it "correctly handles braceless interpolation" do
+        "%W(foo \#@bar baz)".
+          must_be_parsed_as  s(:array,
+                               s(:str, "foo"),
+                               s(:dstr, "", s(:evstr, s(:ivar, :@bar))),
+                               s(:str, "baz"))
+      end
+    end
+
+    describe "for character literals" do
+      it "works for simple character literals" do
+        "?a".
+          must_be_parsed_as s(:str, "a")
+      end
+
+      it "works for escaped character literals" do
+        "?\\n".
+          must_be_parsed_as s(:str, "\n")
+      end
+
+      it "works for escaped character literals with ctrl" do
+        "?\\C-a".
+          must_be_parsed_as s(:str, "\u0001")
+      end
+
+      it "works for escaped character literals with meta" do
+        "?\\M-a".
+          must_be_parsed_as s(:str, "\xE1".force_encoding("ascii-8bit"))
+      end
+
+      it "works for escaped character literals with meta plus shorthand ctrl" do
+        "?\\M-\\ca".
+          must_be_parsed_as s(:str, "\x81".force_encoding("ascii-8bit"))
+      end
+
+      it "works for escaped character literals with shorthand ctrl plus meta" do
+        "?\\c\\M-a".
+          must_be_parsed_as s(:str, "\x81".force_encoding("ascii-8bit"))
+      end
+
+      it "works for escaped character literals with meta plus ctrl" do
+        "?\\M-\\C-a".
+          must_be_parsed_as s(:str, "\x81".force_encoding("ascii-8bit"))
+      end
+
+      it "works for escaped character literals with ctrl plus meta" do
+        "?\\C-\\M-a".
+          must_be_parsed_as s(:str, "\x81".force_encoding("ascii-8bit"))
+      end
+    end
+
+    describe "for symbol literals" do
+      it "works for simple symbols" do
+        ":foo".
+          must_be_parsed_as s(:lit, :foo)
+      end
+
+      it "works for symbols that look like instance variable names" do
+        ":@foo".
+          must_be_parsed_as s(:lit, :@foo)
+      end
+
+      it "works for simple dsyms" do
+        ':"foo"'.
+          must_be_parsed_as s(:lit, :foo)
+      end
+
+      it "works for dsyms with interpolations" do
+        ':"foo#{bar}"'.
+          must_be_parsed_as s(:dsym,
+                              "foo",
+                              s(:evstr, s(:call, nil, :bar)))
+      end
+    end
+
+    describe "for backtick string literals" do
+      it "works for basic backtick strings" do
+        '`foo`'.
+          must_be_parsed_as s(:xstr, "foo")
+      end
+
+      it "works for interpolated backtick strings" do
+        '`foo#{bar}`'.
+          must_be_parsed_as s(:dxstr,
+                              "foo",
+                              s(:evstr, s(:call, nil, :bar)))
+      end
+
+      it "works for backtick strings with escape sequences" do
+        '`foo\\n`'.
+          must_be_parsed_as s(:xstr, "foo\n")
+      end
+    end
+
+    describe "for array literals" do
+      it "works for an empty array" do
+        "[]".
+          must_be_parsed_as s(:array)
+      end
+
+      it "works for a simple case with splat" do
+        "[*foo]".
+          must_be_parsed_as s(:array,
+                              s(:splat, s(:call, nil, :foo)))
+      end
+
+      it "works for a multi-element case with splat" do
+        "[foo, *bar]".
+          must_be_parsed_as s(:array,
+                              s(:call, nil, :foo),
+                              s(:splat, s(:call, nil, :bar)))
+      end
+
+      it "works for an array created with %W" do
+        "%W(foo bar)".
+          must_be_parsed_as s(:array, s(:str, "foo"), s(:str, "bar"))
+      end
+    end
+
+    describe "for hash literals" do
+      it "works for an empty hash" do
+        "{}".
+          must_be_parsed_as s(:hash)
+      end
+
+      it "works for a hash with one pair" do
+        "{foo => bar}".
+          must_be_parsed_as s(:hash,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar))
+      end
+
+      it "works for a hash with multiple pairs" do
+        "{foo => bar, baz => qux}".
+          must_be_parsed_as s(:hash,
+                              s(:call, nil, :foo),
+                              s(:call, nil, :bar),
+                              s(:call, nil, :baz),
+                              s(:call, nil, :qux))
+      end
+
+      it "works for a hash with label keys (Ruby 1.9 only)" do
+        "{foo: bar, baz: qux}".
+          must_be_parsed_as s(:hash,
+                              s(:lit, :foo),
+                              s(:call, nil, :bar),
+                              s(:lit, :baz),
+                              s(:call, nil, :qux))
+      end
+    end
+
+    describe "for number literals" do
+      it "works for floats" do
+        "3.14".
+          must_be_parsed_as s(:lit, 3.14)
+      end
+
+      it "works for octal integer literals" do
+        "0700".
+          must_be_parsed_as s(:lit, 448)
+      end
+    end
+
   end
 end