method_missing_router 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm ruby-1.9.2@method_missing_router --create

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in method_missing_router.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/README.md

@@ -0,0 +1,64 @@
+# MethodMissingRouter
+MethodMissingRouter provides a DSL for dynamic methods backed by method\_missing.  You define a regular expression => method route and MethodMissingRouter spits out the tedious boilerplate code for implementing method_missing and respond_to_missing?
+
+## Basic usage
+
+To route class methods use 
+    class_route_missing /SOME_REGEX/, options
+
+To route instance methods use
+    route_missing /SOME_REGEX/, options
+
+## Working With Regex Matches
+
+You can configure the router to pass your regex matches to the target method by setting ":pass_match" or ":pass_matches" in the options hash
+
+## Examples (from /examples/example_spec.rb)
+
+    describe "an example of instance routing with multiple matches" do
+      class SpaceShip
+        include MethodMissingRouter
+        route_missing /^fire\_the\_(.+)_and_(.+)/, :fire_weapon, :pass_matches => true
+    
+        def fire_weapon(weapon_names, count)
+          "firing #{count} #{weapon_names.first} and #{weapon_names.last}"
+        end
+      end
+    
+      it 'passes along the name of the weapon since we set pass matches' do
+        ship = SpaceShip.new
+        ship.fire_the_missiles_and_bacon(5).should == "firing 5 missiles and bacon"
+      end
+    end
+    
+    
+    describe "an example of class routing with a single match" do
+      class LetterCounter
+        include MethodMissingRouter
+        class_route_missing /([a-z])s/, :count_letter, :pass_match => true
+    
+        def self.count_letter(letter, string)
+          string.count(letter)
+        end
+      end
+    
+      it 'passes along the letter since we set pass match' do
+        LetterCounter.as('a string and another string').should == 3
+      end
+    end
+    
+    
+    describe "an example of instance routing that doesn't override the message" do
+      class Turtle
+        include MethodMissingRouter
+        route_missing /some_message/, :announce
+    
+        def announce(message)
+          "message was #{message}"
+        end
+      end
+    
+      it 'passes along the original method name since we did not ask to pass the match(es)' do
+        Turtle.new.some_message_fred.should == "message was some_message_fred"
+      end
+    end

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/examples/example_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe "an example of instance routing with multiple matches" do
+  class SpaceShip
+    include MethodMissingRouter
+    route_missing /^fire\_the\_(.+)_and_(.+)/, :fire_weapon, :pass_matches => true
+
+    def fire_weapon(weapon_names, count)
+      "firing #{count} #{weapon_names.first} and #{weapon_names.last}"
+    end
+  end
+
+  it 'passes along the name of the weapon since we set pass matches' do
+    ship = SpaceShip.new
+    ship.fire_the_missiles_and_bacon(5).should == "firing 5 missiles and bacon"
+  end
+end
+
+
+describe "an example of class routing with a single match" do
+  class LetterCounter
+    include MethodMissingRouter
+    class_route_missing /([a-z])s/, :count_letter, :pass_match => true
+
+    def self.count_letter(letter, string)
+      string.count(letter)
+    end
+  end
+
+  it 'passes along the letter since we set pass match' do
+    LetterCounter.as('a string and another string').should == 3
+  end
+end
+
+
+describe "an example of instance routing that doesn't override the message" do
+  class Turtle
+    include MethodMissingRouter
+    route_missing /some_message/, :announce
+
+    def announce(message)
+      "message was #{message}"
+    end
+  end
+
+  it 'passes along the original method name since we did not ask to pass the match(es)' do
+    Turtle.new.some_message_fred.should == "message was some_message_fred"
+  end
+end

data/lib/method_missing_router/version.rb

@@ -0,0 +1,3 @@
+module MethodMissingRouter
+  VERSION = "0.0.1"
+end

data/lib/method_missing_router.rb

