hashr 1.0.0 → 2.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 363367721272caa3b82603de2d83346a509a4a5f
-  data.tar.gz: 5a3b97d5394ae7c46e6f926e8e72cd5f37b3856b
+  metadata.gz: 865d5c744eb989eb6faa51b252a52b83ac31fd49
+  data.tar.gz: a69e87efba10818c1af7036e02d75327210dbc3b
 SHA512:
-  metadata.gz: 8a89f6e9a054164233456eabe2a4e14ce9ef42f4d6c80a2ebb3c42e185412ab39ba56dda24079293593238c089762444583cdfaaaaa955c5a33442abc7991eda
-  data.tar.gz: 609ed7d5b46af9cf45c52783efd0f97420280eb42dfb2b9c204805e9dd4a5036163244c1aebab428065e5a5d12b2f711491d45b0af7ae9d4dc8621933239b7fd
+  metadata.gz: 1e2285af349146a905c6bcc53f5bdacc9d644f2ca48e05e69d700e18082d2285dd1b49e16670808a470e72e6ced4795ceb614d6d4eeded4310e61c9f1ffb559e
+  data.tar.gz: 993a3e986b50d2c9c34bd2ce153f2a25c10d0530962cca561880361f9080d83cdbb87f83de34b3dc11029ed88a5cf479d9de259396dc7d09b089f00d9820a336

data/Gemfile

@@ -1,2 +1,7 @@
 source 'https://rubygems.org'
+
 gemspec
+
+group :test do
+  gem 'rspec'
+end

data/README.md

@@ -2,145 +2,107 @@
 
 # Hashr
 
-Hashr is a very simple and tiny class derived from Ruby's core Hash class which makes using nested hashes for configuration (and other purposes) easier and less repetive and error prone.
+Hashr is a very simple and tiny class which makes using nested hashes for
+configuration (and other purposes) easier.
 
 It supports the following features:
 
 * method read and write access
 * automatic predicate (boolean, i.e. `?`) methods
 * easy defaults
-* easy inclusion of modules into nested hashes
-* automatic symbolized keys
+* indifferent (strings vs symbols) keys
 
 ## Usage
 
 Directly use Hashr instances like this:
 
-    config = Hashr.new('foo' => { 'bar' => 'bar' })
+```ruby
+config = Hashr.new(foo: { bar: 'bar' })
 
-    config.foo?     # => true
-    config.foo      # => { :bar => 'bar' }
+config.foo?     # => true
+config.foo      # => { bar: 'bar' }
 
-    config.foo.bar? # => true
-    config.foo.bar  # => 'bar'
+config.foo.bar? # => true
+config.foo.bar  # => 'bar'
 
-    config.foo.bar = 'bar!'
-    config.foo.bar # => 'bar!'
+config.foo.bar = 'bar'
+config.foo.bar # => 'bar'
 
-    config.foo.baz = 'baz'
-    config.foo.baz # => 'baz'
+config.foo.baz = 'baz'
+config.foo.baz # => 'baz'
+```
 
-Be aware that by default missing keys won't raise an exception but instead behave like Hash access:
+Hash core methods are not available but assume you mean to look up keys with
+the same name:
 
-    config = Hashr.new
-    config.foo? # => false
-    config.foo  # => nil
+```ruby
+config = Hashr.new(count: 1, key: 'key')
+config.count # => 1
+config.key   # => 'key'
+```
 
-You can make Hashr raise an `IndexError` though like this:
+In order to check a hash stored on a certain key you can convert it to a Ruby
+Hash:
 
-    Hashr.raise_missing_keys = true
-    config = Hashr.new
-    config.foo? # => false
-    config.foo  # => raises an IndexError "Key :foo is not defined."
+```ruby
+config = Hashr.new(count: 1, key: 'key')
+config.to_h.count # => 2
+config.to_h.key   # => raises ArgumentError: "wrong number of arguments (0 for 1)"
+```
 
-You can also anonymously overwrite core Hash methods like this:
+Missing keys won't raise an exception but instead behave like Hash access:
 
-    config = Hashr.new(:count => 3) do
-      def count
-        self[:count]
-      end
-    end
-    config.count # => 3
+```ruby
+config = Hashr.new
+config.foo? # => false
+config.foo  # => nil
+```
 
-And you can anonymously provide defaults like this:
+## Defaults
 
-    data     = { :foo => 'foo' }
-    defaults = { :bar => 'bar' }
-    config   = Hashr.new(data, defaults)
-    config.foo # => 'foo'
-    config.bar # => 'bar'
+Defaults can be defined per class:
 
-But you can obvioulsy also derive a custom class to define defaults and overwrite core Hash methods like this:
+```ruby
+class Config < Hashr
+  default boxes: { memory: '1024' }
+end
 
-    class Config < Hashr
-      define :foo => { :bar => 'bar' }
+config = Config.new
+config.boxes.memory # => 1024
+```
 
-      def count
-        self[:count]
-      end
-    end
+Or passed to the instance:
 
-    config = Config.new
-    config.foo.bar # => 'bar'
+```ruby
+data = {}
+defaults = { boxes: { memory: '1024' } }
 
-Include modules to nested hashes like this:
-
-    class Config < Hashr
-      module Boxes
-        def count
-          self[:count] # overwrites a Hash method to return the Hash's content here
-        end
-
-        def names
-          @names ||= (1..count).map { |num| "box-#{num}" }
-        end
-      end
-
-      define :boxes => { :count => 3, :_include => Boxes }
-    end
-
-    config = Config.new
-    config.boxes       # => { :count => 3 }
-    config.boxes.count # => 3
-    config.boxes.names # => ["box-1", "box-2", "box-3"]
-
-As overwriting Hash methods for method access to keys is a common pattern there's a short cut to it:
-
-    class Config < Hashr
-      define :_access => [:count, :key]
-    end
-
-    config = Config.new(:count => 3, :key => 'key')
-    config.count # => 3
-    config.key   # => 'key'
-
-Both `:_include` and `:_access` can be defined as defaults, i.e. so that they will be used on all nested hashes:
-
-    class Config < Hashr
-      default :_access => :key
-    end
-
-    config = Config.new(:key => 'key', :foo => { :key => 'foo.key' })
-    config.key     # => 'key'
-    config.foo.key # => 'foo.key'
+config = Hashr.new(data, defaults)
+config.boxes.memory # => 1024
+```
 
 ## Environment defaults
 
-Hashr includes a simple module that makes it easy to overwrite configuration defaults from environment variables:
+Hashr includes a simple module that makes it easy to overwrite configuration
+defaults from environment variables:
 
-    class Config < Hashr
-      extend Hashr::EnvDefaults
+```ruby
+class Config < Hashr
+  extend Hashr::Env
 
-      self.env_namespace = 'foo'
+  self.env_namespace = 'foo'
 
-      define :boxes => { :memory => '1024' }
-    end
+  default boxes: { memory: '1024' }
+end
+```
 
 Now when an environment variable is defined then it will overwrite the default:
 
-    ENV['FOO_BOXES_MEMORY'] = '2048'
-    config = Config.new
-    config.boxes.memory # => '2048'
-
-## Running the tests
-
-You can run the tests as follows:
-
-    # going through bundler
-    bundle exec rake
-
-    # using just ruby
-    ruby -rubygems -Ilib:test test/hashr_test.rb
+```ruby
+ENV['FOO_BOXES_MEMORY'] = '2048'
+config = Config.new
+config.boxes.memory # => '2048'
+```
 
 ## Other libraries
 

data/lib/hashr.rb

@@ -1,132 +1,108 @@
 require 'hashr/core_ext/ruby/hash'
 
-class Hashr < Hash
-  autoload :EnvDefaults, 'hashr/env_defaults'
-
-  TEMPLATE = new
+class Hashr < BasicObject
+  require 'hashr/delegate/conditional'
+  require 'hashr/env'
 
   class << self
-    attr_accessor :raise_missing_keys
+    attr_reader :defaults
 
