missingly 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e73ef19743d5de0709594ea3d67b44efd9133b1b
-  data.tar.gz: 2222043ca754451ccce39090da828b563222cbbe
+  metadata.gz: 242b35ec57e5447c85e8ae0e22a9aac429e7eda5
+  data.tar.gz: c866e36784eada8f7b9fac4c598045fd5391b78c
 SHA512:
-  metadata.gz: e07f530971e2cb1dab180932d9d2c4e9ce00d367d0816c73ab03cbc15f066e439e42c056aba4a482495b04fb7c02ce2181c1fb222c5bc1cc3fcb29885a9593f2
-  data.tar.gz: 06e156883e936d8fe6963c71e9f40aea08ff3f2ea476b1cc7bb7786ef21e2e6d2695bedba308e72f2f64c6478b56443249bb3c0ad85d0c7cbe8f6385a3f26abd
+  metadata.gz: c74940512b88e2413720f84eeef11b59c5d39c0885fc8b87d175b26f20a2ff8b4b2e469caba81624b01187b72fe4715e3b62c0901a5d2777578fb99248e4ede4
+  data.tar.gz: a7da137a6fa783261daf4411d63012057baf08d304b78fda09a3d70b14e5a8c552d1c3f7b4ed764b30dcb8f1040607ff8116132658affa6088b8db40e27cb8c8

data/lib/missingly/array_matcher.rb

@@ -6,6 +6,10 @@ module Missingly
       @array, @options, @method_block = array, options, method_block
     end
 
+    def matchable
+      array
+    end
+
     def should_respond_to?(name)
       array.include?(name)
     end

data/lib/missingly/matchers.rb

@@ -1,26 +1,59 @@
+require 'thread'
+
 module Missingly
+  module Mutex
+    @mutex = ::Mutex.new
+
+    def self.synchronize(&block)
+      @mutex.synchronize(&block)
+    end
+  end
+
   module Matchers
     module ClassMethods
       def handle_missingly(regular_expression_or_array, options={}, &block)
+        undef_parent_missingly_methods regular_expression_or_array
+
         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)
         end
       end
 
+      def undef_parent_missingly_methods(matcher)
+        return unless superclass.respond_to?(:missingly_methods_for_matcher)
+
+        superclass.missingly_methods_for_matcher(matcher).each do |method|
+          undef_method method
+        end
+      end
+
+      def missingly_subclasses
+        @missingly_subclasses ||= []
+      end
+
       def missingly_matchers
         @missingly_matchers ||= {}
       end
 
+      def missingly_methods
+        @missingly_methods ||= Hash.new()
+      end
+
+      def missingly_methods_for_matcher(matcher)
+        missingly_methods[matcher] ||= []
+      end
+
       def _define_method(*args, &block)
         define_method(*args, &block)
       end
 
       def inherited(subclass)
         matchers = self.missingly_matchers
-        subclass.module_eval do
+        subclass.class_eval do
           @missingly_matchers =  matchers.clone
         end
+        missingly_subclasses << subclass
       end
     end
 
@@ -36,7 +69,17 @@ module Missingly
       self.class.missingly_matchers.values.each do |matcher|
         next unless matcher.should_respond_to?(method_name)
 
-        return matcher.handle(self, method_name, *args, &block)
+        Missingly::Mutex.synchronize do
+          self.class.missingly_methods_for_matcher(matcher.matchable) << method_name
+
+          returned_value = matcher.handle(self, method_name, *args, &block)
+
+          self.class.missingly_subclasses.each do |subclass|
+            subclass.undef_parent_missingly_methods matcher.matchable
+          end
+
+          return returned_value
+        end
       end
       super
     end

data/lib/missingly/regex_matcher.rb

@@ -6,6 +6,10 @@ module Missingly
       @regex, @options, @method_block = regex, options, method_block
     end
 
+    def matchable
+      regex
+    end
+
     def should_respond_to?(name)
       regex.match(name)
     end

data/lib/missingly/version.rb

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

data/spec/class_inheritance_spec.rb

@@ -16,18 +16,33 @@ describe Missingly::Matchers do
     end
   end
 
-  it "should work with an inherited class" do
+  it "should work when called before parent" do
     b = subclass.new
     b.foo.should eq :foo
   end
 
-  it "should allow override of parent class" do
-    subclass.module_eval do
-      handle_missingly [:foo] do |method|
-        :super_duper
+  describe "overriding methods" do
+    let(:subclass_with_overrides) do
+      Class.new(super_class) do
+        handle_missingly [:foo] do |method|
+          :super_duper
+        end
       end
     end
 
-    subclass.new.foo.should eq :super_duper
+    it "should work when called before parent" do
+      subclass_with_overrides.new.foo.should eq :super_duper
+    end
+
+    it "should work when called after parent" do
+      super_class.new.foo
+      subclass_with_overrides.new.foo.should eq :super_duper
+    end
+
+    it "should work when subclass initiated before parent method defined" do
+      subclass_with_overrides
+      super_class.new.foo
+      subclass_with_overrides.new.foo.should eq :super_duper
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: missingly
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Thijs de Vries
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-16 00:00:00.000000000 Z
+date: 2013-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler