machete 0.4.0 → 0.5.0

data/lib/machete/parser.y

@@ -1,16 +1,17 @@
 class Machete::Parser
 
+token NIL
 token TRUE
 token FALSE
-token NIL
 token INTEGER
+token SYMBOL
 token STRING
+token REGEXP
 token ANY
 token EVEN
 token ODD
 token METHOD_NAME
 token CLASS_NAME
-token SYMBOL
 
 start expression
 
@@ -41,6 +42,27 @@ attrs : attr
       | attrs "," attr { result = val[0].merge(val[2]) }
 
 attr : method_name "=" expression { result = { val[0].to_sym => val[2] } }
+     | method_name "^=" SYMBOL {
+         result = {
+           val[0].to_sym => SymbolRegexpMatcher.new(
+             Regexp.new("^" + Regexp.escape(symbol_value(val[2]).to_s))
+           )
+         }
+       }
+     | method_name "$=" SYMBOL {
+         result = {
+           val[0].to_sym => SymbolRegexpMatcher.new(
+             Regexp.new(Regexp.escape(symbol_value(val[2]).to_s) + "$")
+           )
+         }
+       }
+     | method_name "*=" SYMBOL {
+         result = {
+           val[0].to_sym => SymbolRegexpMatcher.new(
+             Regexp.new(Regexp.escape(symbol_value(val[2]).to_s))
+           )
+         }
+       }
      | method_name "^=" STRING {
          result = {
            val[0].to_sym => StringRegexpMatcher.new(
@@ -62,14 +84,21 @@ attr : method_name "=" expression { result = { val[0].to_sym => val[2] } }
            )
          }
        }
+     | method_name "*=" REGEXP {
+         result = {
+           val[0].to_sym => IndifferentRegexpMatcher.new(
+             Regexp.new(regexp_value(val[2]))
+           )
+         }
+       }
 
 # Hack to overcome the fact that some tokens will lex as simple tokens, not
 # METHOD_NAME tokens, and that "reserved words" will lex as separate kinds of
 # tokens.
 method_name : METHOD_NAME
+            | NIL
             | TRUE
             | FALSE
-            | NIL
             | ANY
             | EVEN
             | ODD
@@ -109,12 +138,13 @@ quantifier : "*" { result = [0, nil, 1] }
            | "{" EVEN "}" { result = [0, nil, 2] }
            | "{" ODD "}"  { result = [1, nil, 2] }
 
-literal : SYMBOL  { result = LiteralMatcher.new(val[0][1..-1].to_sym) }
+literal : NIL     { result = LiteralMatcher.new(nil) }
+        | TRUE    { result = LiteralMatcher.new(true) }
+        | FALSE   { result = LiteralMatcher.new(false) }
         | INTEGER { result = LiteralMatcher.new(integer_value(val[0])) }
+        | SYMBOL  { result = LiteralMatcher.new(symbol_value(val[0])) }
         | STRING  { result = LiteralMatcher.new(string_value(val[0])) }
-        | TRUE	  { result = LiteralMatcher.new(true) }
-        | FALSE   { result = LiteralMatcher.new(false) }
-        | NIL     { result = LiteralMatcher.new(nil) }
+        | REGEXP  { result = LiteralMatcher.new(regexp_value(val[0])) }
 
 any : ANY { result = AnyMatcher.new }
 
@@ -143,12 +173,16 @@ def integer_value(value)
   elsif value =~ /^0[xX]/
     value[2..-1].to_i(16)
   elsif value =~ /^0/
-    value[1..-1].to_i(8)
+    value.to_i(8)
   else
     value.to_i
   end
 end
 
+def symbol_value(value)
+  value[1..-1].to_sym
+end
+
 def string_value(value)
   quote = value[0..0]
   if quote == "'"
@@ -173,6 +207,19 @@ def string_value(value)
   end
 end
 
