machete 0.2.1 → 0.3.0

data/lib/machete/parser.y

@@ -1,10 +1,13 @@
 class Machete::Parser
 
+token INTEGER
+token STRING
+token ANY
+token EVEN
+token ODD
 token METHOD_NAME
 token CLASS_NAME
 token SYMBOL
-token INTEGER
-token STRING
 
 start expression
 
@@ -20,7 +23,9 @@ expression : primary
              }
 
 primary : node
+        | array
         | literal
+        | any
 
 node : CLASS_NAME {
          result = NodeMatcher.new(val[0].to_sym)
@@ -33,55 +38,65 @@ attrs : attr
       | attrs "," attr { result = val[0].merge(val[2]) }
 
 attr : method_name "=" expression { result = { val[0].to_sym => val[2] } }
+     | method_name "^=" STRING {
+         result = {
+           val[0].to_sym => StartsWithMatcher.new(string_value(val[2]))
+         }
+       }
+     | method_name "$=" STRING {
+         result = {
+           val[0].to_sym => EndsWithMatcher.new(string_value(val[2]))
+         }
+       }
 
-# Hack to overcome the fact that "<", ">" and "|" will lex as simple tokens, not
-# METHOD_NAME tokens.
+# 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
+            | ANY
+            | EVEN
+            | ODD
+            | "*"
+            | "+"
             | "<"
             | ">"
+            | "^"
             | "|"
 
+array : "[" items_opt "]" { result = ArrayMatcher.new(val[1]) }
+
+items_opt : /* empty */ { result = [] }
+          | items
+
+items : item           { result = [val[0]] }
+      | items "," item { result = val[0] << val[2] }
+
+item : expression
+     | expression quantifier { result = Quantifier.new(val[0], *val[1]) }
+
+quantifier : "*" { result = [0, nil, 1] }
+           | "+" { result = [1, nil, 1] }
+           | "?" { result = [0, 1, 1] }
+           | "{" INTEGER "}" {
+             result = [integer_value(val[1]), integer_value(val[1]), 1]
+           }
+           | "{" INTEGER "," "}" {
+             result = [integer_value(val[1]), nil, 1]
+           }
+           | "{" "," INTEGER "}" {
+             result = [0, integer_value(val[2]), 1]
+           }
+           | "{" INTEGER "," INTEGER "}" {
+             result = [integer_value(val[1]), integer_value(val[3]), 1]
+           }
+           | "{" EVEN "}" { result = [0, nil, 2] }
+           | "{" ODD "}"  { result = [1, nil, 2] }
+
 literal : SYMBOL  { result = LiteralMatcher.new(val[0][1..-1].to_sym) }
-        | INTEGER {
-            value = if val[0] =~ /^0[bB]/
-              val[0][2..-1].to_i(2)
-            elsif val[0] =~ /^0[oO]/
-              val[0][2..-1].to_i(8)
-            elsif val[0] =~ /^0[dD]/
-              val[0][2..-1].to_i(10)
-            elsif val[0] =~ /^0[xX]/
-              val[0][2..-1].to_i(16)
-            elsif val[0] =~ /^0/
-              val[0][1..-1].to_i(8)
-            else
-              val[0].to_i
-            end
-            result = LiteralMatcher.new(value)
-          }
-        | STRING {
-            quote = val[0][0..0]
-            value = if quote == "'"
-              val[0][1..-2].gsub("\\\\", "\\").gsub("\\'", "'")
-            elsif quote == '"'
-              val[0][1..-2].
-                gsub("\\\\", "\\").
-                gsub('\\"', '"').
-                gsub("\\n", "\n").
-                gsub("\\t", "\t").
-                gsub("\\r", "\r").
-                gsub("\\f", "\f").
-                gsub("\\v", "\v").
-                gsub("\\a", "\a").
-                gsub("\\e", "\e").
-                gsub("\\b", "\b").
-                gsub("\\s", "\s").
-                gsub(/\\([0-7]{1,3})/) { $1.to_i(8).chr }.
-                gsub(/\\x([0-9a-fA-F]{1,2})/) { $1.to_i(16).chr }
-            else
-              raise "Unknown quote: #{quote.inspect}."
-            end
-            result = LiteralMatcher.new(value)
-          }
+        | INTEGER { result = LiteralMatcher.new(integer_value(val[0])) }
+        | STRING  { result = LiteralMatcher.new(string_value(val[0])) }
+
+any : ANY { result = AnyMatcher.new }
 
 ---- inner
 
@@ -98,7 +113,65 @@ end
 
 private
 
-SIMPLE_TOKENS = ["|", "<", ">", ",", "="]
+def integer_value(value)
+  if value =~ /^0[bB]/
+    value[2..-1].to_i(2)
+  elsif value =~ /^0[oO]/
+    value[2..-1].to_i(8)
+  elsif value =~ /^0[dD]/
+    value[2..-1].to_i(10)
+  elsif value =~ /^0[xX]/
+    value[2..-1].to_i(16)
+  elsif value =~ /^0/
+    value[1..-1].to_i(8)
+  else
+    value.to_i
+  end
+end
+
+def string_value(value)
+  quote = value[0..0]
+  if quote == "'"
+    value[1..-2].gsub("\\\\", "\\").gsub("\\'", "'")
+  elsif quote == '"'
+    value[1..-2].
+      gsub("\\\\", "\\").
+      gsub('\\"', '"').
+      gsub("\\n", "\n").
+      gsub("\\t", "\t").
+      gsub("\\r", "\r").
+      gsub("\\f", "\f").
+      gsub("\\v", "\v").
+      gsub("\\a", "\a").
+      gsub("\\e", "\e").
+      gsub("\\b", "\b").
+      gsub("\\s", "\s").
+      gsub(/\\([0-7]{1,3})/) { $1.to_i(8).chr }.
+      gsub(/\\x([0-9a-fA-F]{1,2})/) { $1.to_i(16).chr }
+  else
+    raise "Unknown quote: #{quote.inspect}."
+  end
+end
+
+# "^" needs to be here because if it were among operators recognized by
+# METHOD_NAME, "^=" would be recognized as two tokens.
+SIMPLE_TOKENS = [
+  "|",
+  "<",
+  ">",
+  ",",
+  "=",
+  "^=",
+  "^",
+  "$=",
+  "[",
+  "]",
+  "*",
+  "+",
+  "?",
+  "{",
+  "}"
+]
 
 COMPLEX_TOKENS = [
   # INTEGER needs to be before METHOD_NAME, otherwise e.g. "+1" would be
@@ -151,9 +224,14 @@ COMPLEX_TOKENS = [
       )
     /x
   ],
-  # We exclude "<", ">" and "|" from method names since they are lexed as simple
-  # tokens. This is because they have also other meanings in Machette patterns
-  # beside Ruby method names.
+  # ANY, EVEN and ODD need to be before METHOD_NAME, otherwise they would be
+  # recognized as method names.
+  [:ANY,  /^any/],
+  [:EVEN, /^even/],
+  [:ODD,  /^odd/],
+  # We exclude "*", "+", "<", ">", "^" and "|" from method names since they are
+  # lexed as simple tokens. This is because they have also other meanings in
+  # Machette patterns beside Ruby method names.
   [
     :METHOD_NAME,
     /^
@@ -162,7 +240,7 @@ COMPLEX_TOKENS = [
         [a-z_][a-zA-Z0-9_]*[?!=]?
         |
         # operator (sorted by length, then alphabetically)
-        (<=>|===|\[\]=|\*\*|\+@|-@|<<|<=|==|=~|>=|>>|\[\]|[%&*+\-\/^`~])
+        (<=>|===|\[\]=|\*\*|\+@|-@|<<|<=|==|=~|>=|>>|\[\]|[%&\-\/`~])
       )
     /x
   ],

data/spec/machete/matchers_spec.rb

@@ -1,6 +1,54 @@
 require "spec_helper"
 
 module Machete::Matchers
+  describe Quantifier do
+    before :each do
+      @quantifier = Quantifier.new(LiteralMatcher.new(42), 0, 100, 10)
+    end
+
+    describe "initialize" do
+      it "sets attributes correctly" do
+        @quantifier.matcher.should == LiteralMatcher.new(42)
+        @quantifier.min.should == 0
+        @quantifier.max.should == 100
+        @quantifier.step.should == 10
+      end
+    end
+
+    describe "==" do
+      it "returns true when passed the same object" do
+        @quantifier.should == @quantifier
+      end
+
+      it "returns true when passed a Quantifier initialized with the same parameters" do
+        @quantifier.should == Quantifier.new(LiteralMatcher.new(42), 0, 100, 10)
+      end
+
+      it "returns false when passed some random object" do
+        @quantifier.should_not == Object.new
+      end
+
+      it "returns false when passed a subclass of Quantifier initialized with the same parameters" do
+        class SubclassedQuantifier < Quantifier
+        end
+
+        @quantifier.should_not ==
+          SubclassedQuantifier.new(LiteralMatcher.new(42), 0, 100, 10)
+      end
+
+      it "returns false when passed a Quantifier initialized with different parameters" do
+        @quantifier.should_not ==
+          Quantifier.new(LiteralMatcher.new(43), 0, 100, 10)
+        @quantifier.should_not ==
+          Quantifier.new(LiteralMatcher.new(42), 1, 100, 10)
+        @quantifier.should_not ==
+          Quantifier.new(LiteralMatcher.new(42), 0, 101, 10)
+        @quantifier.should_not ==
+          Quantifier.new(LiteralMatcher.new(42), 0, 100, 11)
+      end
+    end
+  end
+
   describe ChoiceMatcher do
     before :each do
       @alternatives = [
@@ -137,6 +185,183 @@ module Machete::Matchers
     end
   end
 
+  describe ArrayMatcher do
+    before :each do
+      @items = [
+        LiteralMatcher.new(42),
+        LiteralMatcher.new(43),
+        LiteralMatcher.new(44)
+      ]
+      @matcher = ArrayMatcher.new(@items)
+    end
+
+    describe "initialize" do
+      it "sets attributes correctly" do
+        @matcher.items.should == @items
+      end
+    end
+
+    describe "==" do
+      it "returns true when passed the same object" do
+        @matcher.should == @matcher
+      end
+
+      it "returns true when passed a ArrayMatcher initialized with the same parameters" do
+        @matcher.should == ArrayMatcher.new(@items)
+      end
+
+      it "returns false when passed some random object" do
+        @matcher.should_not == Object.new
+      end
+
+      it "returns false when passed a subclass of ArrayMatcher initialized with the same parameters" do
+        class SubclassedArrayMatcher < ArrayMatcher
+        end
+
+        @matcher.should_not == SubclassedArrayMatcher.new(@items)
+      end
+
+      it "returns false when passed a ArrayMatcher initialized with different parameters" do
+        @matcher.should_not == ArrayMatcher.new([
+          LiteralMatcher.new(45),
+          LiteralMatcher.new(46),
+          LiteralMatcher.new(47)
+        ])
+      end
+    end
+
+    describe "matches?" do
+      it "works on matcher with no items" do
+        matcher = ArrayMatcher.new([])
+
+        matcher.matches?([]).should be_true
+        matcher.matches?([42]).should be_false
+      end
+
+      it "works on matcher with one item" do
+        matcher = ArrayMatcher.new([LiteralMatcher.new(42)])
+
+        matcher.matches?([]).should be_false
+        matcher.matches?([42]).should be_true
+        matcher.matches?([43]).should be_false
+        matcher.matches?([42, 43]).should be_false
+      end
+
+      it "works on matcher with many items" do
+        matcher = ArrayMatcher.new([
+          LiteralMatcher.new(42),
+          LiteralMatcher.new(43),
+          LiteralMatcher.new(44)
+        ])
+
+        matcher.matches?([42, 43]).should be_false
+        matcher.matches?([42, 43, 44]).should be_true
+        matcher.matches?([43, 43, 44]).should be_false
+        matcher.matches?([42, 44, 44]).should be_false
+        matcher.matches?([42, 43, 45]).should be_false
+        matcher.matches?([42, 43, 44, 45]).should be_false
+      end
+
+      it "works on matcher with a bound quantifier" do
+        matcher = ArrayMatcher.new([
+          Quantifier.new(LiteralMatcher.new(42), 1, 2, 1)
+        ])
+
+        matcher.matches?([]).should be_false
+        matcher.matches?([42]).should be_true
+        matcher.matches?([43]).should be_false
+        matcher.matches?([42, 42]).should be_true
+        matcher.matches?([43, 42]).should be_false
+        matcher.matches?([42, 43]).should be_false
+        matcher.matches?([42, 42, 42]).should be_false
+      end
+
+      it "works on matcher with a bound quantifier with a bigger step" do
+        matcher = ArrayMatcher.new([
+          Quantifier.new(LiteralMatcher.new(42), 1, 3, 2)
+        ])
+
+        matcher.matches?([]).should be_false
+        matcher.matches?([42]).should be_true
+        matcher.matches?([43]).should be_false
+        matcher.matches?([42, 42]).should be_false
+        matcher.matches?([42, 42, 42]).should be_true
+        matcher.matches?([43, 42, 42]).should be_false
+        matcher.matches?([42, 43, 42]).should be_false
+        matcher.matches?([42, 42, 43]).should be_false
+        matcher.matches?([42, 42, 42, 42]).should be_false
+      end
+
+      it "works on matcher with a bound quantifier and some items" do
+        matcher = ArrayMatcher.new([
+          LiteralMatcher.new(42),
+          Quantifier.new(LiteralMatcher.new(43), 0, 1, 1),
+          LiteralMatcher.new(44)
+        ])
+
+        matcher.matches?([42, 44]).should be_true
+        matcher.matches?([42, 43, 44]).should be_true
+        matcher.matches?([42, 44, 44]).should be_false
+        matcher.matches?([42, 43, 43, 44]).should be_false
+      end
+
+      it "works on matcher with an unbound quantifier" do
+        matcher = ArrayMatcher.new([
+          Quantifier.new(LiteralMatcher.new(42), 1, nil, 1)
+        ])
+
+        matcher.matches?([]).should be_false
+        matcher.matches?([42]).should be_true
+        matcher.matches?([43]).should be_false
+        matcher.matches?([42, 42]).should be_true
+        matcher.matches?([43, 42]).should be_false
+        matcher.matches?([42, 43]).should be_false
+        matcher.matches?([42, 42, 42]).should be_true
+        matcher.matches?([43, 42, 42]).should be_false
+        matcher.matches?([42, 43, 42]).should be_false
+        matcher.matches?([42, 42, 43]).should be_false
+      end
+
+      it "works on matcher with an unbound quantifier with a bigger step" do
+        matcher = ArrayMatcher.new([
+          Quantifier.new(LiteralMatcher.new(42), 1, nil, 2)
+        ])
+
+        matcher.matches?([]).should be_false
+        matcher.matches?([42]).should be_true
+        matcher.matches?([43]).should be_false
+        matcher.matches?([42, 42]).should be_false
+        matcher.matches?([42, 42, 42]).should be_true
+        matcher.matches?([43, 42, 42]).should be_false
+        matcher.matches?([42, 43, 42]).should be_false
+        matcher.matches?([42, 42, 43]).should be_false
+      end
+
+      it "works on matcher with an unbound quantifier and some items" do
+        matcher = ArrayMatcher.new([
+          LiteralMatcher.new(42),
+          Quantifier.new(LiteralMatcher.new(43), 0, nil, 1),
+          LiteralMatcher.new(44)
+        ])
+
+        matcher.matches?([42, 44]).should be_true
+        matcher.matches?([42, 43, 44]).should be_true
+        matcher.matches?([42, 44, 44]).should be_false
+        matcher.matches?([42, 43, 43, 44]).should be_true
+        matcher.matches?([42, 44, 43, 44]).should be_false
+        matcher.matches?([42, 43, 44, 44]).should be_false
+        matcher.matches?([42, 43, 43, 43, 44]).should be_true
+        matcher.matches?([42, 44, 43, 43, 44]).should be_false
+        matcher.matches?([42, 43, 44, 43, 44]).should be_false
+        matcher.matches?([42, 43, 43, 44, 44]).should be_false
+      end
+
+      it "does not match some random object" do
+        @matcher.matches?(Object.new).should be_false
+      end
+    end
+  end
+
   describe LiteralMatcher do
     before :each do
       @matcher = LiteralMatcher.new(42)
@@ -183,4 +408,135 @@ module Machete::Matchers
       end
     end
   end
+
+  describe StartsWithMatcher do
+    before :each do
+      @matcher = StartsWithMatcher.new("abcd")
+    end
+
+    describe "initialize" do
+      it "sets attributes correctly" do
+        @matcher.prefix.should == "abcd"
+      end
+    end
+
+    describe "==" do
+      it "returns true when passed the same object" do
+        @matcher.should == @matcher
+      end
+
+      it "returns true when passed a StartsWithMatcher initialized with the same parameters" do
+        @matcher.should == StartsWithMatcher.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 SubclassedStartsWithMatcher < StartsWithMatcher
+        end
+
+        @matcher.should_not == SubclassedStartsWithMatcher.new("abcd")
+      end
+
+      it "returns false when passed a StartsWithMatcher initialized with different parameters" do
+        @matcher.should_not == StartsWithMatcher.new("efgh")
+      end
+    end
+
+    describe "matches?" do
+      it "matches a string starting with the prefix" do
+        @matcher.matches?("abcdefgh").should be_true
+      end
+
+      it "does not match a string not starting with the prefix" 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 EndsWithMatcher do
+    before :each do
+      @matcher = EndsWithMatcher.new("abcd")
+    end
+
+    describe "initialize" do
+      it "sets attributes correctly" do
+        @matcher.suffix.should == "abcd"
+      end
+    end
+
+    describe "==" do
+      it "returns true when passed the same object" do
+        @matcher.should == @matcher
+      end
+
+      it "returns true when passed a EndsWithMatcher initialized with the same parameters" do
+        @matcher.should == EndsWithMatcher.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 EndsWithMatcher initialized with the same parameters" do
+        class SubclassedEndsWithMatcher < EndsWithMatcher
+        end
+
+        @matcher.should_not == SubclassedEndsWithMatcher.new("abcd")
+      end
+
+      it "returns false when passed a EndsWithMatcher initialized with different parameters" do
+        @matcher.should_not == EndsWithMatcher.new("efgh")
+      end
+    end
+
+    describe "matches?" do
+      it "matches a string ending with the suffix" do
+        @matcher.matches?("efghabcd").should be_true
+      end
+
+      it "does not match a string not ending with the suffix" do
+        @matcher.matches?("ijklefgh").should be_false
+      end
+
+      it "does not match some random object" do
+        @matcher.matches?(Object.new).should be_false
+      end
+    end
+  end
+
+  describe AnyMatcher do
+    before :each do
+      @matcher = AnyMatcher.new
+    end
+
+    describe "==" do
+      it "returns true when passed the same object" do
+        @matcher.should == @matcher
+      end
+
+      it "returns false when passed some random object" do
+        @matcher.should_not == Object.new
+      end
+
+      it "returns false when passed a subclass of AnyMatcher" do
+        class SubclassedAnyMatcher < AnyMatcher
+        end
+
+        @matcher.should_not == SubclassedAnyMatcher.new
+      end
+    end
+
+    describe "matches?" do
+      it "matches any object" do
+        @matcher.matches?(Object.new)
+      end
+    end
+  end
 end