matches 1.0.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Phil Calvin
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,30 @@
+Matches – easygoing methods
+===========================
+
+Matches is an easy DSL for defining regular-expression-based methods in Ruby.
+
+Start playing with matches:
+
+    require 'matches'
+    
+    class Hippo
+      def initialize
+        @verbs = []
+      end
+      
+      matches /(\w+)\!/ do |verb|
+        @verbs << verb
+      end
+      
+      matches /(\w+)ed\?/ do |verb|
+        @verbs.include?(verb)
+      end
+    end
+
+    herman = Hippo.new
+    herman.fatten!
+    herman.touch!
+    
+    herman.touched?
+    ==> true
+

data/README.rdoc

@@ -0,0 +1,18 @@
+= matches - easygoing methods
+
+Matches is an easy DSL for defining regular-expression-based methods in Ruby.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 Phil Calvin. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "matches"
+    gem.summary = %Q{A DSL for defining regular-expression-based methods in Ruby.}
+    gem.description = %Q{Matches allows you to define methods that have regular 
+                         expressions rather than names, and automatically
+                         configires method_missing to handle them.}
+    gem.email = "pncalvin@gmail.com"
+    gem.homepage = "http://github.com/pnc/matches"
+    gem.authors = ["Phil Calvin"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "cucumber", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "matches #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/*.rb')
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.spec_opts = ['--options', "\"spec/spec.opts\""]
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/features/define_matches.feature

@@ -0,0 +1,44 @@
+As a fancy-pants programmer
+I want to define match methods using regular expressions
+So that I don't have to screw around with method_missing
+
+Scenario: Define a matcher method
+  Given I have the following Ruby code:
+  """
+    class Hippo 
+      matches /(\w+)\!/ do |verb|
+        puts "I've been #{verb}ed!"
+      end
+    end
+    
+    Hippo.new.touch!
+  """
+  When I execute the code
+  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
+      def initialize
+        @verbs = []
+      end
+
+      matches /(\w+)\!/ do |verb|
+        @verbs << verb
+      end
+
+      matches /(\w+)ed\?/ do |verb|
+        @verbs.include?(verb)
+      end
+    end
+
+    herman = Hippo.new
+    herman.fatten!
+    herman.touch!
+
+    puts herman.touched?
+  """
+  When I execute the code
+  Then I should see "true" in the output

data/features/step_definitions/method_steps.rb

@@ -0,0 +1,33 @@
+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
+
+When /^I execute the code$/ do
+  module Kernel
+    def puts(str)
+      OutputStorage.write("#{str}\n")
+    end
+  end
+  
+  eval(@code)
+end
+
+Then /^I should see \"(.+)\" in the output$/ do |text|
+  OutputStorage.output.should =~ /#{text}/
+end
+
+class OutputStorage
+  @@output = ""
+  
+  def self.write(str)
+    @@output += str
+  end
+  
+  def self.output
+    @@output
+  end
+end

data/features/support/env.rb

@@ -0,0 +1,3 @@
+require File.dirname(__FILE__) + "/../../lib/matches"
+
+require 'spec/stubs/cucumber'

data/lib/match_method.rb

@@ -0,0 +1,48 @@
+class MatchMethod
+  attr_accessor :matcher, :proc
+  
+  # Allows properties to be specified in the constructor.
+  # E.g.,
+  #   MetaMethod.new(:matcher => /foo/)
+  def initialize(args)
+    args.each do |key, value|
+      send("#{key}=", value)
+    end
+  end
+  
+  # Returns whether this MetaMethod is capable of matching the given
+  # message.
+  def matches?(message)
+    !!(message.to_s =~ matcher)
+  end
+  
+  # Calls the method's proc if the message matches.
+  def match(instance, message, *args)
+    groups = message.to_s.match(matcher)[1..-1]
+    
+    # Should curry here: instance.instance_eval( &proc.curry(groups + args) )
+    # Or we could use instance_exec.
+    # But these require 1.9. Darn. One day!
+    
+    full = (groups + args).flatten
+    instance.instance_exec(*full, &proc)
+  end
+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.
+
+class Object
+  def instance_exec(*args, &block)
+    mname = "__instance_exec_#{Thread.current.object_id.abs}"
+    class << self; self end.class_eval{ define_method(mname, &block) }
+    begin
+      ret = send(mname, *args)
+    ensure
+      class << self; self end.class_eval{ undef_method(mname) } rescue nil
+    end
+    ret
+  end
+end

data/lib/matches.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + "/match_method"
+
+module MatchDef
+  def matches(regexp, &block)
+    @@match_methods ||= []
+    
+    @@match_methods << MatchMethod.new( :matcher => regexp,
+                                        :proc => block )
+    self.class_eval {
+      unless respond_to?(:match_method_missing)
+        def match_method_missing(message, *args)
+          # 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)
+        end
+      
+        alias_method :old_method_missing, :method_missing
+        alias_method :method_missing, :match_method_missing
+      end
+    }
+  end
+  
+  def reset_meta_methods
+    @@match_methods = []
+  end
+end
+
+Class.class_eval { include MatchDef }

data/spec/match_method_spec.rb

@@ -0,0 +1,75 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe MatchMethod do
+  it "should store its matcher" do
+    mm = MatchMethod.new(:matcher => /foo/)
+    mm.matcher.should == /foo/
+  end
+  
+  it "should know if a message matches" do
+    mm = MatchMethod.new(:matcher => /find_by_(\w+)/)
+    mm.matches?('find_by_something').should be_true
+  end
+  
+  it "should not match if the message doesn't match" do
+    mm = MatchMethod.new(:matcher => /find_by_(\w+)/)
+    mm.matches?('not').should be_false
+  end
+  
+  it "should store a Proc" do
+    real_proc = Proc.new {}
+    mm = MatchMethod.new(:matcher => /find_by_(\w+)/, 
+                        :proc => real_proc)
+    mm.proc.should == real_proc
+  end
+  
+  it "should call its Proc when a message matches" do
+    mock_proc = Proc.new {}
+    object = Object.new
+    object.should_receive(:instance_exec).once.with('something')
+    
+    mm = MatchMethod.new(:matcher => /find_by_(\w+)/, 
+                        :proc => mock_proc)
+    mm.match(object, 'find_by_something')
+  end
+  
+  it "should work with no groups" do
+    mock_proc = Proc.new {}
+    object = Object.new
+    object.should_receive(:instance_exec).once.with(no_args())
+    
+    mm = MatchMethod.new(:matcher => /find_by_something/, 
+                        :proc => mock_proc)
+    mm.match(object, :find_by_something)
+  end
+  
+  it "should pass each group in as an argument" do
+    mock_proc = Proc.new {}
+    object = Object.new
+    object.should_receive(:instance_exec).once.with('something')
+    
+    mm = MatchMethod.new(:matcher => /find_by_(\w+)/, 
+                        :proc => mock_proc)
+    mm.match(object, :find_by_something)
+  end
+  
+  it "should work with arguments, too" do
+    mock_proc = Proc.new {}
+    object = Object.new
+    object.should_receive(:instance_exec).once.with('argument')
+    
+    mm = MatchMethod.new(:matcher => /find_by_something/, 
+                        :proc => mock_proc)
+    mm.match(object, :find_by_something, 'argument')
+  end
+  
+  it "should work with both match groups and arguments" do
+    mock_proc = Proc.new {}
+    object = Object.new
+    object.should_receive(:instance_exec).once.with('something', 'argument')
+    
+    mm = MatchMethod.new(:matcher => /find_by_(\w+)/, 
+                        :proc => mock_proc)
+    mm.match(object, :find_by_something, 'argument')
+  end
+end

data/spec/matches_spec.rb

@@ -0,0 +1,74 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe MatchDef do
+  before(:each) do
+    Hippo.reset_meta_methods
+  end
+  
+  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 /bar/ do
+        worked
+      end
+    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)
+      end
+    end
+    
+    test = Hippo.new
+    test.should_receive(:worked).once.with('fight')
+    test.bar_fight()
+  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)
+      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 = Rhino.new
+    lambda { test.second() }.should raise_error
+  end
+end
+
+class Hippo
+end
+
+class Rhino
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'matches'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: matches
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Phil Calvin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-23 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.9
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: |-
+  Matches allows you to define methods that have regular 
+                           expressions rather than names, and automatically
+                           configires method_missing to handle them.
+email: pncalvin@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+- README.rdoc
+files: 
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- features/define_matches.feature
+- features/step_definitions/method_steps.rb
+- features/support/env.rb
+- lib/match_method.rb
+- lib/matches.rb
+- spec/match_method_spec.rb
+- spec/matches_spec.rb
+- spec/spec_helper.rb
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/pnc/matches
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A DSL for defining regular-expression-based methods in Ruby.
+test_files: 
+- spec/match_method_spec.rb
+- spec/matches_spec.rb
+- spec/spec_helper.rb