inherited-hash 1.0.0 → 1.0.1

data/lib/inherited-hash.rb

@@ -1,23 +1,36 @@
 require "inherited-hash/version"
 
 module InheritedHash
-  def inherited_hash_accessor *names
-    names.each do |name|
-      [self,class<<self;self;end].each do |context|
-        context.send(%Q{instance_eval}.to_s) do
-          define_method(name) do
-            storage = %Q{@#{name}}.to_sym
-            unless instance_variable_defined?( storage )
-              instance_variable_set(storage, InheritedHash::ConnectedHash.new.connect(self,name))
+  def self.extended(base)
+    base.send(:include, InstanceMethods)
+    base.extend ClassMethods
+  end
+  
+  module InstanceMethods
+    def inherited_hashes
+      @inherited_hashes ||= Hash.new do |h,name|
+        h[name] = ConnectedHash.new.connect(self,name)
+      end
+    end  
+  end
+
+  module ClassMethods
+    include InstanceMethods
+
+    def inherited_hash_accessor *names
+      names.each do |name|
+        [self,class<<self;self;end].each do |context|
+          context.send(%Q{instance_eval}.to_s) do
+            define_method(name) do
+              inherited_hashes[name]
+            end
+            define_method(%Q{#{name}!}.to_sym) do
+              inherited_hashes[name].to_hash!
+            end
+            define_method(%Q{#{name}=}.to_sym) do |hsh|
+              raise ArgumentError, 'Only hashes are allowed' unless hsh.is_a? Hash
+              inherited_hashes[name].replace(hsh)
             end
-            instance_variable_get( storage)
-          end
-          define_method(%Q{#{name}!}.to_sym) do
-            send(name).to_hash!
-          end
-          define_method(%Q{#{name}=}.to_sym) do |hsh|
-            raise ArgumentError, 'Only hashes are allowed' unless hsh.is_a? Hash
-            send(name).replace(hsh)
           end
         end
       end
@@ -37,11 +50,11 @@ module InheritedHash
     def to_hash!
       verify!
       return @anchor.class.send(%Q{#{@name}!}.to_sym).merge(self.to_hash) unless @anchor.is_a? Module
-      hash = Hash.new
-      @anchor.ancestors.reverse.each do |ancestor|
-        hash.merge!(ancestor.send(@name).to_hash) if ancestor.respond_to?(@name)
-      end
-      hash
+
+      @anchor.ancestors.reverse.map do |ancestor|
+        next nil unless ancestor.respond_to?(:inherited_hashes)
+        ancestor.inherited_hashes[@name].to_hash
+      end.compact.reduce({},:merge)
     end
 
     def to_hash
@@ -53,8 +66,8 @@ module InheritedHash
       return @anchor if has_key? key
       return @anchor.class.send(@name).find_definition_of(key) unless @anchor.is_a? Module
       @anchor.ancestors.reverse.index do |ancestor|
-        next false unless ancestor.respond_to?(@name)
-        return ancestor if ancestor.send(@name).has_key?(key)
+        next nil unless ancestor.respond_to?(:inherited_hashes)
+        return ancestor if ancestor.inherited_hashes[@name].has_key?(key)
       end
     end
   end

data/lib/inherited-hash/version.rb

@@ -1,3 +1,3 @@
 module InheritedHash
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/spec/inherited-hash_spec.rb

@@ -40,6 +40,12 @@ describe 'InheritedHash' do
       @s[:leaf2_shoot1] = Class.new(@s[:leaf2]) do
         foo[:existing_key] = 'changed!'
       end
+      @s[:leaf_with_colliding_module_extended] = Class.new(@s[:leaf1]) do
+        extend Module.new{ def foo() [] end }
+      end
+      @s[:leaf_with_colliding_module_included] = Class.new(@s[:leaf1]) do
+        include Module.new{ def foo() [] end }
+      end
 
       @s
     end
@@ -71,36 +77,45 @@ describe 'InheritedHash' do
         subject.foo![:not_overridden].should == "don't override me"
       end
 
-      context 'instance' do
-        subject do
-          s = @s[:leaf1].new
-          s.foo = {:another_new_key => 'ooh, shiny'}
-          s
-        end
-        it 'should have access to instance-set key' do
-          subject.foo![:another_new_key].should == 'ooh, shiny'
-        end
-        it 'should have access to keys inherited from class' do
-          subject.foo![:existing_key].should == 'changed'
-        end
-        it 'should have access to keys inherited from root' do
-          subject.foo![:not_overridden].should == "don't override me"
-        end
-        it 'should be able to find the definition in the object' do
-          subject.foo.find_definition_of(:another_new_key).should be subject
-        end
-        it 'should be able to find the definition in the class' do
-          subject.foo.find_definition_of(:new_key).should be subject.class
-          subject.foo.find_definition_of(:existing_key).should be subject.class
-        end
-        it 'should be able to find the definition in the root' do
-          subject.foo.find_definition_of(:not_overridden).should be @s[:root]
-        end
-        it 'should not be able to find a definition that does not exist' do
-          subject.foo.find_definition_of(:not_exist).should be_nil
+      [
+        :leaf1,
+        :leaf_with_colliding_module_extended,
+        :leaf_with_colliding_module_included
+      ].compact.each do |node|
+        context "instance of #{node}" do
+          subject do
+            s = @s[node].new
+            s.foo = {:another_new_key => 'ooh, shiny'}
+            s
+          end
+          it 'should have access to instance-set key' do
+            subject.foo![:another_new_key].should == 'ooh, shiny'
+          end
+          it 'should have access to keys inherited from class' do
+            subject.foo![:existing_key].should == 'changed'
+          end
+          it 'should have access to keys inherited from root' do
+            subject.foo![:not_overridden].should == "don't override me"
+          end
+
+          # don't run these on colliding, since colliding by definition breaks this
+          if node == :leaf1
+            it 'should be able to find the definition in the object' do
+              subject.foo.find_definition_of(:another_new_key).should be subject
+            end
+            it 'should be able to find the definition in the class' do
+              subject.foo.find_definition_of(:new_key).should be subject.class
+              subject.foo.find_definition_of(:existing_key).should be subject.class
+            end
+            it 'should be able to find the definition in the root' do
+              subject.foo.find_definition_of(:not_overridden).should be @s[:root]
+            end
+            it 'should not be able to find a definition that does not exist' do
+              subject.foo.find_definition_of(:not_exist).should be_nil
+            end
+          end
         end
       end
     end
-
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: inherited-hash
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: 
   segments: 
   - 1
   - 0
-  - 0
-  version: 1.0.0
+  - 1
+  version: 1.0.1
 platform: ruby
 authors: 
 - Ryan Biesemeyer
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-02 00:00:00 Z
+date: 2012-01-06 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec