inheritance_hash 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7e4e36238a2b52dcf48c009726068a39130cdc44
+  data.tar.gz: 96a5381e76b43802c28f0ba9a5be99c6988aa3fb
+SHA512:
+  metadata.gz: 50112cd991b77a460358d0cec40b70b0307fa8ad0bfb035c1a78d7422a90185cf7d741eab2d562758a28b6feb9185b46a866416aa91aa05f42ccf0bce64d1ceb
+  data.tar.gz: 883855b64888a9e1ab2b5950b7d01627f102ed2c4f1cde19ee7c6c8f07007bf6a8bb8683f6edb7d1cab42833a7bb2ef5aac11abf140a198980126d3fd530bc0d

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Frank Hall
+
+MIT License
+
+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,35 @@
+# InheritanceHash
+
+A hash that can inherit entries from other normal hashes or other inheritance hashes.
+Originally created for class level attributes, InheritanceHash is designed for maintaining hashes in an inheritable fashion such that changes in the parent can be reflected in the children but not vice versa.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'inheritance_hash'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install inheritance_hash
+
+## Usage
+
+  Use it just like a normal hash only call InheritanceHash.new
+
+  To inherit values from another hash use: ihash.inherit_from(other_hash)
+
+  To prevent inheriting a specific value use: ihash.dont_inherit(key)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+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

data/Rakefile

@@ -0,0 +1,16 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rdoc/task'
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task :test => :spec
+
+RDoc::Task.new do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.main = 'README.md'
+  rdoc.rdoc_files.include 'README.md', "lib/**/*\.rb"
+
+  rdoc.options << '--line-numbers'
+end

data/inheritance_hash.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'inheritance_hash/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'inheritance_hash'
+  spec.version       = InheritanceHash::VERSION
+  spec.authors       = ['Frank Hall']
+  spec.email         = ['ChapterHouse.Dune@gmail.com']
+  spec.description   = %q{A hash that can inherit entries from other normal hashes or other inheritance hashes.}
+  spec.summary       = %q{Originally created for class level attributes, InheritanceHash is designed for maintaining hashes in an inheritable fashion such that changes in the parent can be reflected in the children but not vice versa.}
+  spec.homepage      = 'http://chapterhouse.github.io/inheritance_hash'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rdoc'
+
+end

data/lib/inheritance_hash/version.rb

@@ -0,0 +1,4 @@
+class InheritanceHash < Hash
+  # 0.0.1
+  VERSION = "0.0.1"
+end

data/lib/inheritance_hash.rb

@@ -0,0 +1,240 @@
+require 'inheritance_hash/version'
+
+class InheritanceHash < Hash
+
+  #:nodoc:
+  alias :__has_key? :has_key?
+  private(:__has_key?)
+
+  instance_methods.each do |m|
+    undef_method(m) unless m =~ /(^__|^nil\?|^send$|^object_id$|^tap$|^class$)/
+  end
+
+  #:doc:
+  def self.[](*args) #:nodoc:
+    ihash = InheritanceHash.new
+    if args.size == 1
+      if args.first.is_a?(Array)
+        args.first.each { |item| ihash[item.first] = item.last }
+      else
+        if args.first.respond_to?(:to_h)
+          args.first.to_h.each { |key, value| ihash[key] = value }
+        else
+          raise ArgumentError.new('odd number of arguments for Hash')
+        end
+      end
+    elsif args.size.even?
+      args.each_slice(2) { |key, value| ihash[key] = value }
+    else
+      raise ArgumentError.new('odd number of arguments for Hash')
+    end
+    ihash
+  end
+
+  def initialize(*args) #:nodoc:
+    super
+  end
+
+  def [](key) #:nodoc:
+    if __has_key?(key)
+      super
+    elsif inheritable?(key) && !deleted?(key) && up_chain.has_key?(key)
+      up_chain[key]
+    else
+      default(key)
+    end
+  end
+
+  def []=(key, value) #:nodoc:
+    key_set(key)
+    super
+  end
+
+  def assoc(obj) #:nodoc:
+    if __has_key?(object)
+      super
+    else
+      up_chain.assoc(obj)
+    end
+  end
+
+  def clear #:nodoc:
+    deleted_keys += (up_chain.keys - noninheritable)
+    deleted_keys.uniq!
+    super
+  end
+
+  # This is not yet implemented as it will be neccessary to prevent children from causing
+  # side effects in other children by affecting the parent's comparison method.
+  def compare_by_identity
+    raise NotImplementedError
+  end
+
+  def delete(key) #:nodoc:
+    if noninheritable?(key)
+      super
+    else
+      if deleted?(key)
+        block_given? ? yield(key) : default
+      else
+        if __has_key?(key)
+          super
+        elsif up_chain.has_key?(key)
+          delete_key(key)
+          up_chain[key]
+        else
+          block_given? ? yield(key) : default
+        end
+      end
+    end
+
+  end
+
+  def delete_if #:nodoc:
+    if block_given?
+      each { |key, value| delete(key) if yield(key, value) }
+      self
+    else
+      raise NotImplementedError, 'External iterator not yet supported'
+    end
+  end
+
+  # Define a key as uninheritable.
+  # If the key is not defined in this hash it will not check the parent.
+  # The key does not need to currently exist in the hash.
+  def dont_inherit(key)
+    noninheritable << key
+    noninheritable.uniq!
+  end
+
+  def fetch(*args) #:nodoc:
+    if args.length < 1 || args.length > 2
+      raise ArgumentError, "wrong number of arguments (#{args.length} for 1..2)"
+    elsif args.length == 2 && block_given?
+      warn('warning: block supersedes default value argument')
+    end
+
+    key = args.first
+
+    if __has_key?(key)
+      super
+    elsif inheritable?(key) && !deleted?(key) && up_chain.has_key?(key)
+      up_chain.fetch(key)
+    else
+      if block_given?
+        yield(key)
+      elsif args.length == 2
+        args[1]
+      else
+        raise KeyError, "key not found #{args.first.inspect}"
+      end
+    end
+  end
+
+  def has_key?(key) #:nodoc:
+    super || up_chain.has_key?(key)
+  end
+
+
+  # Mark a key as inheritable (the default).
+  # If the key was previously marked as uninheritable, this will remove that setting.
+  # The key does not need to currently exist in the hash.
+  def inherit(key)
+    noninheritable.delete(key)
+  end
+
+  # Set the hash to inherit from. Usually this would be another InheritanceHash but can be a normal Hash.
+  # Note: Using a normal Hash will not automatically undelete keys in the child InheritanceHash if they are reset in the parent Hash.
+  def inherit_from(hash)
+    unless hash == self
+      up_chain.unchain_from(self) if up_chain.respond_to?(:unchain_from, true)
+      self.up_chain = hash
+      up_chain.down_chain_to(self) if up_chain.respond_to?(:down_chain_to, true)
+    end
+  end
+
+  def keep_if #:nodoc:
+    if block_given?
+      each { |key, value| delete(key) unless yield(key, value) }
+      self
+    else
+      raise NotImplementedError, 'External iterator not yet supported'
+    end
+  end
+
+  def respond_to?(*args) #:nodoc:
+    [:inherit, :dont_inherit, :inherit_from].include?(args.first) || args[1] && [:down_chain_to, :unchain_from].include?(args.first) || {}.respond_to?(*args)
+  end
+
+  def to_h #:nodoc:
+    up_chain.to_h.select { |key, _| inheritable?(key) }.merge(super).select { |key, _| !deleted?(key) }
+  end
+
+
+  protected
+
+  def down_chain_to(hash) #:nodoc:
+    unless hash == self
+      down_chains << hash
+      down_chains.uniq!
+    end
+  end
+
+  def key_set(key) #:nodoc:
+    if inheritable?(key)
+      deleted_keys.delete(key)
+      #deleted(key).delete
+      down_chains.each { |down_chain| down_chain.key_set(key) }
+    end
+  end
+
+  def unchain_from(hash) #:nodoc:
+    down_chains.delete(hash)
+  end
+
+  private
+
+
+  attr_writer :up_chain, :down_chains
+
+  def deleted?(key)
+    deleted_keys.include?(key)
+    #(deleted.keys + deleted_keys).include?(key)
+  end
+
+  def delete_key(key)
+    deleted_keys << key
+    deleted_keys.uniq!
+  end
+
+  # Inherited values we are pretending to have 'deleted' but may be restored if the up_chain sets another value.
+  def deleted_keys
+    @deleted_keys ||= []
+  end
+
+  def up_chain
+    @up_chain ||= {}
+  end
+
+  def inheritable?(key)
+    !noninheritable?(key)
+  end
+
+  def noninheritable
+    @noninheritable ||= []
+  end
+
+  def noninheritable?(key)
+    noninheritable.include?(key)
+  end
+
+  def method_missing(method_name, *args, &block)
+    to_h.send(*(args.unshift(method_name)), &block)
+  end
+
+  def down_chains
+    @down_chains ||= []
+  end
+
+end
+