+REGEXP_OPTIONS = {
+  'i' => Regexp::IGNORECASE,
+  'm' => Regexp::MULTILINE,
+  'x' => Regexp::EXTENDED
+}
+
+def regexp_value(value)
+  /\A\/(.*)\/([imx]*)\z/ =~ value
+  pattern, options = $1, $2
+
+  Regexp.new(pattern, options.chars.map { |ch| REGEXP_OPTIONS[ch] }.inject(:|))
+end
+
 # "^" needs to be here because if it were among operators recognized by
 # METHOD_NAME, "^=" would be recognized as two tokens.
 SIMPLE_TOKENS = [
@@ -195,9 +242,9 @@ SIMPLE_TOKENS = [
 ]
 
 COMPLEX_TOKENS = [
+  [:NIL,   /^nil/],
   [:TRUE,  /^true/],
   [:FALSE, /^false/],
-  [:NIL,   /^nil/],
   # INTEGER needs to be before METHOD_NAME, otherwise e.g. "+1" would be
   # recognized as two tokens.
   [
@@ -219,6 +266,28 @@ COMPLEX_TOKENS = [
       )
     /x
   ],
+  [
+    :SYMBOL,
+    /^
+      :
+      (
+        # class name
+        [A-Z][a-zA-Z0-9_]*
+        |
+        # regular method name
+        [a-z_][a-zA-Z0-9_]*[?!=]?
+        |
+        # instance variable name
+        @[a-zA-Z_][a-zA-Z0-9_]*
+        |
+        # class variable name
+        @@[a-zA-Z_][a-zA-Z0-9_]*
+        |
+        # operator (sorted by length, then alphabetically)
+        (<=>|===|\[\]=|\*\*|\+@|-@|<<|<=|==|=~|>=|>>|\[\]|[%&*+\-\/<>^`|~])
+      )
+    /x
+  ],
   [
     :STRING,
     /^
@@ -248,6 +317,26 @@ COMPLEX_TOKENS = [
       )
     /x
   ],
+  [
+    :REGEXP,
+    /^
+      \/
+        (
+          \\                                          # escape
+          (
+            [\\\/ntrfvaebs\(\)\[\]\{\}\-\.\?\*\+\|\^\$] # one-character escape
+            |
+            [0-7]{2,3}                                  # octal number escape
+            |
+            x[0-9a-fA-F]{1,2}                           # hexadecimal number escape
+          )
+          |
+          [^\/]                                       # regular character
+        )*
+      \/
+      [imx]*
+    /x
+  ],
   # ANY, EVEN and ODD need to be before METHOD_NAME, otherwise they would be
   # recognized as method names.
   [:ANY,  /^any/],
@@ -268,23 +357,7 @@ COMPLEX_TOKENS = [
       )
     /x
   ],
-  [:CLASS_NAME,  /^[A-Z][a-zA-Z0-9_]*/],
-  [
-    :SYMBOL,
-    /^
-      :
-      (
-        # class name
-        [A-Z][a-zA-Z0-9_]*
-        |
-        # regular method name
-        [a-z_][a-zA-Z0-9_]*[?!=]?
-        |
-        # operator (sorted by length, then alphabetically)
-        (<=>|===|\[\]=|\*\*|\+@|-@|<<|<=|==|=~|>=|>>|\[\]|[%&*+\-\/<>^`|~])
-      )
-    /x
-  ]
+  [:CLASS_NAME, /^[A-Z][a-zA-Z0-9_]*/]
 ]
 
 def next_token

data/machete.gemspec

@@ -13,8 +13,8 @@ Gem::Specification.new do |s|
     in the code, etc.
   EOT
 
-  s.author      = "David Majda"
-  s.email       = "dmajda@suse.de"
+  s.authors     = ["David Majda", "Piotr Niełacny"]
+  s.email       = ["dmajda@suse.cz", "piotr.nielacny@gmail.com"]
   s.homepage    = "https://github.com/openSUSE/machete"
   s.license     = "MIT"
 

data/spec/machete/matchers_spec.rb

@@ -49,6 +49,10 @@ module Machete::Matchers
     end
   end
 
+  describe Matcher do
+    # Nothing to spec.
+  end
+
   describe ChoiceMatcher do
     before :each do
       @alternatives = [
@@ -116,7 +120,7 @@ module Machete::Matchers
       @matcher = NodeMatcher.new(:RegexLiteral, @attrs)
     end
 
-    describe "initializa" do
+    describe "initialize" do
       describe "when passed one parameter" do
         it "sets attributes correctly" do
           matcher = NodeMatcher.new(:RegexLiteral)
@@ -409,9 +413,9 @@ module Machete::Matchers
     end
   end
 
-  describe StringRegexpMatcher do
-    before :each do
-      @matcher = StringRegexpMatcher.new(/abcd/)
+  describe RegexpMatcher do
+    before do
+      @matcher = RegexpMatcher.new(/abcd/)
     end
 
     describe "initialize" do
@@ -425,27 +429,81 @@ module Machete::Matchers
         @matcher.should == @matcher
       end
 
-      it "returns true when passed a StartsWithMatcher initialized with the same parameters" do
-        @matcher.should == StringRegexpMatcher.new(/abcd/)
+      it "returns true when passed a RegexpMatcher initialized with the same parameters" do
+        @matcher.should == RegexpMatcher.new(/abcd/)
       end
 
       it "returns false when passed some random object" do
         @matcher.should_not == Object.new
       end
 
-      it "returns false when passed a subclass of StartsWithMatcher initialized with the same parameters" do
-        class SubclassedStringRegexpMatcher < StringRegexpMatcher
+      it "returns false when passed a subclass of RegexpMatcher initialized with the same parameters" do
+        class SubclassedRegexpMatcher < RegexpMatcher
         end
 
-        @matcher.should_not == SubclassedStringRegexpMatcher.new(/abcd/)
+        @matcher.should_not == SubclassedRegexpMatcher.new(/abcd/)
       end
 
-      it "returns false when passed a StartsWithMatcher initialized with different parameters" do
-        @matcher.should_not == StringRegexpMatcher.new(/efgh/)
+      it "returns false when passed a RegexpMatcher initialized with different parameters" do
+        @matcher.should_not == RegexpMatcher.new(/efgh/)
       end
     end
+  end
+
+  describe SymbolRegexpMatcher do
+    before do
+      @matcher = SymbolRegexpMatcher.new(/abcd/)
+    end
 
     describe "matches?" do
+      it "matches a symbol matching the regexp" do
+        @matcher.matches?(:efghabcdijkl).should be_true
+      end
+
+      it "does not match a symbol not matching the regexp" do
+        @matcher.matches?(:efghijkl).should be_false
+      end
+
+      it "does not match some random object" do
+        @matcher.matches?(Object.new).should be_false
+      end
+    end
+  end
+
+  describe StringRegexpMatcher do
+    before :each do
+      @matcher = StringRegexpMatcher.new(/abcd/)
+    end
+
+    describe "matches?" do
+      it "matches a string matching the regexp" do
+        @matcher.matches?("efghabcdijkl").should be_true
+      end
+
+      it "does not match a string not matching the regexp" do
+        @matcher.matches?("efghijkl").should be_false
+      end
+
+      it "does not match some random object" do
+        @matcher.matches?(Object.new).should be_false
+      end
+    end
+  end
+
+  describe IndifferentRegexpMatcher do
+    before :each do
+      @matcher = IndifferentRegexpMatcher.new(/abcd/)
+    end
+
+    describe "matches?" do
+      it "matches a symbol matching the regexp" do
+        @matcher.matches?(:efghabcdijkl).should be_true
+      end
+
+      it "does not match a symbol not matching the regexp" do
+        @matcher.matches?(:efghijkl).should be_false
+      end
+
       it "matches a string matching the regexp" do
         @matcher.matches?("efghabcdijkl").should be_true
       end

data/spec/machete/parser_spec.rb

@@ -72,7 +72,30 @@ module Machete
 
     # Canonical attr is "a = 42".
     it "parses attr" do
+      # Expressions
       'Foo<a = 42 | 43>'.should be_parsed_as(NodeMatcher.new(:Foo, :a => @ch4243))
+
+      # Symbols
+      'Foo<a ^= :a>'.should be_parsed_as(
+        NodeMatcher.new(:Foo, :a => SymbolRegexpMatcher.new(/^a/))
+      )
+      'Foo<a ^= :+>'.should be_parsed_as(
+        NodeMatcher.new(:Foo, :a => SymbolRegexpMatcher.new(/^\+/))
+      )
+      'Foo<a $= :a>'.should be_parsed_as(
+        NodeMatcher.new(:Foo, :a => SymbolRegexpMatcher.new(/a$/))
+      )
+      'Foo<a $= :+>'.should be_parsed_as(
+        NodeMatcher.new(:Foo, :a => SymbolRegexpMatcher.new(/\+$/))
+      )
+      'Foo<a *= :a>'.should be_parsed_as(
+        NodeMatcher.new(:Foo, :a => SymbolRegexpMatcher.new(/a/))
+      )
+      'Foo<a *= :+>'.should be_parsed_as(
+        NodeMatcher.new(:Foo, :a => SymbolRegexpMatcher.new(/\+/))
+      )
+
+      # Strings
       'Foo<a ^= "abcd">'.should be_parsed_as(
         NodeMatcher.new(:Foo, :a => StringRegexpMatcher.new(/^abcd/))
       )
@@ -97,15 +120,32 @@ module Machete
           /\[\]\{\}\(\)\|\-\*\.\\\?\+\^\$\ \#\t\f\v\n\r/
         ))
       )