@@ -0,0 +1,110 @@
+require "method_missing_router/version"
+
+module MethodMissingRouter
+  def self.included(base)
+    base.extend(RoutedMethodMissing)
+    base.send(:include, RoutedMethodMissing)
+    base.extend(ClassMethods)
+    base.reset_method_missing_routes!
+  end
+
+
+  module RoutedMethodMissing
+    def respond_to_missing?(method_name, *)
+      method_missing_routes.route_for(method_name) || super
+    end
+
+    private
+
+    def method_missing(method_name, *args, &block)
+      if route = method_missing_routes.route_for(method_name)
+        call_info = CallInfo.new(self, route.target, *args, &block)
+        call_info.prepend_argument(route.message_for(method_name))
+        return call_info.call
+      else
+        super(method_name, *args, &block)
+      end
+    end
+
+    def method_missing_routes
+      if self.kind_of?(Class)
+        self.instance_variable_get("@class_method_missing_routes")
+      else 
+        self.class.instance_variable_get("@method_missing_routes")
+      end
+    end
+  end
+
+
+  module ClassMethods
+    def class_route_missing(matcher, target, options={})
+      @class_method_missing_routes << Route.new(matcher, target, options)
+    end
+
+    def route_missing(matcher, target, options={})
+      @method_missing_routes << Route.new(matcher, target, options)
+    end
+
+    def reset_method_missing_routes!
+      @method_missing_routes = RouteCollection.new
+      @class_method_missing_routes = RouteCollection.new
+    end
+  end
+
+  class RouteCollection
+    def initialize
+      @routes = []
+    end
+
+    def <<(item)
+      @routes << item
+    end
+
+    def route_for(method_name)
+      @routes.find{ |route | route.applies_to?(method_name) }
+    end
+  end
+
+  class Route
+    attr_reader :target
+
+    def initialize(regex, target, options)
+      @regex = regex
+      @target = target
+      @options = options
+    end
+
+    def applies_to?(method_name)
+      @regex =~ method_name
+    end
+
+    def message_for(method_name)
+      captures = @regex.match(method_name).captures
+      if @options[:pass_matches]
+        return captures
+      elsif @options[:pass_match]
+        return captures.first 
+      else
+        return method_name.to_s
+      end
+    end
+  end
+
+  class CallInfo
+    attr_accessor :object, :method_name, :args, :block
+    def initialize(object, method_name, *args, &block)
+      @object = object
+      @method_name = method_name
+      @args = args
+      @block = block
+    end
+
+    def prepend_argument(new_arg)
+      @args.unshift(new_arg)
+    end
+
+    def call
+      @object.send(method_name, *args, &block)
+    end
+  end
+end