-    def define(definition)
-      @definition = deep_accessorize(definition.deep_symbolize_keys)
+    def inherited(other)
+      other.default(defaults)
     end
 
-    def definition
-      @definition ||= {}
+    def new(*args)
+      super(self, *args)
     end
 
     def default(defaults)
-      @defaults = deep_accessorize(defaults)
+      @defaults = (self.defaults || {}).deep_merge(defaults || {})
     end
+    alias :define :default
 
-    def defaults
-      @defaults ||= {}
+    def const_missing(name)
+      Kernel.const_get(name)
     end
+  end
+
+  attr_reader :class
+
+  def initialize(klass, data = nil, defaults = nil, &block)
+    ::Kernel.fail ::ArgumentError.new("Invalid input #{data.inspect}") unless data.nil? || data.is_a?(::Hash)
 
-    def deep_accessorize(hash)
-      hash.each do |key, value|
-        next unless value.is_a?(Hash)
-        value[:_access] ||= []
-        value[:_access] = Array(value[:_access])
-        value.keys.each { |key| value[:_access] << key if value.respond_to?(key) }
-        deep_accessorize(value)
-      end
+    data = (data || {}).deep_symbolize_keys
+    defaults = (defaults || klass.defaults || {}).deep_symbolize_keys
+
+    @class = klass
+    @data = defaults.deep_merge(data).inject({}) do |result, (key, value)|
+      result.merge(key => value.is_a?(::Hash) ? ::Hashr.new(value, {}) : value)
     end
   end
 
-  undef :id if method_defined?(:id) # undefine deprecated method #id on 1.8.x
-
-  def initialize(data = {}, definition = self.class.definition, &block)
-    raise(ArgumentError.new("Invalid input #{data.inspect}")) unless data.nil? || data.is_a?(Hash)
-    replace((deep_hashrize(definition.deep_merge((data || {}).deep_symbolize_keys))))
-    deep_defaultize(self)
-    (class << self; self; end).class_eval(&block) if block_given?
+  def defined?(key)
+    @data.key?(to_key(key))
   end
 
-  def [](key, default = nil)
-    store(key.to_sym, Hashr.new(default)) if default && !key?(key)
-    super(key.to_sym)
+  def [](key)
+    @data[to_key(key)]
   end
 
   def []=(key, value)
-    super(key.to_sym, value.is_a?(Hash) ? self.class.new(value, {}) : value)
+    @data.store(to_key(key), value.is_a?(::Hash) ? ::Hashr.new(value, {}) : value)
   end
 
-  def set(path, value, stack = [])
-    tokens = path.to_s.split('.')
-    tokens.size == 1 ? self[path] = value : self[tokens.shift, Hashr.new].set(tokens.join('.'), value, stack)
+  def values_at(*keys)
+    keys.map { |key| self[key] }
   end
 
-  def respond_to?(method)
-    if self.class.raise_missing_keys
-      key?(method)
-    else
-      true
-    end
+  def respond_to?(*args)
+    true
   end
 
   def method_missing(name, *args, &block)
     case name.to_s[-1, 1]
     when '?'
-      !!self[name.to_s[0..-2].to_sym]
+      !!self[name.to_s[0..-2]]
     when '='
-      self[name.to_s[0..-2].to_sym] = args.first
+      self[name.to_s[0..-2]] = args.first
     else
-      raise(IndexError.new("Key #{name.inspect} is not defined.")) if !key?(name) && self.class.raise_missing_keys
       self[name]
     end
   end
 
-  def include_modules(modules)
-    Array(modules).each { |mod| meta_class.send(:include, mod) } if modules
+  def try(key)
+    defined?(key) ? self[key] : nil # TODO needs to look for to_h etc
   end
 
-  def include_accessors(accessors)
-    Array(accessors).each { |accessor| meta_class.send(:define_method, accessor) { self[accessor] } } if accessors
+  def to_h
+    @data.inject({}) do |hash, (key, value)|
+      hash.merge(key => value.respond_to?(:to_h) ? value.to_h : value)
+    end
   end
+  alias to_hash to_h
 
-  def meta_class
-    class << self; self end
+  def ==(other)
+    to_h == other.to_h if other.respond_to?(:to_h)
   end
 
-  def to_hash
-    inject({}) do |hash, (key, value)|
-      hash[key] = value.is_a?(Hashr) ? value.to_hash : value
-      hash
-    end
+  def instance_of?(const)
+    self.class == const
   end
 
-  protected
-
-    def deep_hashrize(hash)
-      hash.inject(TEMPLATE.dup) do |result, (key, value)|
-        case key.to_sym
-        when :_include
-          result.include_modules(value)
-        when :_access
-          result.include_accessors(value)
-        else
-          result.store(key.to_sym, value.is_a?(Hash) ? deep_hashrize(value) : value)
-        end
-        result
-      end
-    end
+  def is_a?(const)
+    consts = [self.class]
+    consts << consts.last.superclass while consts.last.superclass
+    consts.include?(const)
+  end
+  alias kind_of? is_a?
+
+  def inspect
+    "<#{self.class.name} #{@data.inspect}>"
+  end
+
+  private
 
-    def deep_defaultize(hash)
-      self.class.defaults.each do |key, value|
-        case key.to_sym
-        when :_include
-          hash.include_modules(value)
-        when :_access
-          hash.include_accessors(value)
-        end
-      end
-
-      hash.each do |key, value|
-        deep_defaultize(value) if value.is_a?(Hash)
-      end
-
-      hash
+    def to_key(key)
+      key.respond_to?(:to_sym) ? key.to_sym : key
     end
 end

data/lib/hashr/core_ext/ruby/hash.rb

@@ -1,14 +1,4 @@
 class Hash
-  def slice(*keep_keys)
-    h = {}
-    keep_keys.each { |key| h[key] = fetch(key) if key?(key) }
-    h
-  end unless Hash.method_defined?(:slice)
-
-  def except(*less_keys)
-    slice(*keys - less_keys)
-  end unless Hash.method_defined?(:except)
-
   def deep_symbolize_keys
      symbolizer = lambda do |value|
       case value
@@ -24,15 +14,11 @@ class Hash
       result[(key.to_sym rescue key) || key] = symbolizer.call(value)
       result
     end
-  end
-
-  def deep_symbolize_keys!
-    replace(deep_symbolize_keys)
-  end
+  end unless instance_methods.include?(:deep_symbolize_keys)
 
   # deep_merge_hash! by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
   def deep_merge(other)
     merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
     merge(other, &merger)
-  end unless Hash.method_defined?(:deep_merge)
+  end unless instance_methods.include?(:deep_merge)
 end

data/lib/hashr/delegate/conditional.rb

@@ -0,0 +1,13 @@
+class Hashr
+  module Delegate
+    module Conditional
+      def method_missing(name, *args, &block)
+        if (args.any? || block) && @data.respond_to?(name)
+          @data.send(name, *args, &block)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/hashr/delegate/hash.rb

