missingly 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 242b35ec57e5447c85e8ae0e22a9aac429e7eda5
-  data.tar.gz: c866e36784eada8f7b9fac4c598045fd5391b78c
+  metadata.gz: 3a83705cf44cec6dd38ce2c141dc8b01056c8c93
+  data.tar.gz: 33d31bba15f08fb1ca5a7fe815a5c10d83763a54
 SHA512:
-  metadata.gz: c74940512b88e2413720f84eeef11b59c5d39c0885fc8b87d175b26f20a2ff8b4b2e469caba81624b01187b72fe4715e3b62c0901a5d2777578fb99248e4ede4
-  data.tar.gz: a7da137a6fa783261daf4411d63012057baf08d304b78fda09a3d70b14e5a8c552d1c3f7b4ed764b30dcb8f1040607ff8116132658affa6088b8db40e27cb8c8
+  metadata.gz: 210ccf7b8492f0c25c09795578ee69a367a836e3e4878a10da0b1fb8eddce9c19bc3c30bf37843b9ead71762680bc76192fb65c37776cc046a2e3dac132301cc
+  data.tar.gz: 6031dd4754856133dfcfa7f24fef13b47d152fdcc30e73eb2a593784cf5c0b6017fb0b9a9673dd6c2d863a4a944216c679122d82c1080d45a3ac90cb5487c021

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3
+  - jruby-19mode
+  - jruby-20mode
+  - rbx-19mode
+  - rbx-20mode

data/README.md

@@ -2,6 +2,10 @@
 
 A DSL for handling method\_missing hooks.
 