data/method_missing_router.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "method_missing_router/version"
+
+Gem::Specification.new do |s|
+  s.name        = "method_missing_router"
+  s.version     = MethodMissingRouter::VERSION
+  s.authors     = ["Matt Margolis"]
+  s.email       = ["matt@mattmargolis.net"]
+  s.homepage    = ""
+  s.summary     = %q{Declarative method routing for method_missing}
+  s.description = %q{Use regular expressions to route missing methods}
+
+  s.rubyforge_project = "method_missing_router"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "guard-rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/spec/lib/method_missing_router_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+class TestMissingMethodRouter
+  include MethodMissingRouter
+end
+
+describe MethodMissingRouter do
+  let(:test_class) { TestMissingMethodRouter }
+
+  after(:each) do
+    test_class.reset_method_missing_routes!
+  end
+
+  context 'class method routing' do
+    it 'can route all missing messages to the same target' do
+      test_class.class_route_missing(/.+/, :every_message)
+      test_class.should_receive(:every_message).twice
+      test_class.blammo
+      test_class.dragon_soda
+    end
+
+    it 'can route two different formats of message to different targets' do
+      test_class.class_route_missing(/^fish/, :fish_message)
+      test_class.class_route_missing(/[a-z]+/, :lowercase_message)
+
+      test_class.should_receive(:fish_message)
+      test_class.should_receive(:lowercase_message)
+
+      test_class.fish_powers_activate
+      test_class.somelowercaseletters
+    end
+
+    it 'passes the original message name as the first argument' do
+      test_class.class_route_missing(/^fire\_the/, :fire_weapon)
+      test_class.should_receive(:fire_weapon).with('fire_the_lazer', {:power => 11})
+      test_class.fire_the_lazer(:power => 11)
+    end
+
+    it 'passes the regex match as the first argument when pass_match option is set' do
+      test_class.class_route_missing(/^fire\_the\_(.+)/, :fire_weapon, :pass_match => true)
+      test_class.should_receive(:fire_weapon).with('lazer', {:power => 11})
+      test_class.fire_the_lazer(:power => 11)
+    end
+
+    it 'passes all regex matches as the first argument when pass_matches option is set' do
+      test_class.class_route_missing(/^fire\_the\_(.+)\_and\_(.+)/, :fire_weapon, :pass_matches => true)
+      test_class.should_receive(:fire_weapon).with(['lazer', 'canon'], {:power => 11})
+      test_class.fire_the_lazer_and_canon(:power => 11)
+    end
+
+    it 'passes undeclared messages to super' do
+      expect{test_class.something_unexpected}.to raise_error(NoMethodError)
+    end
+
+    it 'properly handles queries about responding to a routed method' do
+      test_class.class_route_missing(/^has_a_method_called/, :foobar)
+      test_class.should respond_to(:has_a_method_called_frank)
+    end
+
+    it 'properly handles queries about responding to a non-routed unknown method' do
+      test_class.should_not respond_to(:some_method_i_do_not_have)
+    end
+  end
+
+  context 'instance method routing' do
+    let(:test_instance) { test_class.new }
+
+    it 'can route all missing messages to the same target' do
+      test_class.route_missing(/.*/, :every_message)
+      test_instance.should_receive(:every_message).twice
+
+      test_instance.blammo
+      test_instance.dragon_soda
+    end
+
+    it 'can route two different formats of message to different targets' do
+      test_class.route_missing(/^cow/, :cow_message)
+      test_class.route_missing(/in_a_bag$/, :in_a_bag)
+
+      test_instance.should_receive(:cow_message)
+      test_instance.should_receive(:in_a_bag)
+
+      test_instance.cowsplode
+      test_instance.pudding_in_a_bag
+    end
+
+    it 'passes the original message name as the first argument' do
+      test_class.route_missing(/^fire\_the\_/, :fire_weapon)
+      test_instance.should_receive(:fire_weapon).with('fire_the_lazer', {:power => 11})
+      test_instance.fire_the_lazer(:power => 11)
+    end
+
+    it 'passes the regex match as the first argument when pass_match option is set' do
+      test_class.route_missing(/^fire\_the\_(.+)/, :fire_weapon, :pass_match => true)
+      test_instance.should_receive(:fire_weapon).with('lazer', {:power => 11})
+      test_instance.fire_the_lazer(:power => 11)
+    end
+
+    it 'passes all regex matches as the first argument when pass_matches option is set' do
+      test_class.route_missing(/^fire\_the\_(.+)\_and\_(.+)/, :fire_weapon, :pass_matches => true)
+      test_instance.should_receive(:fire_weapon).with(['lazer', 'canon'], {:power => 11})
+      test_instance.fire_the_lazer_and_canon(:power => 11)
+    end
+
+    it 'passes undeclared messages to super' do
+      expect{test_instance.something_unexpected}.to raise_error(NoMethodError)
+    end
+
+    it 'properly handles queries about responding to a routed method' do
+      test_class.class_route_missing(/^has_a_method_called/, :foobar)
+      test_class.should respond_to(:has_a_method_called_frank)
+    end
+
+    it 'properly handles queries about responding to a non-routed unknown method' do
+      test_class.should_not respond_to(:some_method_i_do_not_have)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require "method_missing_router.rb"

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: method_missing_router
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Matt Margolis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-12 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70167569910440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70167569910440
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70167569909020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70167569909020
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &70167569907480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70167569907480
+description: Use regular expressions to route missing methods
+email:
+- matt@mattmargolis.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- examples/example_spec.rb
+- lib/method_missing_router.rb
+- lib/method_missing_router/version.rb
+- method_missing_router.gemspec
+- spec/lib/method_missing_router_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 743983748671300555
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 743983748671300555
+requirements: []
+rubyforge_project: method_missing_router
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Declarative method routing for method_missing
+test_files:
+- spec/lib/method_missing_router_spec.rb
+- spec/spec_helper.rb