+
+      # Regexps
+      'Foo<a *= /abcd/>'.should be_parsed_as(
+        NodeMatcher.new(:Foo, :a => IndifferentRegexpMatcher.new(/abcd/))
+      )
+      'Foo<a *= /abcd/i>'.should be_parsed_as(
+        NodeMatcher.new(:Foo, :a => IndifferentRegexpMatcher.new(/abcd/i))
+      )
+      'Foo<a *= /abcd/m>'.should be_parsed_as(
+        NodeMatcher.new(:Foo, :a => IndifferentRegexpMatcher.new(/abcd/m))
+      )
+      'Foo<a *= /abcd/x>'.should be_parsed_as(
+        NodeMatcher.new(:Foo, :a => IndifferentRegexpMatcher.new(/abcd/x))
+      )
+      'Foo<a *= /abcd/imx>'.should be_parsed_as(
+        NodeMatcher.new(:Foo, :a => IndifferentRegexpMatcher.new(/abcd/imx))
+      )
     end
 
     # Canonical method_name is "a".
     it "parses method_name" do
       'Foo<a = 42>'.should be_parsed_as(node_matcher_with_attr(:a))
+      'Foo<nil = 42>'.should be_parsed_as(node_matcher_with_attr(:nil))
       'Foo<true = 42>'.should be_parsed_as(node_matcher_with_attr(:true))
       'Foo<false = 42>'.should be_parsed_as(node_matcher_with_attr(:false))
       'Foo<any = 42>'.should be_parsed_as(node_matcher_with_attr(:any))