+[![Code Climate](https://codeclimate.com/github/moger777/missingly.png)](https://codeclimate.com/github/moger777/missingly)
+[![Build Status](https://travis-ci.org/moger777/missingly.png?branch=master)](https://travis-ci.org/moger777/missingly)
+[![Coverage Status](https://coveralls.io/repos/moger777/missingly/badge.png?branch=master)](https://coveralls.io/r/moger777/missingly?branch=master)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -110,6 +114,164 @@ class UserDecorator
 end
 ```
 
+### Use custom matchers
+
+In the example with the regex block matchers, our code has to do a
+fair amount of work which is not looking up a value in a hash, for example:
+
+```ruby
+fields = matches[1].split("_and_")
+```
+
+will run every time and can have a performance impact. Likewise we
+are always running:
+
+```ruby
+field.to_sym
+```
+
+In the hash lookup. If the field was already a symbol, there would be less work. And
+the fields were already split up, there would be less work each time. Custom block
+matchers can be done as follows:
+
+```ruby
+class OurMatcher < Missingly::BlockMatcher
+  attr_reader :some_matcher, :options_hash, :method_block
+
+  def initialize(some_matcher, options_hash, method_block)
+    @some_matcher, @method_block = some_matcher, method_block
+  end
+
+  def should_respond_to?(instance, name)
+    # our custom code
+  end
+
+  def setup_method_name_args(method_name)
+    # args we will pass to block
+  end
+
+  def matchable; some_matcher; end
+end
+```
+
+Since we essentially want to re-use the regex block helper, we can inherit and override
+setup_method_name_args. These args will be passed to the block in the handle_missingly
+call:
+
+```ruby
+class FindByFieldsWithAndsMatcher < Missingly::RegexBlockMatcher
+  attr_reader :options
+
+  def initialize(regex, options, block)
+    super regex, block
+  end
+
+  def setup_method_name_args(method_name)
+    matches = regex.match(method_name)
+    fields = matches[1].split("_and_")
+    fields.map(&:to_sym)
+  end
+end
+```
+
+From here, we can use our custom matcher:
+
+```ruby
+class ArrayWithHashes
+  include Missingly::Matchers
+
+  handle_missingly /^find_by_(\w+)$/, with: FindByFieldsWithAndsMatcher do |fields, *args, &block|
+    hashes.find do |hash|
+      fields.inject(true) do |fields_match, field|
+        index_of_field = fields.index(field)
+        arg_for_field = args[index_of_field]
+
+        fields_match = fields_match && hash[field] == arg_for_field
+        break false unless fields_match
+        true
+      end
+    end
+  end
+
+  attr_reader :hashes
+
+  def initialize(hashes)
+    @hashes = hashes
+  end
+end
+
+hashes = [
+  { id: 1, name: 'Pat', gender: 'f' },
+  { id: 2, name: 'Pat', gender: 'm' },
+  { id: 3, name: 'Steve', gender: 'm' },
+  { id: 4, name: 'Sue', gender: 'f' },
+]
+
+instance = ArrayWithHashes.new(hashes)
+instance.find_by_name_and_gender('Pat', 'm') # { id: 2, name: 'Pat', gender: 'm' }
+instance.respond_to?(:find_by_name_and_gender) # true
+instance.method(:find_by_name_and_gender) # method object
+```
+
+For more fine grain controll, you can write should_respond_to? which should
+return true if method responds to, and handle, which should define method and
+return results of first run of method.
+
+### How inheritance works
+
+The handle_missingly method is designed to be both inherited and overwritable by
+child classes. The following scenarios should work:
+
+Straight up inheritance:
+
+```ruby
+class Parent
+  handle_missingly /foo/ do
+    :foo
+  end
+end
+
+class Child < Parent
+end
+
+Child.new.foo # should return :foo
+```
+
+Overwriting:
+
+```ruby
+class Parent
+  handle_missingly /foo/ do
+    :foo
+  end
+end
+
+class Child < Parent
+  handle_missingly /foo/ do
+    :bar
+  end
+end
+
+Child.new.foo # should return :bar
+```
+
+Missingly handlers are based off of "matchable" passed to matcher, so the following
+will also be overwritten:
+
+```ruby
+class Parent
+  handle_missingly /foo/ do
+    :foo
+  end
+end
+
+class Child < Parent
+  handle_missingly /foo/, to: :something
+end
+
+Child.new.foo # should return whatever something returns
+```
+
 ## Contributing
 
 1. Fork it
@@ -117,3 +279,5 @@ end
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+6. Please no tabs or trailing whitespace
+7. Features and bug fixes should have specs

data/Rakefile

@@ -1 +1,10 @@
 require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+desc 'Run the specs'
+RSpec::Core::RakeTask.new do |r|
+  r.verbose = false
+end
+
+task :default => :spec

data/lib/missingly/array_block_matcher.rb

@@ -0,0 +1,19 @@
+module Missingly
+  class ArrayBlockMatcher < BlockMatcher
+    attr_reader :array, :method_block, :options
+
+    def initialize(array, options, method_block)
+      @array, @method_block, @options = array, method_block, options
+    end
+
+    def should_respond_to?(instance, name)
+      array.include?(name)
+    end
+
+    def setup_method_name_args(method_name)
+      method_name
+    end
+
+    def matchable; array; end
+  end
+end

data/lib/missingly/array_delegate_matcher.rb

@@ -0,0 +1,17 @@
+module Missingly
+  class ArrayDelegateMatcher < DelegateMatcher
+    attr_reader :array, :options, :delegate_name
+
+    def initialize(array, options, delegate_name)
+      @array, @options, @delegate_name = array, options, delegate_name
+    end
+
+    def should_respond_to?(instance, name)
+      included_in_array = array.include?(name)
+      delegate_responds_to = instance.send(delegate_name).respond_to?(name)
+      included_in_array && delegate_responds_to
+    end
+
+    def matchable; array; end
+  end
+end

data/lib/missingly/block_matcher.rb

@@ -0,0 +1,34 @@
+module Missingly
+  class BlockMatcher
+    def define(instance, method_name)
+
+      klass = instance.class == Class ? instance : instance.class
+
+      if instance.class == Class
+        define_class_method(klass, method_name)
+      else
+        define_instance_method(klass, method_name)
+      end
+    end
+
+    def define_class_method(klass, method_name)
+      sub_name = "_#{method_name}_submethod"
+      method_name_args = setup_method_name_args(method_name)
+
+      klass.define_singleton_method method_name do |*the_args, &the_block|
+        public_send(sub_name, method_name_args, *the_args, &the_block)
+      end
+      klass.define_singleton_method(sub_name, &method_block)
+    end
+
+    def define_instance_method(klass, method_name)
+      sub_name = "_#{method_name}_submethod"
+      method_name_args = setup_method_name_args(method_name)
+
+      klass._define_method method_name do |*the_args, &the_block|
+        public_send(sub_name, method_name_args, *the_args, &the_block)
+      end
+      klass._define_method(sub_name, &method_block)
+    end
+  end
+end

data/lib/missingly/delegate_matcher.rb

@@ -0,0 +1,11 @@
+module Missingly
+  class DelegateMatcher
+    def define(instance, name)
+      instance.class.class_eval <<-RUBY, __FILE__, __LINE__
+        def #{name}(*args, &block)
+          #{delegate_name}.#{name}(*args, &block)
+        end
+      RUBY
+    end
+  end
+end

data/lib/missingly/matchers.rb

@@ -11,20 +11,64 @@ module Missingly
 
   module Matchers
     module ClassMethods
-      def handle_missingly(regular_expression_or_array, options={}, &block)
-        undef_parent_missingly_methods regular_expression_or_array
+      def handle_missingly(matcher, options={}, &block)
+        undef_parent_missingly_methods matcher
+        undef_normal_missingly_methods matcher
+
+        if options[:with]
+          setup_custom_handler(matcher, options, &block)
+        elsif block_given?
+          setup_block_handlers(matcher, options, &block)
+        elsif options[:to]
+          setup_delegation_handlers(matcher, options, options[:to])
+        end
+      end
+
+      def setup_custom_handler(matcher, options, &block)
+        missingly_matchers[matcher] = options[:with].new(matcher, options, block)
+      end
+
+      def setup_block_handlers(matcher, options, &block)
+        case matcher
+        when Array then missingly_matchers[matcher] = ArrayBlockMatcher.new(matcher, options, block)
+        when Regexp then missingly_matchers[matcher] = RegexBlockMatcher.new(matcher, options, block)
+        end
+      end
 
-        case regular_expression_or_array
-        when Array then missingly_matchers[regular_expression_or_array] = ArrayMatcher.new(regular_expression_or_array, options, block)
-        when Regexp then missingly_matchers[regular_expression_or_array] = RegexMatcher.new(regular_expression_or_array, options, block)
+      def setup_delegation_handlers(matcher, options, to)
+        case matcher
+        when Array then missingly_matchers[matcher] = ArrayDelegateMatcher.new(matcher, options, to)
+        when Regexp then missingly_matchers[matcher] = RegexDelegateMatcher.new(matcher, options, to)
         end
       end
 
       def undef_parent_missingly_methods(matcher)
-        return unless superclass.respond_to?(:missingly_methods_for_matcher)
+        superclass = self.superclass
+        matchers = []
 
-        superclass.missingly_methods_for_matcher(matcher).each do |method|
-          undef_method method
+        while superclass.respond_to?(:missingly_methods_for_matcher)
+          matchers.concat superclass.missingly_methods_for_matcher(matcher)
+          superclass = superclass.superclass
+        end
+
+        undef_missingly_methods(matchers)
+      end
+
+      def undef_normal_missingly_methods(matcher)
+        undef_missingly_methods(missingly_methods_for_matcher(matcher))
+      end
+
+      def undef_missingly_methods(methods)
+        methods.each do |method|
+          begin
+            undef_method method
+          rescue NameError
+            eval <<-RUBY
+              class << self
+                undef_method #{method.inspect}
+              end
+            RUBY
+          end
         end
       end
 
@@ -55,11 +99,38 @@ module Missingly
         end
         missingly_subclasses << subclass
       end
+
+      def method_missing(method_name, *args, &block)
+        missingly_matchers.values.each do |matcher|
+          next unless matcher.should_respond_to?(self, method_name)
+          next unless matcher.options[:class_method]
+
+          Missingly::Mutex.synchronize do
+            missingly_methods_for_matcher(matcher.matchable) << method_name
+
+            returned_value = matcher.define(self, method_name, *args, &block)
+
+            missingly_subclasses.each do |subclass|
+              subclass.undef_parent_missingly_methods matcher.matchable
+            end
+
+            return public_send(method_name, *args, &block)
+          end
+        end
+        super
+      end
+
+      def respond_to_missing?(method_name, include_all)
+        self.missingly_matchers.values.each do |matcher|
+          return true if matcher.should_respond_to?(self, method_name.to_sym) && matcher.options[:class_method]
+        end
+        super
+      end
     end
 
     def respond_to_missing?(method_name, include_all)
       self.class.missingly_matchers.values.each do |matcher|
-        return true if matcher.should_respond_to?(method_name.to_sym)
+        return true if matcher.should_respond_to?(self, method_name.to_sym) && !(matcher.options[:class_method])
       end
       super
     end
@@ -67,18 +138,19 @@ module Missingly
 
     def method_missing(method_name, *args, &block)
       self.class.missingly_matchers.values.each do |matcher|
-        next unless matcher.should_respond_to?(method_name)
+        next unless matcher.should_respond_to?(self, method_name)
+        next if matcher.options[:class_method]
 
         Missingly::Mutex.synchronize do
           self.class.missingly_methods_for_matcher(matcher.matchable) << method_name
 
-          returned_value = matcher.handle(self, method_name, *args, &block)
+          matcher.define(self, method_name)
 
           self.class.missingly_subclasses.each do |subclass|
             subclass.undef_parent_missingly_methods matcher.matchable
           end
 
-          return returned_value
+          return public_send(method_name, *args, &block)
         end
       end
       super

data/lib/missingly/regex_block_matcher.rb

@@ -0,0 +1,19 @@
+module Missingly
+  class RegexBlockMatcher < BlockMatcher
+    attr_reader :regex, :method_block, :options
+
+    def initialize(regex, options, method_block)
+      @regex, @options, @method_block = regex, options, method_block
+    end
+
+    def should_respond_to?(instance, name)
+      regex.match(name)
+    end
+
+    def setup_method_name_args(method_name)
+      regex.match method_name
+    end
+
+    def matchable; regex; end
+  end
+end

data/lib/missingly/regex_delegate_matcher.rb

@@ -0,0 +1,17 @@
+module Missingly
+  class RegexDelegateMatcher < DelegateMatcher
+    attr_reader :regex, :options, :delegate_name
+
+    def initialize(regex, options, delegate_name)
+      @regex, @options, @delegate_name = regex, options, delegate_name
+    end
+
+    def should_respond_to?(instance, name)
+      matches = regex.match name
+      delegate_responds_to = instance.send(delegate_name).respond_to?(name)
+      matches && delegate_responds_to
+    end
+
+    def matchable; regex; end
+  end
+end

data/lib/missingly/version.rb

@@ -1,3 +1,3 @@
 module Missingly
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/lib/missingly.rb

@@ -1,7 +1,11 @@
 require "missingly/version"
 require "missingly/matchers"
-require "missingly/array_matcher"
-require "missingly/regex_matcher"
+require "missingly/block_matcher"
+require "missingly/array_block_matcher"
+require "missingly/regex_block_matcher"
+require "missingly/delegate_matcher"
+require "missingly/array_delegate_matcher"
+require "missingly/regex_delegate_matcher"
 
 module Missingly
 

data/missingly.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
-  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rspec", "~> 2.14.0"
+  spec.add_development_dependency "pry", "0.9.12"
+  spec.add_development_dependency "coveralls"
 end

data/spec/array_spec.rb

@@ -55,13 +55,6 @@ module Missingly
         instance.block.should == prock
       end
 
-      it "should define the method on call preventing further method missing calls on same class" do
-        args = [1, 2, 3]
-        prock = Proc.new { puts 'foo' }
-        instance.derp(*args, &prock)
-        Method.should === instance.method(:derp)
-      end
-
       it "should work with subsequent calls" do
         args = [1, 2, 3]
         prock = Proc.new { puts 'foo' }

data/spec/class_inheritance_spec.rb

@@ -22,8 +22,13 @@ describe Missingly::Matchers do
   end
 
   describe "overriding methods" do
-    let(:subclass_with_overrides) do
+    let(:another_inheritance_layer) do
       Class.new(super_class) do
+      end
+    end
+
+    let(:subclass_with_overrides) do
+      Class.new(another_inheritance_layer) do
         handle_missingly [:foo] do |method|
           :super_duper
         end
@@ -45,4 +50,44 @@ describe Missingly::Matchers do
       subclass_with_overrides.new.foo.should eq :super_duper
     end
   end
+
+  describe "overriding class methods" do
+    let(:super_class) do
+      Class.new do
+        include Missingly::Matchers
+
+        handle_missingly [:foo], class_method: true do |method|
+          return method
+        end
+      end
+    end
+
+    let(:another_inheritance_layer) do
+      Class.new(super_class) do
+      end
+    end
+
+    let(:subclass_with_overrides) do
+      Class.new(another_inheritance_layer) do
+        handle_missingly [:foo], class_method: true do |_|
+          :super_duper
+        end
+      end
+    end
+
+    it "should work when called before parent" do
+      subclass_with_overrides.foo.should eq :super_duper
+    end
+
+    it "should work when called after parent" do
+      super_class.foo
+      subclass_with_overrides.foo.should eq :super_duper
+    end
+
+    it "should work when subclass initiated before parent method defined" do
+      subclass_with_overrides
+      super_class.foo
+      subclass_with_overrides.foo.should eq :super_duper
+    end
+  end
 end

data/spec/class_methods_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Missingly::Matchers do
+  let(:search_class) do
+    Class.new do
+      include Missingly::Matchers
+
+      handle_missingly [:find_by_name], class_method: true do |name|
+        return {foo: 'bar'}
+      end
+
+      handle_missingly /^find_all_by_(\w+)$/, class_method: true do |matches, *args, &block|
+        return matches
+      end
+    end
+  end
+
+  let(:delegation_test) do
+    Class.new(search_class) do
+      handle_missingly [:find_by_foo], to: :proxy, class_method: true
+
+      def self.proxy
+        OpenStruct.new({find_by_foo: "foo"})
+      end
+    end
+  end
+
+
+  it "should not break normal method_missing" do
+    search_class.new.respond_to?("foo_bar_widget").should be_false
+  end
+
+  it "should allow you to define class methods" do
+    search_class.respond_to?("find_by_name").should be_true
+    search_class.respond_to?("find_all_by_name").should be_true
+    search_class.find_all_by_name.should be_a MatchData
+    search_class.find_by_name.should be_a Hash
+  end
+
+  it "should support delegation matchers" do
+    delegation_test.respond_to?("find_by_foo").should be_true
+    delegation_test.find_by_foo.should be_true
+  end
+
+  it "should not make class methods avliable to instances" do
+    search_class.new.respond_to?("find_by_name").should be_false
+    lambda { search_class.new.find_by_name("foo") }.should raise_exception
+  end
+
+  it "should work through inheritence" do
+    delegation_test.respond_to?("find_all_by_name").should be_true
+    delegation_test.find_all_by_name.should be_a MatchData
+  end
+end

data/spec/custom_matcher_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+module Missingly
+  describe Matchers do
+    let(:find_by_matcher) do
+      FindByMatcher = Class.new(Missingly::RegexBlockMatcher) do
+        attr_reader :method_block, :options
+
+        def initialize(regex, options, block)
+          @regex = regex
+          @options = options
+          @method_block = block
+        end
+
+        def setup_method_name_args(method_name)
+          matches = regex.match(method_name)
+          matches[1].split("_and_").map(&:to_sym)
+        end
+      end
+    end
+
+    let(:our_class) do
+      find_by_matcher
+      Class.new do
+      include Missingly::Matchers
+        attr_reader :hashes
+
+        def initialize(hashes)
+          @hashes = hashes
+        end
+
+        handle_missingly /^find_by_(\w+)$/, with: FindByMatcher do |fields, *args|
+          hashes.find do |hash|
+            fields.inject(true) do |fields_match, field|
+              index_of_field = fields.index(field)
+              arg_for_field = args[index_of_field]
+
+              fields_match = fields_match && hash[field.to_sym] == arg_for_field
+              break false unless fields_match
+              true
+            end
+          end
+        end
+      end
+    end
+
+    let(:our_instance) do
+      hashes = [
+        { first_name: 'Bob', last_name: 'Dole' },
+        { first_name: 'Bill', last_name: 'Clinton' },
+        { first_name: 'George', last_name: 'Bush' }
+      ]
+      our_class.new(hashes)
+    end
+
+    it "should allow us to define custom matchers" do
+      our_instance.find_by_first_name_and_last_name('Bill', 'Douglas').should be_nil
+      our_instance.find_by_first_name_and_last_name('Bill', 'Clinton').should == { first_name: 'Bill', last_name: 'Clinton' }
+    end
+  end
+end

data/spec/delegation_spec.rb

@@ -11,11 +11,11 @@ module Missingly
       end
     end
 
-    let(:proxy){ stub }
+    let(:proxy){ double }
 
     let(:instance) do
       i = our_class.new
-      i.stub(:proxy).and_return(proxy)
+      allow(i).to receive(:proxy).and_return(proxy)
       i
     end
 

data/spec/matchers_spec.rb

@@ -0,0 +1,39 @@
+module Missingly
+  describe Matchers do
+    describe "#handle_missingly" do
+      it "can be used to override previous missingly with same matcher" do
+        klass = Class.new do
+          include Missingly::Matchers
+
+          handle_missingly /foo/ do |*args|
+            'foo'
+          end
+
+          handle_missingly /foo/ do |*args|
+            'bar'
+          end
+        end
+
+        klass.new.foo.should eq('bar')
+
+        another_klass = Class.new do
+          include Missingly::Matchers
+
+          handle_missingly /foo/ do |*args|
+            'foo'
+          end
+        end
+
+        another_klass.new.foo
+
+        another_klass.module_eval do
+          handle_missingly /foo/ do |*args|
+            'bar'
+          end
+        end
+
+        another_klass.new.foo.should eq('bar')
+      end
+    end
+  end
+end

data/spec/regex_spec.rb

@@ -84,13 +84,6 @@ module Missingly
         instance.block.should == prock
       end
 
-      it "should define the method on call preventing further method missing calls on same class" do
-        args = [1, 2, 3]
-        prock = Proc.new { puts 'foo' }
-        instance.find_by_id_and_first_name(*args, &prock)
-        Method.should === instance.method(:find_by_id_and_first_name)
-      end
-
       it "should work with subsequent calls" do
         args = [1, 2, 3]
         prock = Proc.new { puts 'foo' }

data/spec/spec_helper.rb

@@ -1,2 +1,5 @@
+require 'coveralls'
+Coveralls.wear!
+
 require_relative '../lib/missingly'
 require 'pry'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: missingly
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Thijs de Vries
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-20 00:00:00.000000000 Z
+date: 2013-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -42,18 +42,32 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.14.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.14.0
 - !ruby/object:Gem::Dependency
   name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.12
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.12
+- !ruby/object:Gem::Dependency
+  name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -74,19 +88,27 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/missingly.rb
-- lib/missingly/array_matcher.rb
+- lib/missingly/array_block_matcher.rb
+- lib/missingly/array_delegate_matcher.rb
+- lib/missingly/block_matcher.rb
+- lib/missingly/delegate_matcher.rb
 - lib/missingly/matchers.rb
-- lib/missingly/regex_matcher.rb
+- lib/missingly/regex_block_matcher.rb
+- lib/missingly/regex_delegate_matcher.rb
 - lib/missingly/version.rb
 - missingly.gemspec
 - spec/array_spec.rb
 - spec/class_inheritance_spec.rb
+- spec/class_methods_spec.rb
+- spec/custom_matcher_spec.rb
 - spec/delegation_spec.rb
+- spec/matchers_spec.rb
 - spec/regex_spec.rb
 - spec/spec_helper.rb
 homepage: ''
@@ -116,6 +138,9 @@ summary: A DSL for defining method missing methods
 test_files:
 - spec/array_spec.rb
 - spec/class_inheritance_spec.rb
+- spec/class_methods_spec.rb
+- spec/custom_matcher_spec.rb
 - spec/delegation_spec.rb
+- spec/matchers_spec.rb
 - spec/regex_spec.rb
 - spec/spec_helper.rb

data/lib/missingly/array_matcher.rb

@@ -1,40 +0,0 @@
-module Missingly
-  class ArrayMatcher
-    attr_reader :array, :options, :method_block
-
-    def initialize(array, options, method_block)
-      @array, @options, @method_block = array, options, method_block
-    end
-
-    def matchable
-      array
-    end
-
-    def should_respond_to?(name)
-      array.include?(name)
-    end
-
-    def handle(instance, method_name, *args, &block)
-      if method_block
-        sub_name = "#{method_name}_with_method_name"
-
-        instance.class._define_method method_name do |*the_args, &the_block|
-          public_send(sub_name, method_name, *the_args, &the_block)
-        end
-        instance.class._define_method(sub_name, &method_block)
-
-        instance.public_send(method_name, *args, &block)
-      elsif options[:to]
-        instance.class.class_eval <<-CODE
-          def #{method_name}(*args, &block)
-            #{options[:to]}.#{method_name}(*args, &block)
-          end
-        CODE
-
-        instance.public_send(method_name, *args, &block)
-      else
-        raise ArgumentError, "either block, or to option should be passed"
-      end
-    end
-  end
-end

data/lib/missingly/regex_matcher.rb

@@ -1,41 +0,0 @@
-module Missingly
-  class RegexMatcher
-    attr_reader :regex, :options, :method_block
-
-    def initialize(regex, options, method_block)
-      @regex, @options, @method_block = regex, options, method_block
-    end
-
-    def matchable
-      regex
-    end
-
-    def should_respond_to?(name)
-      regex.match(name)
-    end
-
-    def handle(instance, method_name, *args, &block)
-      if method_block
-        matches = regex.match method_name
-
-        sub_name = "#{method_name}_with_matches"
-        instance.class._define_method method_name do |*the_args, &the_block|
-          public_send(sub_name, matches, *the_args, &the_block)
-        end
-        instance.class._define_method(sub_name, &method_block)
-
-        instance.public_send(method_name, *args, &block)
-      elsif options[:to]
-        instance.class.class_eval <<-CODE
-          def #{method_name}(*args, &block)
-            #{options[:to]}.#{method_name}(*args, &block)
-          end
-        CODE
-
-        instance.public_send(method_name, *args, &block)
-      else
-        raise ArgumentError, "either block, or to option should be passed"
-      end
-    end
-  end
-end