data/spec/lib/inheritance_hash_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+
+describe InheritanceHash do
+
+  let(:parent) { InheritanceHash[:a, 1, :b, 2, :c, 3, :z, 10] }
+  let(:child)  { InheritanceHash[:d, 4, :e, 5, :f, 6, :z, 11].tap { |x| x.inherit_from(parent)} }
+  let(:child2) { InheritanceHash[:g, 7, :h, 8, :i, 9, :z, 12].tap { |x| x.inherit_from(parent)} }
+
+  context '.[]' do
+
+    it 'accepts a list of key value pairs' do
+      expect(InheritanceHash[:a, 1, :b, 2]).to eql(Hash[:a, 1, :b, 2])
+    end
+
+    it 'accepts an object convertible to a hash' do
+      hash = {:a => 1, :b => 2}
+      expect(InheritanceHash[hash]).to eql(Hash[hash])
+    end
+
+    it 'accepts an array of key value pairs' do
+      array = [[:a, 1], [:b, 2]]
+      expect(InheritanceHash[array]).to eql(Hash[array])
+    end
+
+    it 'throws an error if given a list with an odd number of arguments' do
+      expect { InheritanceHash[1, 2, 3] }.to raise_error(ArgumentError)
+    end
+
+  end
+
+  context '[]'  do
+
+    it 'acts like a Hash but returns values from within itself or the parent' do
+      expect(parent[:a]).to equal(1)
+      expect(child[:a]).to equal(1)
+      expect(child2[:a]).to equal(1)
+    end
+
+    it 'returns its own values over that of the parent\'s' do
+      expect(child[:z]).to equal(11)
+      expect(child2[:z]).to equal(12)
+    end
+
+    it 'does not return values from siblings' do
+      expect(child[:d]).to_not be_nil
+      expect(child2[:d]).to be_nil
+    end
+
+
+  end
+
+  context '[]=' do
+
+    it 'propagates the values to children' do
+      parent[:Q] = 101
+      expect(child[:Q]).to equal(101)
+    end
+
+    it 'does not propagate the values to parents or siblings' do
+      child[:Q] = 101
+      expect(parent[:Q]).to be_nil
+      expect(child2[:Q]).to be_nil
+    end
+
+    it 'does not change existing child values' do
+      parent[:d] = 101
+      expect(child[:d]).to equal(4)
+    end
+
+    it 'propagates the value to the children if the child previously deleted the key' do
+      child.delete(:a)
+      expect(parent[:a]).to_not be_nil
+      expect(child[:a]).to be_nil
+      parent[:a] = 101
+      expect(child[:a]).to equal(101)
+    end
+
+  end
+
+  context 'delete' do
+
+    it 'deletes values from children if they are being inherited' do
+      parent.delete(:a)
+      expect(parent[:a]).to be_nil
+      expect(child[:a]).to be_nil
+    end
+
+    it 'does not delete values from parents' do
+      child.delete(:a)
+      expect(child[:a]).to be_nil
+      expect(parent[:a]).to equal(1)
+    end
+
+    it 'does not delete values from children if they have a local value of the same key' do
+      child[:a] = 101
+      parent.delete(:a)
+      expect(parent[:a]).to be_nil
+      expect(child[:a]).to equal(101)
+    end
+
+    it 'falls back to the inherited value if local value is deleted' do
+      child[:a] = 101
+      child.delete(:a)
+      expect(child[:a]).to equal(parent[:a])
+    end
+
+  end
+
+  context 'dont_inherit' do
+
+    it 'prevents a value from being inherited from a parent' do
+      expect(child[:a]).to_not be_nil
+      child.dont_inherit(:a)
+      expect(child[:a]).to be_nil
+      expect(parent[:a]).to_not be_nil
+      parent[:a] = 101
+      expect(child[:a]).to be_nil
+    end
+
+  end
+
+
+  context 'fetch'  do
+
+    it 'acts like a Hash but returns values from within itself or the parent' do
+      expect(parent.fetch(:a)).to equal(1)
+      expect(child.fetch(:a)).to equal(1)
+      expect(child2.fetch(:a)).to equal(1)
+    end
+
+    it 'returns its own values over that of the parent\'s' do
+      expect(child.fetch(:z)).to equal(11)
+      expect(child2.fetch(:z)).to equal(12)
+    end
+
+    it 'does not return values from siblings' do
+      expect(child.fetch(:d)).to_not be_nil
+      expect { child2.fetch(:d) }.to raise_error(KeyError)
+    end
+
+
+  end
+
+  context 'inherit' do
+
+    it 'reinherits a value that previously was disinherited' do
+      child.dont_inherit(:a)
+      expect(child[:a]).to be_nil
+      child.inherit(:a)
+      expect(child[:a]).to equal(parent[:a])
+    end
+
+  end
+
+end
+
+
+
+
+
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'bundler/setup'
+require 'rspec/autorun'
+require 'inheritance_hash'
+
+# Support the errors_on check without rails loaded
+#module ::ActiveModel::Validations
+#  def errors_on(attribute)
+#    self.valid?
+#    [self.errors[attribute]].flatten.compact
+#  end
+#  alias :error_on :errors_on
+#end
+
+RSpec.configure do |config|
+  config.order = "random"
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+end
+
+
+

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: inheritance_hash
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Frank Hall
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A hash that can inherit entries from other normal hashes or other inheritance
+  hashes.
+email:
+- ChapterHouse.Dune@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- inheritance_hash.gemspec
+- lib/inheritance_hash.rb
+- lib/inheritance_hash/version.rb
+- spec/lib/inheritance_hash_spec.rb
+- spec/spec_helper.rb
+homepage: http://chapterhouse.github.io/inheritance_hash
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Originally created for class level attributes, InheritanceHash is designed
+  for maintaining hashes in an inheritable fashion such that changes in the parent
+  can be reflected in the children but not vice versa.
+test_files:
+- spec/lib/inheritance_hash_spec.rb
+- spec/spec_helper.rb