-      'Foo<any = 42>'.should be_parsed_as(node_matcher_with_attr(:any))
       'Foo<even = 42>'.should be_parsed_as(node_matcher_with_attr(:even))
       'Foo<odd = 42>'.should be_parsed_as(node_matcher_with_attr(:odd))
       'Foo<* = 42>'.should be_parsed_as(node_matcher_with_attr(:*))
@@ -166,12 +206,13 @@ module Machete
 
     # Canonical literal is "42".
     it "parses literal" do
-      ':a'.should be_parsed_as(LiteralMatcher.new(:a))
-      '42'.should be_parsed_as(@i42)
-      '"abcd"'.should be_parsed_as(LiteralMatcher.new("abcd"))
+      'nil'.should be_parsed_as(LiteralMatcher.new(nil))
       'true'.should be_parsed_as(LiteralMatcher.new(true))
       'false'.should be_parsed_as(LiteralMatcher.new(false))
-      'nil'.should be_parsed_as(LiteralMatcher.new(nil))
+      '42'.should be_parsed_as(@i42)
+      ':a'.should be_parsed_as(LiteralMatcher.new(:a))
+      '"abcd"'.should be_parsed_as(LiteralMatcher.new("abcd"))
+      '/abcd/'.should be_parsed_as(LiteralMatcher.new(/abcd/))
     end
 
     # Canonical any is "any".