@@ -0,0 +1,48 @@
+class Hashr
+  module Delegation
+    module Hash
+      METHODS = [
+        :all?,
+        :any?,
+        :clear,
+        :delete,
+        :delete_if,
+        :detect,
+        :drop,
+        :drop_while,
+        :each,
+        :empty?,
+        :fetch,
+        :find,
+        :flat_map,
+        :grep,
+        :group_by,
+        :hash,
+        :inject,
+        :invert,
+        :is_a?,
+        :keep_if,
+        :key,
+        :key?,
+        :keys,
+        :length,
+        :map,
+        :merge,
+        :nil?,
+        :none?,
+        :one?,
+        :reduce,
+        :reject,
+        :select,
+        :size,
+        :value?,
+        :values,
+        :values_at
+      ]
+
+      METHODS.each do |name|
+        define_method(name) { |*args, &block| @data.send(name, *args, &block }
+      end
+    end
+  end
+end

data/lib/hashr/env.rb

@@ -0,0 +1,48 @@
+class Hashr
+  module Env
+    class Vars < Struct.new(:defaults, :namespace)
+      FALSE = [false, nil, 'false', 'nil', '']
+
+      def to_h
+        defaults.deep_merge(read_env(defaults, namespace.dup))
+      end
+
+      private
+
+        def read_env(defaults, namespace)
+          defaults.inject({}) do |result, (key, default)|
+            keys = namespace + [key]
+            value = default.is_a?(Hash) ? read_env(default, keys) : var(keys, default)
+            result.merge(key => value)
+          end
+        end
+
+        def var(keys, default)
+          key = keys.map(&:upcase).join('_')
+          value = ENV.fetch(key, default)
+          cast(value, default, keys)
+        end
+
+        def cast(value, default, keys)
+          case default
+          when Array
+            value.respond_to?(:split) ? value.split(',') : Array(value)
+          when true, false
+            not FALSE.include?(value)
+          else
+            value
+          end
+        end
+
+        def namespace
+          Array(super && super.upcase)
+        end
+    end
+
+    attr_accessor :env_namespace
+
+    def defaults
+      Vars.new(super, env_namespace).to_h
+    end
+  end
+end

data/lib/hashr/version.rb

@@ -1,3 +1,3 @@
-class Hashr < Hash
-  VERSION = '1.0.0'
+class Hashr < BasicObject
+  VERSION = '2.0.0.rc1'
 end

metadata

@@ -1,77 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: hashr
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0.rc1
 platform: ruby
 authors:
 - Sven Fuchs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-04 00:00:00.000000000 Z
-dependencies:
-- !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: test_declarative
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.0.2
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.0.2
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 5.0.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 5.0.0
+date: 2015-10-07 00:00:00.000000000 Z
+dependencies: []
 description: Simple Hash extension to make working with nested hashes (e.g. for configuration)
   easier and less error-prone.
-email: svenfuchs@artweb-design.de
+email: me@svenfuchs.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - Gemfile
-- Gemfile.lock
 - MIT-LICENSE
 - README.md
-- Rakefile
-- hashr.gemspec
 - lib/hashr.rb
 - lib/hashr/core_ext/ruby/hash.rb
-- lib/hashr/env_defaults.rb
+- lib/hashr/delegate/conditional.rb
+- lib/hashr/delegate/hash.rb
+- lib/hashr/env.rb
 - lib/hashr/version.rb
-- test/core_ext_test.rb
-- test/hashr_test.rb
-- test/test_helper.rb
 homepage: http://github.com/svenfuchs/hashr
 licenses: []
 metadata: {}
@@ -86,9 +40,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: "[none]"
 rubygems_version: 2.4.5

data/Gemfile.lock

@@ -1,21 +0,0 @@
-PATH
-  remote: .
-  specs:
-    hashr (0.0.22)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    minitest (5.3.4)
-    rake (0.9.2)
-    test_declarative (0.0.5)
-
-PLATFORMS
-  java
-  ruby
-
-DEPENDENCIES
-  hashr!
-  minitest (>= 5.0.0)
-  rake
-  test_declarative (>= 0.0.2)

data/Rakefile

@@ -1,12 +0,0 @@
-require 'rake'
-require 'rake/testtask'
-
-Rake::TestTask.new do |t|
-  t.libs << 'lib' << 'test'
-  # this currently does not work in rake 0.9.2, 0.9.3 will fix it
-  # t.pattern = 'test/**/*_test.rb'
-  t.test_files = FileList['test/**/*_test.rb']
-  t.verbose = false
-end
-
-task :default => :test

data/hashr.gemspec

@@ -1,23 +0,0 @@
-# encoding: utf-8
-
-$:.unshift File.expand_path('../lib', __FILE__)
-require 'hashr/version'
-
-Gem::Specification.new do |s|
-  s.name         = "hashr"
-  s.version      = Hashr::VERSION
-  s.authors      = ["Sven Fuchs"]
-  s.email        = "svenfuchs@artweb-design.de"
-  s.homepage     = "http://github.com/svenfuchs/hashr"
-  s.summary      = "Simple Hash extension to make working with nested hashes (e.g. for configuration) easier and less error-prone"
-  s.description  = "Simple Hash extension to make working with nested hashes (e.g. for configuration) easier and less error-prone."
-
-  s.files        = Dir['{lib/**/*,test/**/*,[A-Z]*}']
-  s.platform     = Gem::Platform::RUBY
-  s.require_path = 'lib'
-  s.rubyforge_project = '[none]'
-
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'test_declarative', '>=0.0.2'
-  s.add_development_dependency 'minitest', '>=5.0.0'
-end

data/lib/hashr/env_defaults.rb

@@ -1,31 +0,0 @@
-class Hashr < Hash
-  module EnvDefaults
-    attr_writer :env_namespace
-
-    def env_namespace=(env_namespace)
-      @env_namespace = [env_namespace.upcase]
-    end
-
-    def env_namespace
-      @env_namespace ||= []
-    end
-
-    def definition
-      deep_enverize(super)
-    end
-
-    protected
-
-      def deep_enverize(hash, nesting = env_namespace)
-        hash.each do |key, value|
-          nesting << key.to_s.upcase
-          hash[key] = case value
-          when Hash
-            deep_enverize(value, nesting)
-          else
-            ENV.fetch(nesting.join('_'), value)
-          end.tap { nesting.pop }
-        end
-      end
-  end
-end

data/test/core_ext_test.rb

@@ -1,28 +0,0 @@
-require 'test_helper'
-
-class CoreExtTest < Minitest::Test
-  test 'Hash#deep_symbolize_keys walks arrays, too' do
-    hash     = { 'foo' => [{ 'bar' => 'bar', 'baz' => { 'buz' => 'buz' } }] }
-    expected = { :foo  => [{ :bar  => 'bar', :baz  => { :buz  => 'buz' } }] }
-    assert_equal expected, hash.deep_symbolize_keys
-  end
-
-  test 'Hash#deep_symbolize_keys! replaces with deep_symbolize' do
-    hash     = { 'foo' => { 'bar' => 'baz' } }
-    expected = { :foo => { :bar => 'baz' } }
-    hash.deep_symbolize_keys!
-    assert_equal expected, hash
-  end
-
-  test 'Hash#slice returns a new hash containing the given keys' do
-    hash = { :foo => 'foo', :bar => 'bar', :baz => 'baz' }
-    expected = { :foo => 'foo', :bar => 'bar' }
-    assert_equal expected, hash.slice(:foo, :bar)
-  end
-
-  test 'Hash#slice does not explode on a missing key' do
-    hash = {}
-    expected = {}
-    assert_equal expected, hash.slice(:foo)
-  end
-end

data/test/hashr_test.rb

@@ -1,230 +0,0 @@
-require 'test_helper'
-
-class HashrTest < Minitest::Test
-  def teardown
-    Hashr.raise_missing_keys = false
-  end
-
-  test 'initialize takes nil' do
-    Hashr.new(nil)
-  end
-
-  test 'initialize raises an ArgumentError when given a string' do
-    assert_raises(ArgumentError) { Hashr.new("foo") }
-  end
-
-  test 'method access on an existing key returns the value' do
-    assert_equal 'foo', Hashr.new(:foo => 'foo').foo
-  end
-
-  test 'method access on a non-existing key returns nil when raise_missing_keys is false' do
-    Hashr.raise_missing_keys = false
-    assert_nil Hashr.new(:foo => 'foo').bar
-  end
-
-  test 'method access on a non-existing key raises an IndexError when raise_missing_keys is true' do
-    Hashr.raise_missing_keys = true
-    assert_raises(IndexError) { Hashr.new(:foo => 'foo').bar }
-  end
-
-  test 'method access on an existing nested key returns the value' do
-    assert_equal 'bar', Hashr.new(:foo => { :bar => 'bar' }).foo.bar
-  end
-
-  test 'method access on a non-existing nested key returns nil when raise_missing_keys is false' do
-    Hashr.raise_missing_keys = false
-    assert_nil Hashr.new(:foo => { :bar => 'bar' }).foo.baz
-  end
-
-  test 'method access on a non-existing nested key raises an IndexError when raise_missing_keys is true' do
-    Hashr.raise_missing_keys = true
-    assert_raises(IndexError) { Hashr.new(:foo => { :bar => 'bar' }).foo.baz }
-  end
-
-  test 'method access with a question mark returns true if the key has a value' do
-    assert_equal true, Hashr.new(:foo => { :bar => 'bar' }).foo.bar?
-  end
-
-  test 'method access with a question mark returns false if the key does not have a value' do
-    assert_equal false, Hashr.new(:foo => { :bar => 'bar' }).foo.baz?
-  end
-
-  test 'hash access is indifferent about symbols/strings (string data given, symbol keys used)' do
-    assert_equal 'bar', Hashr.new('foo' => { 'bar' => 'bar' })[:foo][:bar]
-  end
-
-  test 'hash access is indifferent about symbols/strings (symbol data given, string keys used)' do
-    assert_equal 'bar', Hashr.new(:foo => { :bar => 'bar' })['foo']['bar']
-  end
-
-  test 'mixing symbol and string keys in defaults and data' do
-    Symbolized  = Class.new(Hashr) { define :foo => 'foo' }
-    Stringified = Class.new(Hashr) { define 'foo' => 'foo' }
-    NoDefault   = Class.new(Hashr)
-
-    assert_equal 'foo', Symbolized.new.foo
-    assert_equal 'foo', Stringified.new.foo
-    assert_nil NoDefault.new.foo
-
-    assert_equal 'foo', Symbolized.new(:foo => 'foo').foo
-    assert_equal 'foo', Stringified.new(:foo => 'foo').foo
-    assert_equal 'foo', NoDefault.new(:foo => 'foo').foo
-
-    assert_equal 'foo', Symbolized.new('foo' => 'foo').foo
-    assert_equal 'foo', Stringified.new('foo' => 'foo').foo
-    assert_equal 'foo', NoDefault.new('foo' => 'foo').foo
-  end
-
-  test 'method assignment works' do
-    hashr = Hashr.new
-    hashr.foo = 'foo'
-    assert_equal 'foo', hashr.foo
-  end
-
-  test 'method using a string key works' do
-    hashr = Hashr.new
-    hashr['foo'] = 'foo'
-    assert_equal 'foo', hashr.foo
-  end
-
-  test 'using a symbol key works' do
-    hashr = Hashr.new
-    hashr[:foo] = 'foo'
-    assert_equal 'foo', hashr.foo
-  end
-
-  test 'respond_to? returns true if raise_missing_keys is off' do
-    Hashr.raise_missing_keys = false
-    hashr = Hashr.new
-    assert hashr.respond_to?(:foo)
-  end
-
-  test 'respond_to? returns false for missing keys if raise_missing_keys is on' do
-    Hashr.raise_missing_keys = true
-    hashr = Hashr.new
-    assert_equal false, hashr.respond_to?(:foo)
-  end
-
-  test 'respond_to? returns true for extant keys if raise_missing_keys is on' do
-    Hashr.raise_missing_keys = true
-    hashr = Hashr.new
-    hashr[:foo] = 'bar'
-    assert hashr.respond_to?(:foo)
-  end
-
-  test 'defining defaults' do
-    klass = Class.new(Hashr) do
-      define :foo => 'foo', :bar => { :baz => 'baz' }
-    end
-    assert_equal 'foo', klass.new.foo
-    assert_equal 'baz', klass.new.bar.baz
-  end
-
-  test 'defining different defaults on different classes ' do
-    foo = Class.new(Hashr) { define :foo => 'foo' }
-    bar = Class.new(Hashr) { define :bar => 'bar' }
-
-    assert_equal 'foo', foo.definition[:foo]
-    assert_equal 'bar', bar.definition[:bar]
-  end
-
-  test 'defining different env_namespaces on different classes ' do
-    foo = Class.new(Hashr) {extend Hashr::EnvDefaults; self.env_namespace = 'foo' }
-    bar = Class.new(Hashr) {extend Hashr::EnvDefaults; self.env_namespace = 'bar' }
-
-    assert_equal ['FOO'], foo.env_namespace
-    assert_equal ['BAR'], bar.env_namespace
-  end
-
-  test 'defaults to env vars' do
-    klass = Class.new(Hashr) do
-      extend Hashr::EnvDefaults
-      self.env_namespace = 'hashr'
-      define :foo => 'foo', :bar => { :baz => 'baz' }
-    end
-
-    ENV['HASHR_FOO'] = 'env foo'
-    ENV['HASHR_BAR_BAZ'] = 'env bar baz'
-
-    hashr = klass.new
-    assert_equal 'env foo', hashr.foo
-    assert_equal 'env bar baz', hashr.bar.baz
-
-    # ENV.delete('HASHR_FOO')
-    # ENV.delete('HASHR_BAR_BAZ')
-
-    # hashr = klass.new
-    # assert_equal 'foo', hashr.foo
-    # assert_equal 'bar baz', hashr.bar.baz
-  end
-
-  test 'a key :_include includes the given modules' do
-    klass = Class.new(Hashr) do
-      define :foo => { :_include => Module.new { def helper; 'helper'; end } }
-    end
-    hashr = klass.new(:foo => { 'helper' => 'foo' })
-    assert_equal 'helper', klass.new(:foo => { 'helper' => 'foo' }).foo.helper
-  end
-
-  test 'a key :_include includes the given modules (using defaults)' do
-    klass = Class.new(Hashr) do
-      define :foo => { :_include => Module.new { def helper; 'helper'; end } }
-    end
-    assert_equal 'helper', klass.new.foo.helper
-  end
-
-  test 'a key :_access includes an anonymous module with accessors' do
-    klass = Class.new(Hashr) do
-      define :foo => { :_access => [:key] }
-    end
-
-    assert_equal 'key', klass.new(:foo => { :key => 'key' }).foo.key
-  end
-
-  test 'defining defaults always also makes sure an accessor is used' do
-    klass = Class.new(Hashr) do
-      define :foo => { :default => 'default' }
-    end
-
-    assert_equal 'default', klass.new().foo.default
-  end
-
-  test 'all: allows to define :_include modules which will be included into all nested hashes' do
-    klass = Class.new(Hashr) do
-      default :_include => Module.new { def helper; 'helper'; end }
-    end
-    assert_equal 'helper', klass.new.helper
-    assert_equal 'helper', klass.new(:foo => { :bar => {} }).foo.bar.helper
-  end
-
-  test 'all: allows to define :_access which will include an anonymous module with accessors into all nested hashes' do
-    klass = Class.new(Hashr) do
-      default :_access => :key
-    end
-    assert_equal 'key', klass.new(:key => 'key').key
-    assert_equal 'key', klass.new(:foo => { :bar => { :key => 'key' } }).foo.bar.key
-  end
-
-  test 'anonymously overwriting core Hash methods' do
-    hashr = Hashr.new(:count => 5) do
-      def count
-        self[:count]
-      end
-    end
-    assert_equal 5, hashr.count
-  end
-
-  test 'to_hash converts the Hashr instance and all of its children to Hashes' do
-    hash = Hashr.new(:foo => { :bar => { :baz => 'baz' } }).to_hash
-
-    assert hash.instance_of?(Hash)
-    assert hash[:foo].instance_of?(Hash)
-    assert hash[:foo][:bar].instance_of?(Hash)
-  end
-
-  test 'set sets a dot separated path to nested hashes' do
-    hashr = Hashr.new(:foo => { :bar => 'bar' })
-    hashr.set('foo.baz', 'baz')
-    assert_equal 'baz', hashr.foo.baz
-  end
-end

data/test/test_helper.rb

@@ -1,4 +0,0 @@
-require 'bundler/setup'
-require 'minitest/autorun'
-require 'test_declarative'
-require 'hashr'