matches 1.0.3 → 1.0.4

data/TODO.md

@@ -0,0 +1,10 @@
+To do
+=====
+
+Implement regular-expression priorities like Cucumber:
+------------------------------------------------------
+
+  1. The longest Regexp with 0 capture groups always wins.
+  2. The Regexp with the most capture groups wins (when there are none with 0 groups)
+  3. If there are 2+ Regexen with the same number of capture groups, the one with the shortest overall captured string length wins
+  4. If there are still 2+ options then an Ambiguous error is raised

data/VERSION

@@ -1 +1 @@
-1.0.3
+1.0.4

data/features/define_matches.feature

@@ -6,7 +6,7 @@ Scenario: Define a matcher method
   Given I have the following Ruby code:
   """
     class Hippo 
-      matches /(\w+)\!/ do |verb|
+      matches /^(\w+)\!$/ do |verb|
         puts "I've been #{verb}ed!"
       end
     end
@@ -17,7 +17,6 @@ Scenario: Define a matcher method
   Then I should see "I've been touched!" in the output
 
 Scenario: Another meta-method
-  Given I reset the class Hippo
   Given I have the following Ruby code:
   """
     class Hippo
@@ -25,11 +24,11 @@ Scenario: Another meta-method
         @verbs = []
       end
 
-      matches /(\w+)\!/ do |verb|
+      matches /^(\w+)\!$/ do |verb|
         @verbs << verb
       end
 
-      matches /(\w+)ed\?/ do |verb|
+      matches /^(\w+)ed\?$/ do |verb|
         @verbs.include?(verb)
       end
     end