@@ -179,6 +220,11 @@ module Machete
       'any'.should be_parsed_as(AnyMatcher.new)
     end
 
+    # Canonical NIL is "nil".
+    it "parses NIL" do
+      'nil'.should be_parsed_as(LiteralMatcher.new(nil))
+    end
+
     # Canonical TRUE is "true".
     it "parses TRUE" do
       'true'.should be_parsed_as(LiteralMatcher.new(true))
@@ -189,11 +235,6 @@ module Machete
       'false'.should be_parsed_as(LiteralMatcher.new(false))
     end
 
-    # Canonical NIL is "nil".
-    it "parses NIL" do
-      'nil'.should be_parsed_as(LiteralMatcher.new(nil))
-    end
-
     # Canonical INTEGER is "42".
     it "parses INTEGER" do
       # Sign
@@ -275,6 +316,94 @@ module Machete
       '1_2_3_4'.should be_parsed_as(LiteralMatcher.new(1234))
     end
 
+    # Canonical SYMBOL is ":a".
+    it "parses SYMBOL" do
+      # Class names
+      ':A'.should be_parsed_as(LiteralMatcher.new(:A))
+      ':Z'.should be_parsed_as(LiteralMatcher.new(:Z))
+      ':Aa'.should be_parsed_as(LiteralMatcher.new(:Aa))
+      ':Az'.should be_parsed_as(LiteralMatcher.new(:Az))
+      ':AA'.should be_parsed_as(LiteralMatcher.new(:AA))
+      ':AZ'.should be_parsed_as(LiteralMatcher.new(:AZ))
+      ':A0'.should be_parsed_as(LiteralMatcher.new(:A0))
+      ':A9'.should be_parsed_as(LiteralMatcher.new(:A9))
+      ':A_'.should be_parsed_as(LiteralMatcher.new(:A_))
+      ':Abcd'.should be_parsed_as(LiteralMatcher.new(:Abcd))
+
+      # Regular method names
+      ':a'.should be_parsed_as(LiteralMatcher.new(:a))
+      ':z'.should be_parsed_as(LiteralMatcher.new(:z))
+      ':_'.should be_parsed_as(LiteralMatcher.new(:_))
+      ':aa'.should be_parsed_as(LiteralMatcher.new(:aa))
+      ':az'.should be_parsed_as(LiteralMatcher.new(:az))
+      ':aA'.should be_parsed_as(LiteralMatcher.new(:aA))
+      ':aZ'.should be_parsed_as(LiteralMatcher.new(:aZ))
+      ':a0'.should be_parsed_as(LiteralMatcher.new(:a0))
+      ':a9'.should be_parsed_as(LiteralMatcher.new(:a9))
+      ':a_'.should be_parsed_as(LiteralMatcher.new(:a_))
+      ':abcd'.should be_parsed_as(LiteralMatcher.new(:abcd))
+      ':a?'.should be_parsed_as(LiteralMatcher.new(:a?))
+      ':a!'.should be_parsed_as(LiteralMatcher.new(:a!))
+      ':a='.should be_parsed_as(LiteralMatcher.new(:a=))
+
+      # Instance variable name
+      ':@a'.should be_parsed_as(LiteralMatcher.new(:@a))
+      ':@z'.should be_parsed_as(LiteralMatcher.new(:@z))
+      ':@A'.should be_parsed_as(LiteralMatcher.new(:@A))
+      ':@Z'.should be_parsed_as(LiteralMatcher.new(:@Z))
+      ':@_'.should be_parsed_as(LiteralMatcher.new(:@_))
+      ':@aa'.should be_parsed_as(LiteralMatcher.new(:@aa))
+      ':@az'.should be_parsed_as(LiteralMatcher.new(:@az))
+      ':@aA'.should be_parsed_as(LiteralMatcher.new(:@aA))
+      ':@aZ'.should be_parsed_as(LiteralMatcher.new(:@aZ))
+      ':@a0'.should be_parsed_as(LiteralMatcher.new(:@a0))
+      ':@a9'.should be_parsed_as(LiteralMatcher.new(:@a9))
+      ':@a_'.should be_parsed_as(LiteralMatcher.new(:@a_))
+      ':@abcd'.should be_parsed_as(LiteralMatcher.new(:@abcd))
+
+      # Class variable name
+      ':@@a'.should be_parsed_as(LiteralMatcher.new(:@@a))
+      ':@@z'.should be_parsed_as(LiteralMatcher.new(:@@z))
+      ':@@A'.should be_parsed_as(LiteralMatcher.new(:@@A))
+      ':@@Z'.should be_parsed_as(LiteralMatcher.new(:@@Z))
+      ':@@_'.should be_parsed_as(LiteralMatcher.new(:@@_))
+      ':@@aa'.should be_parsed_as(LiteralMatcher.new(:@@aa))
+      ':@@az'.should be_parsed_as(LiteralMatcher.new(:@@az))
+      ':@@aA'.should be_parsed_as(LiteralMatcher.new(:@@aA))
+      ':@@aZ'.should be_parsed_as(LiteralMatcher.new(:@@aZ))
+      ':@@a0'.should be_parsed_as(LiteralMatcher.new(:@@a0))
+      ':@@a9'.should be_parsed_as(LiteralMatcher.new(:@@a9))
+      ':@@a_'.should be_parsed_as(LiteralMatcher.new(:@@a_))
+      ':@@abcd'.should be_parsed_as(LiteralMatcher.new(:@@abcd))
+
+      # Operators (sorted alphabetically)
+      ':%'.should be_parsed_as(LiteralMatcher.new(:%))
+      ':&'.should be_parsed_as(LiteralMatcher.new(:&))
+      ':*'.should be_parsed_as(LiteralMatcher.new(:*))
+      ':**'.should be_parsed_as(LiteralMatcher.new(:**))
+      ':+'.should be_parsed_as(LiteralMatcher.new(:+))
+      ':+@'.should be_parsed_as(LiteralMatcher.new(:+@))
+      ':-'.should be_parsed_as(LiteralMatcher.new(:-))
+      ':-@'.should be_parsed_as(LiteralMatcher.new(:-@))
+      ':/'.should be_parsed_as(LiteralMatcher.new(:/))
+      ':<'.should be_parsed_as(LiteralMatcher.new(:<))
+      ':<<'.should be_parsed_as(LiteralMatcher.new(:<<))
+      ':<='.should be_parsed_as(LiteralMatcher.new(:<=))
+      ':<=>'.should be_parsed_as(LiteralMatcher.new(:<=>))
+      ':=='.should be_parsed_as(LiteralMatcher.new(:==))
+      ':==='.should be_parsed_as(LiteralMatcher.new(:===))
+      ':=~'.should be_parsed_as(LiteralMatcher.new(:=~))
+      ':>'.should be_parsed_as(LiteralMatcher.new(:>))
+      ':>='.should be_parsed_as(LiteralMatcher.new(:>=))
+      ':>>'.should be_parsed_as(LiteralMatcher.new(:>>))
+      ':[]'.should be_parsed_as(LiteralMatcher.new(:[]))
+      ':[]='.should be_parsed_as(LiteralMatcher.new(:[]=))
+      ':^'.should be_parsed_as(LiteralMatcher.new(:^))
+      ':`'.should be_parsed_as(LiteralMatcher.new(:`))
+      ':|'.should be_parsed_as(LiteralMatcher.new(:|))
+      ':~'.should be_parsed_as(LiteralMatcher.new(:~))
+    end
+
     # Canonical STRING is "\"abcd\"".
     it "parses STRING" do
       "''".should be_parsed_as(LiteralMatcher.new(""))
@@ -309,6 +438,50 @@ module Machete
       '"abc"'.should be_parsed_as(LiteralMatcher.new("abc"))
     end
 
+    # Canonical REGEXP is /regexp/.
+    it "parses REGEXP" do
+      '//'.should be_parsed_as(LiteralMatcher.new(//))
+      '/a/'.should be_parsed_as(LiteralMatcher.new(/a/))
+      '/\\\\/'.should be_parsed_as(LiteralMatcher.new(/\\/))
+      '/\//'.should be_parsed_as(LiteralMatcher.new(/\//))
+      '/\\n/'.should be_parsed_as(LiteralMatcher.new(/\n/))
+      '/\\t/'.should be_parsed_as(LiteralMatcher.new(/\t/))
+      '/\\r/'.should be_parsed_as(LiteralMatcher.new(/\r/))
+      '/\\f/'.should be_parsed_as(LiteralMatcher.new(/\f/))
+      '/\\v/'.should be_parsed_as(LiteralMatcher.new(/\v/))
+      '/\\a/'.should be_parsed_as(LiteralMatcher.new(/\a/))
+      '/\\e/'.should be_parsed_as(LiteralMatcher.new(/\e/))
+      '/\\b/'.should be_parsed_as(LiteralMatcher.new(/\b/))
+      '/\\s/'.should be_parsed_as(LiteralMatcher.new(/\s/))
+      '/\\(/'.should be_parsed_as(LiteralMatcher.new(/\(/))
+      '/\\)/'.should be_parsed_as(LiteralMatcher.new(/\)/))
+      '/\\[/'.should be_parsed_as(LiteralMatcher.new(/\[/))
+      '/\\]/'.should be_parsed_as(LiteralMatcher.new(/\]/))
+      '/\\{/'.should be_parsed_as(LiteralMatcher.new(/\{/))
+      '/\\}/'.should be_parsed_as(LiteralMatcher.new(/\}/))
+      '/\\-/'.should be_parsed_as(LiteralMatcher.new(/\-/))
+      '/\\./'.should be_parsed_as(LiteralMatcher.new(/\./))
+      '/\\?/'.should be_parsed_as(LiteralMatcher.new(/\?/))
+      '/\\*/'.should be_parsed_as(LiteralMatcher.new(/\*/))
+      '/\\+/'.should be_parsed_as(LiteralMatcher.new(/\+/))
+      '/\\|/'.should be_parsed_as(LiteralMatcher.new(/\|/))
+      '/\\^/'.should be_parsed_as(LiteralMatcher.new(/\^/))
+      '/\\$/'.should be_parsed_as(LiteralMatcher.new(/\$/))
+      '/\\00/'.should be_parsed_as(LiteralMatcher.new(/\00/))
+      '/\\07/'.should be_parsed_as(LiteralMatcher.new(/\07/))
+      '/\\70/'.should be_parsed_as(LiteralMatcher.new(/\70/))
+      '/\\77/'.should be_parsed_as(LiteralMatcher.new(/\77/))
+      '/\\123/'.should be_parsed_as(LiteralMatcher.new(/\123/))
+      '/\\x0/'.should be_parsed_as(LiteralMatcher.new(/\x0/))
+      '/\\x9/'.should be_parsed_as(LiteralMatcher.new(/\x9/))
+      '/\\xa/'.should be_parsed_as(LiteralMatcher.new(/\xa/))
+      '/\\xf/'.should be_parsed_as(LiteralMatcher.new(/\xf/))
+      '/\\xA/'.should be_parsed_as(LiteralMatcher.new(/\xA/))
+      '/\\xF/'.should be_parsed_as(LiteralMatcher.new(/\xF/))
+      '/\\x12/'.should be_parsed_as(LiteralMatcher.new(/\x12/))
+      '/abc/'.should be_parsed_as(LiteralMatcher.new(/abc/))
+    end
+
     # Canonical ANY is "any".
     it "parses ANY" do
       'any'.should be_parsed_as(AnyMatcher.new)
@@ -382,64 +555,6 @@ module Machete
       'Abcd'.should be_parsed_as(NodeMatcher.new(:Abcd))
     end
 
-    # Canonical SYMBOL is ":a".
-    it "parses SYMBOL" do
-      # Class names
-      ':A'.should be_parsed_as(LiteralMatcher.new(:A))
-      ':Z'.should be_parsed_as(LiteralMatcher.new(:Z))
-      ':Aa'.should be_parsed_as(LiteralMatcher.new(:Aa))
-      ':Az'.should be_parsed_as(LiteralMatcher.new(:Az))
-      ':AA'.should be_parsed_as(LiteralMatcher.new(:AA))
-      ':AZ'.should be_parsed_as(LiteralMatcher.new(:AZ))
-      ':A0'.should be_parsed_as(LiteralMatcher.new(:A0))
-      ':A9'.should be_parsed_as(LiteralMatcher.new(:A9))
-      ':A_'.should be_parsed_as(LiteralMatcher.new(:A_))
-      ':Abcd'.should be_parsed_as(LiteralMatcher.new(:Abcd))
-
-      # Regular method names
-      ':a'.should be_parsed_as(LiteralMatcher.new(:a))
-      ':z'.should be_parsed_as(LiteralMatcher.new(:z))
-      ':_'.should be_parsed_as(LiteralMatcher.new(:_))
-      ':aa'.should be_parsed_as(LiteralMatcher.new(:aa))
-      ':az'.should be_parsed_as(LiteralMatcher.new(:az))
-      ':aA'.should be_parsed_as(LiteralMatcher.new(:aA))
-      ':aZ'.should be_parsed_as(LiteralMatcher.new(:aZ))
-      ':a0'.should be_parsed_as(LiteralMatcher.new(:a0))
-      ':a9'.should be_parsed_as(LiteralMatcher.new(:a9))
-      ':a_'.should be_parsed_as(LiteralMatcher.new(:a_))
-      ':abcd'.should be_parsed_as(LiteralMatcher.new(:abcd))
-      ':a?'.should be_parsed_as(LiteralMatcher.new(:a?))
-      ':a!'.should be_parsed_as(LiteralMatcher.new(:a!))
-      ':a='.should be_parsed_as(LiteralMatcher.new(:a=))
-
-      # Operators (sorted alphabetically)
-      ':%'.should be_parsed_as(LiteralMatcher.new(:%))
-      ':&'.should be_parsed_as(LiteralMatcher.new(:&))
-      ':*'.should be_parsed_as(LiteralMatcher.new(:*))
-      ':**'.should be_parsed_as(LiteralMatcher.new(:**))
-      ':+'.should be_parsed_as(LiteralMatcher.new(:+))
-      ':+@'.should be_parsed_as(LiteralMatcher.new(:+@))
-      ':-'.should be_parsed_as(LiteralMatcher.new(:-))
-      ':-@'.should be_parsed_as(LiteralMatcher.new(:-@))
-      ':/'.should be_parsed_as(LiteralMatcher.new(:/))
-      ':<'.should be_parsed_as(LiteralMatcher.new(:<))
-      ':<<'.should be_parsed_as(LiteralMatcher.new(:<<))
-      ':<='.should be_parsed_as(LiteralMatcher.new(:<=))
-      ':<=>'.should be_parsed_as(LiteralMatcher.new(:<=>))
-      ':=='.should be_parsed_as(LiteralMatcher.new(:==))
-      ':==='.should be_parsed_as(LiteralMatcher.new(:===))
-      ':=~'.should be_parsed_as(LiteralMatcher.new(:=~))
-      ':>'.should be_parsed_as(LiteralMatcher.new(:>))
-      ':>='.should be_parsed_as(LiteralMatcher.new(:>=))
-      ':>>'.should be_parsed_as(LiteralMatcher.new(:>>))
-      ':[]'.should be_parsed_as(LiteralMatcher.new(:[]))
-      ':[]='.should be_parsed_as(LiteralMatcher.new(:[]=))
-      ':^'.should be_parsed_as(LiteralMatcher.new(:^))
-      ':`'.should be_parsed_as(LiteralMatcher.new(:`))
-      ':|'.should be_parsed_as(LiteralMatcher.new(:|))
-      ':~'.should be_parsed_as(LiteralMatcher.new(:~))
-    end
-
     it "skips whitespace before tokens" do
       '42'.should be_parsed_as(@i42)
       ' 42'.should be_parsed_as(@i42)