matches 1.0.4 → 1.1.0

data/Rakefile

@@ -52,10 +52,13 @@ Spec::Rake::SpecTask.new(:spec) do |spec|
 end
 
 Spec::Rake::SpecTask.new(:rcov) do |spec|
-
+  spec.spec_opts = ['--options', "\"spec/spec.opts\""]
+  spec.spec_files = FileList['spec/*_spec.rb']
   spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/*_spec.rb'
   spec.rcov = true
+  spec.rcov_opts = lambda do
+    IO.readlines("spec/rcov.opts").map {|l| l.chomp.split " "}.flatten
+  end
 end
 
 task :spec => :check_dependencies

data/VERSION

@@ -1 +1 @@
-1.0.4
+1.1.0

data/features/define_matches.feature

@@ -25,6 +25,7 @@ Scenario: Another meta-method
       end
 
       matches /^(\w+)\!$/ do |verb|
+        puts "Doing a #{verb}"
         @verbs << verb
       end
 

data/lib/match_method.rb

@@ -38,19 +38,29 @@ class MatchMethod
 end
 
 # SWEET HACK ZOMG. Mind has been blown.
-# http://www.ruby-forum.com/topic/54096
-# Mauricio Fernandez is a Ruby beast.
 # This provides instance-exec-like functionality in Ruby 1.8.
+# Originally saw this here:
+# http://www.ruby-forum.com/topic/54096
+# It appears to have been revised here, so this is a new version:
+# http://eigenclass.org/hiki/bounded+space+instance_exec
 
 if RUBY_VERSION.split('.')[1].to_i < 9
   class Object
+    module InstanceExecHelper; end
+    include InstanceExecHelper
     def instance_exec(*args, &block)
-      mname = "__instance_exec_#{Thread.current.object_id.abs}"
-      class << self; self end.class_eval{ define_method(mname, &block) }
+      begin
+        old_critical, Thread.critical = Thread.critical, true
+        n = 0
+        n += 1 while respond_to?(mname="__instance_exec#{n}")
+        InstanceExecHelper.module_eval{ define_method(mname, &block) }
+      ensure
+        Thread.critical = old_critical
+      end
       begin
         ret = send(mname, *args)
       ensure
-        class << self; self end.class_eval{ undef_method(mname) } rescue nil
+        InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
       end
       ret
     end

data/lib/matches.rb

@@ -2,14 +2,42 @@ 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 dynamicinstance methods.
+  # Defines a new class method that allows you to define dynamic instance methods.
   # Takes a regular expression and a block, which are stored and called later.
   def matches(regexp, &block)
-    @@match_methods ||= []
+    # This evil voodoo scares the crud out of me.
+    # It sneaks into the instance upon which we are called
+    # and sets a class variable, so we can keep track of what
+    # match methods have been defined.
+    unless self.send(:class_variable_defined?, :@@match_methods)
+      self.send(:class_variable_set, :@@match_methods, [])
+      self.send(:class_variable_set, :@@cached_match_methods, [])
+    end
+    
+    append_to_methods = Proc.new do |method|
+      current = self.send(:class_variable_get, :@@match_methods)
+      self.send(:class_variable_set, :@@match_methods, current + [method])
+    end
+    
+    @@available_methods = Proc.new do
+      self.send(:class_variable_get, :@@match_methods)
+    end
+    
+    @@append_to_cached_methods = Proc.new do |method|
+      current = self.send(:class_variable_get, :@@cached_match_methods)
+      self.send(:class_variable_set, :@@cached_match_methods, current + [method])
+    end
+    
+    # The above statement tweaks the scope, so when we refer to
+    # @@match_methods here, what we're really doing is referring to
+    # the above @@match_methods.
+    self.class_eval do
+      append_to_methods.call(MatchMethod.new( :matcher => regexp,
+                                              :proc => block ))
+    end
     
-    @@match_methods << MatchMethod.new( :matcher => regexp,
-                                        :proc => block )
     self.class_eval {
+      
       unless method_defined? :method_missing
         def method_missing(meth, *args, &block); super; end
       end
@@ -18,13 +46,28 @@ module MatchDef
         # Defines a +method_missing+ that is aware of the
         # dynamically-defined methods and will call them if appropriate.
         def match_method_missing(message, *args, &block)
-          # Attempt to evaluate this using a MetaMethod
-          result = @@match_methods.find do |mm|
+          result = nil
+          
+          # Attempt to evaluate this using a MatchMethod
+          matched = @@available_methods.call.find do |mm|
             if mm.matches?(message)
-              return mm.match(self, message, args)
+              
+              # Cache the method onto the class
+              self.class.send(:define_method, message, lambda { |*largs|
+                return mm.match(self, message, *largs) 
+              })
+              
+              # Store the name of the cached method in order to facilitate
+              # introspection.
+              @@append_to_cached_methods.call(message)
+              
+              # Call the actual method
+              result = self.send(message, *args)
+              
+              true
             end
           end
-          return result || old_method_missing(message, args, &block)
+          return matched ? result : old_method_missing(message, args, &block)
         end
       
         alias_method :old_method_missing, :method_missing
@@ -33,10 +76,22 @@ module MatchDef
     }
   end
   
+  def reset_match_methods
+    # @@match_methods = []
+  end
+  
   # Allows you to delete all defined dynamic methods on a class.
   # This permits testing.
   def reset_match_methods
-    @@match_methods = []
+    self.send(:class_variable_set, :@@match_methods, [])
+    
+    if self.send(:class_variable_defined?, :@@cached_match_methods)
+      self.send(:class_variable_get, :@@cached_match_methods).each do |method|
+        self.send(:undef_method, method)
+      end
+    end
+    
+    self.send(:class_variable_set, :@@cached_match_methods, [])
   end
 end
 

data/matches.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{matches}
-  s.version = "1.0.4"
+  s.version = "1.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Phil Calvin"]

data/spec/matches_spec.rb

@@ -3,15 +3,9 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 describe MatchDef do
   before(:each) do
     Hippo.reset_match_methods
-    
+        
+    Object.send(:remove_const, :Hippo)
     class Hippo
-      def method_missing(message, *args)
-        super
-      end
-      
-      if method_defined?(:match_method_missing)
-        undef match_method_missing
-      end
     end
   end
   
@@ -49,6 +43,18 @@ describe MatchDef do
       test.bar_fight()
     end
     
+    it "should support arguments, too" do
+      Hippo.class_eval do
+        matches /bar_(\w+)/ do |activity, style|
+          worked(activity, style)
+        end
+      end
+    
+      test = Hippo.new
+      test.should_receive(:worked).once.with('fight', 'crazy')
+      test.bar_fight('crazy')
+    end
+    
     it "should fall through normally if no match" do
       Hippo.class_eval do
         matches /bar_(\w+)/ do |activity|
@@ -85,9 +91,12 @@ describe MatchDef do
           throw "Should never be reached"
         end
       end
-    
+      
+      herman = Hippo.new
+      lambda { herman.second }.should raise_error(NameError)
+      
       test = Rhino.new
-      lambda { test.second() }.should raise_error
+      lambda { test.second }.should raise_error(NoMethodError)
     end
   
   end
@@ -109,22 +118,52 @@ describe MatchDef do
     
     it "should differentiate between class and instance methods" do
       class Hippo
-        matches /foo/ do
-          worked
+        matches /something/ do
+          throw "Called on instance"
         end
         
         class << self
-          matches /foo/ do
-            failed
+          matches /something/ do
+            throw "Called on class"
           end
         end
       end
       
       herman = Hippo.new
-      Hippo.should_receive(:failed).never
-      herman.should_receive(:worked).once
       
+      lambda { herman.something }.should raise_error(NameError)
+      lambda { Hippo.something }.should raise_error(NameError)
+    end
+  end
+  
+  describe "caching" do
+    it "should cache methods when they are called" do
+      class Hippo
+        matches /foo/ do
+          worked
+        end
+      end
+    
+      herman = Hippo.new
+      herman.should_receive(:worked).once
+    
       herman.foo
+      herman.methods.should include('foo')
+    end
+    
+    it "should support complex, multi-argument cached methods" do
+      class Hippo
+        matches /foo_(\w+)/ do |a, b|
+          worked(a, b)
+        end
+      end
+    
+      herman = Hippo.new
+      herman.should_receive(:worked).twice.with('bar', 'baz')
+    
+      herman.foo_bar('baz')
+      herman.methods.should include('foo_bar')
+      herman.foo_bar('baz')
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: matches
 version: !ruby/object:Gem::Version 
-  version: 1.0.4
+  version: 1.1.0
 platform: ruby
 authors: 
 - Phil Calvin