@@ -41,4 +40,29 @@ Scenario: Another meta-method
     puts herman.touched?
   """
   When I execute the code
-  Then I should see "true" in the output
+  Then I should see "true" in the output
+  
+Scenario: Defining class methods
+  Given I have the following Ruby code:
+  """
+    class Hippo
+      attr_accessor :disposition
+      
+      def initialize(dis)
+        self.disposition = dis
+      end
+      
+      class << self
+        matches /^new_(\w+)$/ do |dis|
+          new(dis)
+        end
+      end
+    end
+
+    herman = Hippo.new_angry
+
+    puts herman.disposition
+  """
+  When I execute the code
+  Then I should see "angry" in the output
+  

data/features/step_definitions/method_steps.rb

@@ -1,7 +1,3 @@
-Given /^I reset the class (.+)$/ do |klass|
-  eval("#{klass}.reset_meta_methods")
-end
-
 Given /^I have the following Ruby code:$/ do |code|
   @code = code
 end
@@ -30,4 +26,8 @@ class OutputStorage
   def self.output
     @@output
   end
+  
+  def self.clear
+    @@output = ""
+  end
 end

data/features/support/env.rb

@@ -1,3 +1,16 @@
 require File.dirname(__FILE__) + "/../../lib/matches"
 
-require 'spec/stubs/cucumber'
+require 'spec/stubs/cucumber'
+
+Before do
+  # Look through all the classes, some of which will have been defined
+  # in the scenarios. Reset their match methods if necessary.
+  Module.constants.each do |constant|
+    klass = Kernel.const_get(constant)
+    if klass.kind_of?(Class)
+      klass.reset_match_methods if klass.respond_to?(:reset_match_methods)
+    end
+  end
+  
+  OutputStorage.clear()
+end

data/lib/matches.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + "/match_method"
 
 # Defines all the necessary components to allow defining dynamic methods.
 module MatchDef
-  # Defines a new class method that allows you to define dynamic methods.
+  # Defines a new class method that allows you to define dynamicinstance methods.
   # Takes a regular expression and a block, which are stored and called later.
   def matches(regexp, &block)
     @@match_methods ||= []
@@ -10,18 +10,21 @@ module MatchDef
     @@match_methods << MatchMethod.new( :matcher => regexp,
                                         :proc => block )
     self.class_eval {
-      unless respond_to?(:match_method_missing)
+      unless method_defined? :method_missing
+        def method_missing(meth, *args, &block); super; end
+      end
+      
+      unless method_defined?(:match_method_missing)
         # Defines a +method_missing+ that is aware of the
         # dynamically-defined methods and will call them if appropriate.
-        def match_method_missing(message, *args)
+        def match_method_missing(message, *args, &block)
           # Attempt to evaluate this using a MetaMethod
           result = @@match_methods.find do |mm|
             if mm.matches?(message)
               return mm.match(self, message, args)
             end
           end
-          return result if result
-          return old_method_missing(message, args)
+          return result || old_method_missing(message, args, &block)
         end
       
         alias_method :old_method_missing, :method_missing
@@ -32,7 +35,7 @@ module MatchDef
   
   # Allows you to delete all defined dynamic methods on a class.
   # This permits testing.
-  def reset_meta_methods
+  def reset_match_methods
     @@match_methods = []
   end
 end

data/matches.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{matches}
-  s.version = "1.0.3"
+  s.version = "1.0.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Phil Calvin"]
@@ -26,6 +26,7 @@ Gem::Specification.new do |s|
      "README.md",
      "README.rdoc",
      "Rakefile",
+     "TODO.md",
      "VERSION",
      "features/define_matches.feature",
      "features/step_definitions/method_steps.rb",

data/spec/matches_spec.rb

@@ -2,68 +2,130 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe MatchDef do
   before(:each) do
-    Hippo.reset_meta_methods
+    Hippo.reset_match_methods
+    
+    class Hippo
+      def method_missing(message, *args)
+        super
+      end
+      
+      if method_defined?(:match_method_missing)
+        undef match_method_missing
+      end
+    end
   end
   
-  it "should provide a matches method on classes" do
-    lambda {
+  describe "when defining instance methods" do
+  
+    it "should provide a matches method on classes" do
+      lambda {
+        Hippo.class_eval do
+          matches /foo/
+        end
+      }.should_not raise_error
+    end
+  
+    it "should call the method if it matches" do
       Hippo.class_eval do
-        matches /foo/
+        matches /bar/ do
+          worked
+        end
       end
-    }.should_not raise_error
-  end
+    
+      test = Hippo.new
+      test.should_receive(:worked).once
+      test.bar
+    end
   
-  it "should call the method if it matches" do
-    Hippo.class_eval do
-      matches /bar/ do
-        worked
+    it "should pass in the match groups" do
+      Hippo.class_eval do
+        matches /bar_(\w+)/ do |activity|
+          worked(activity)
+        end
       end
+    
+      test = Hippo.new
+      test.should_receive(:worked).once.with('fight')
+      test.bar_fight()
     end
     
-    test = Hippo.new
-    test.should_receive(:worked).once
-    test.bar
-  end
-  
-  it "should pass in the match groups" do
-    Hippo.class_eval do
-      matches /bar_(\w+)/ do |activity|
-        worked(activity)
+    it "should fall through normally if no match" do
+      Hippo.class_eval do
+        matches /bar_(\w+)/ do |activity|
+          worked(activity)
+        end
       end
-    end
     
-    test = Hippo.new
-    test.should_receive(:worked).once.with('fight')
-    test.bar_fight()
-  end
+      test = Hippo.new
+      test.should_receive(:worked).never
+      lambda { test.totally_unmatched }.should raise_error(NoMethodError)
+    end
   
-  it "should respect an existing method_missing" do
-    Hippo.class_eval do
-      def method_missing(message, *args)
-        affirm(message)
-      end
+    it "should respect an existing method_missing" do
+      Hippo.class_eval do
+        def method_missing(message, *args)
+          affirm(message)
+        end
       
-      matches /second/ do
-        affirm(:second)
+        matches /second/ do
+          affirm(:second)
+        end
       end
+    
+      test = Hippo.new
+      test.should_receive(:affirm).once.with(:first)
+      test.should_receive(:affirm).once.with(:second)
+      test.first()
+      test.second()
     end
+  
+    it "should not pollute other classes" do
+      Hippo.class_eval do
+        matches /second/ do
+          throw "Should never be reached"
+        end
+      end
     
-    test = Hippo.new
-    test.should_receive(:affirm).once.with(:first)
-    test.should_receive(:affirm).once.with(:second)
-    test.first()
-    test.second()
+      test = Rhino.new
+      lambda { test.second() }.should raise_error
+    end
+  
   end
   
-  it "should not pollute other classes" do
-    Hippo.class_eval do
-      matches /second/ do
-        throw "Should never be reached"
+  describe "when defining class methods" do
+    
+    it "should call the method if it matches" do
+      Hippo.should_receive(:worked).once
+      class Hippo
+        class << self
+          matches /foo/ do
+            worked
+          end
+        end
       end
+      
+      Hippo.foo
     end
     
-    test = Rhino.new
-    lambda { test.second() }.should raise_error
+    it "should differentiate between class and instance methods" do
+      class Hippo
+        matches /foo/ do
+          worked
+        end
+        
+        class << self
+          matches /foo/ do
+            failed
+          end
+        end
+      end
+      
+      herman = Hippo.new
+      Hippo.should_receive(:failed).never
+      herman.should_receive(:worked).once
+      
+      herman.foo
+    end
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: matches
 version: !ruby/object:Gem::Version 
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors: 
 - Phil Calvin
@@ -52,6 +52,7 @@ files:
 - README.md
 - README.rdoc
 - Rakefile
+- TODO.md
 - VERSION
 - features/define_matches.feature
 - features/step_definitions/method_steps.rb