accessible 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ba9fa465e93322e6b9f7c2c37714e3c7cb96932
-  data.tar.gz: ad0299925c1b42408e90d184f1bbf49b531fd841
+  metadata.gz: efe7ae168ae14ba3851146219742ec4df0a012d2
+  data.tar.gz: c15fe8888c9c05f8c26a8da5912e0a5ce763d7b1
 SHA512:
-  metadata.gz: f81549a605ef57707f46b34e1a4f1cd212dc6defef01c91773045e3975c4922959a73f8f97327c2fa235c011053ec21bd4f4850b7dbc1030f85e93627bec3503
-  data.tar.gz: 8fa230b3242fa3ceb3a220d0d6cfa14ccd04751a35ce6a4f3dc4ed54f592e28c9dd8f66a524d85d5874c2c612f1dabac041e2dfdcafe4508312fa3ce88d6cc94
+  metadata.gz: a212b3ed52ba27dbfe4460a53f777103c120400634968e03bbdd0ac154a638dcd4da53d34410c2c7a99103b4f4ec089c0439cf337909d2403f71909dbafc1819
+  data.tar.gz: 354a11f3b2d58d8b2e97d9be7578231fdc835ff7ffd0388e544ae77122567f93f21614b22e7d6f0f0965467469d2161f73aa7a4bdbc0d5fb48075ba9bc267822

data/.gitignore

@@ -4,6 +4,7 @@
 .config
 .yardoc
 Gemfile.lock
+vendor/
 InstalledFiles
 _yardoc
 coverage

data/.ruby-version

@@ -1 +1 @@
-ruby-2.1.0
+2.1.0

data/README.md

@@ -1,10 +1,32 @@
 # Accessible
-[![Build Status](https://travis-ci.org/saclark/accessible.svg)](https://travis-ci.org/saclark/accessible) [![Coverage Status](https://coveralls.io/repos/saclark/accessible/badge.svg)](https://coveralls.io/r/saclark/accessible)
+[![Gem Version](https://badge.fury.io/rb/accessible.svg)](http://badge.fury.io/rb/accessible) [![Build Status](https://travis-ci.org/saclark/accessible.svg)](https://travis-ci.org/saclark/accessible) [![Coverage Status](https://coveralls.io/repos/saclark/accessible/badge.svg)](https://coveralls.io/r/saclark/accessible)
 
-A simple and flexible means of configuration for Ruby applications.
+A simple and flexible means of setting up configuration for Ruby applications.
 
-# Set up a configuration class
-Create a class in your project, include the `Accessible` module, and `load` a data source. You may then also `merge` in any number of additional data sources.
+# Usage
+```ruby
+MyConfig = Accessible.create do |config|
+  confg.load   'config/defaults.yml'
+  config.merge 'config/environments.yml', ENV['APP_ENV']
+  config.merge { :foo => 'bar' }
+end
+
+MyConfig.wake_me_up.before.you_go.go?
+# => true
+```
+
+# Documentation
+
+## Creating an "Accessible" class
+Assign the result of calling Accessible's `create` method, passing it a block in which you may `load`/`merge` any number of data sources.
+```ruby
+MyConfig = Accessible.create do |config|
+  confg.load 'config/defaults.yml'
+  config.merge 'config/environments/dev.yml'
+end
+```
+
+Alternatively, you can create a class, include the `Accessible` module, and `load`/`merge` your data.
 ```ruby
 class MyConfig
   include Accessible
@@ -14,59 +36,194 @@ class MyConfig
 end
 ```
 
-> Note: The `load` method will clear out any previously loaded data and replace it with the new data, whereas `merge` will merge in new data with previously loaded data (i.e. matching keys will be overridden and new keys will be added).
+## Methods
+The following class methods are available on any class created with/including Accessible.
 
-Both `load` and `merge` can take any of the following as a data source:
-- A filepath to a yaml file (i.e. `'config/default.yml'`)
-- A symbol representing the name of a yaml file found in `config/` (i.e. `:default`)
-- A raw hash of data (i.e. `{ :base_url => 'http://www.example.com' }`)
+* [`Accessor methods`](#user-content-accessor-methods)
+* [`#load`](#user-content-load)
+* [`#merge`](#user-content-merge)
+* [`#[]`](#user-content--)
+* [`#[]=`](#user-content--1)
+* [`#to_h`](#user-content-to_h)
 
-Both methods also accept an optional second parameter: the name of a specific key within the data source, whose data is the only data that should be loaded from the source. This is provided in case you prefer to maintain a single configuration file with default and environment specific data separated out under different keys.
+### Accessor methods
+When you load data into your class, getter and setter methods are defined on the class and recursively through the loaded data for each key. This way you can easily walk through your data:
+```ruby
+MyConfig.my_deeply.nested.data_is.accessible
+```
 
-# Access your configuration data
-There are two ways to access your configuration data.
+The main difference between accessor methods and [`[]`](#user-content--) and [`[]=`](#user-content--1) is that the accessor methods raise an error if a matching key does not exist.
 
-Let's imagine the following data is loaded:
+Examples:
 ```ruby
-{
-  :environments => {
-    :dev => {
-      :users => [
-        { :name => 'user0' },
-        { :name => 'user1' },
-        { :name => 'user2' }
-      ]
+MyConfig = Accessible.create do |config|
+  config.load({
+    :characters => {
+      :calvin => {
+        :alter_egos => [
+          { :name => 'Spaceman Spiff' },
+          { :name => 'Tracer Bullet' }
+        ]
+      }
     }
-  }
-}
+  })
+end
+
+MyConfig.characters.calvin.alter_egos[0].name
+# => 'Spaceman Spiff'
+MyConfig.characters[:calvin].alter_egos[0].name
+# => 'Spaceman Spiff'
+
+MyConfig[:characters].calvin.alter_egos[1].name = 'Stupendous Man'
+# => 'Stupendous Man'
+MyConfig.characters.calvin
+# => {
+#   :alter_egos => [
+#     { :name => 'Spaceman Spiff' },
+#     { :name => 'Stupendous Man' }
+#   ]
+# }
+
+MyConfig.does_not_exist
+# => NoMethodError
+MyConfig[:does_not_exist]
+# => nil
+
+MyConfig.does_not_exist = 'foo'
+# => NoMethodError
+MyConfig[:new_key] = 'a new value'
+# => 'a new value'
+MyConfig.new_key
+# => 'a new value'
+```
+
+Be careful with this one though. It is best to treat its return value as read-only due to surprising results when used in combination with `[]=` ([read why](#user-content--1)).
+
+### load
+`load(data_source, key = nil) -> data`
+
+Loads data into your class, wiping out any previously loaded data. It accepts a data source as well as an optional second parameter representing the name of a specific key within the data source from which data should be loaded.
+
+A data source can be any of the following:
+
+__Hash__  
+Loads the given hash:
+```ruby
+MyConfig.load({ :names => ['Calvin', 'Hobbes'] })
+```
+
+__String__  
+The given string should represent a file path to an existing yaml file to be loaded. An error will be throw if the file cannot be found:
+```ruby
+MyConfig.load('config/env_config.yml')
+```
+
+__Symbol__  
+The given symbol should represent the name of a `.yml` file located in a `/config` directory (relative to the working directory of the running process):
+```ruby
+MyConfig.load(:env_config)
 ```
 
-__Methods__
+Therefore, the following are equivalent
+```ruby
+# These are the same
+MyConfig.load(:env_config)
+MyConfig.load('config/env_config.yml')
+```
+
+### merge
+`merge(data_source, namespace = nil) -> data`
+
+Equivalent to [`load`](#user-content-load) with the exception that the data source is _merged_ (i.e. entries with duplicate keys are overwritten) with previously loaded data.
 
-You can get and set data by calling methods on your data set that match the name of the keys. If you try to get or set a key does not exist, an error will be thrown.
+### []
+`[key] -> value`
+
+Gets data from your class. Returns `nil` if the key does not exist, making this method useful for assigning default values in the absence of a key.
 ```ruby
-MyConfig.environments.dev.users[1].name # => 'user1'
+MyConfig.load({ :calvin => 'Spaceman Spiff' })
+
+MyConfig[:calvin]
+# => 'Spaceman Spiff'
 
-MyConfig.environments.dev.users[1].name = 'new_user1'
-MyConfig.environments.dev.users[1].name # => 'new_user1'
+MyConfig[:susie]
+# => nil
 
-MyConfig.does_not_exist # => NoMethodError
-MyConfig.does_not_exist = 'foo' # => NoMethodError
+person = MyConfig[:susie] || 'Hobbes'
+# => 'Hobbes'
 ```
 
-__Brackets__
+### []=
+`[key] = value -> value`
 
-You may also use the familiar `:[]` and `:[]=` methods, which behave the same as they do on any hash. `:[]` will return `nil` if the key does not exist, `:[]=` will create and set the key-value pair if the key does not exist. This makes `:[]` useful for providing default values.
+Sets data on your class.
 ```ruby
-MyConfig[:environments][:dev][:users][1][:name] # => 'user1'
+MyConfig.load({})
 
-MyConfig[:environments][:dev][:users][1][:name] = 'new_user1'
-MyConfig[:environments][:dev][:users][1][:name] # => 'new_user1'
+MyConfig[:calvin] = 'Spaceman Spiff'
+MyConfig[:calvin]
+# => 'Spaceman Spiff'
 
-MyConfig[:does_not_exist] || 'default' # => 'default'
-MyConfig[:new_key] = 'foo' # => `:new_key => 'foo'` pair is created
+MyConfig[:calvin] = 'Stupendous Man'
+MyConfig[:calvin]
+# => 'Stupendous Man'
 ```
 
----
+Note, however, __this is _not_ functionally equivalent to setting values on the result of calling `to_h` on your class or it's values.__ (e.g. `MyConfig.to_h[:foo] = 'bar'`).
+
+The subtle difference here is that using `[]=` directly on the class ensures that the appropriate accessor methods are defined on the class, it's data, and the value being set. Thus, the following works:
+```ruby
+MyConfig.load({ :calvin => { :superhero => 'Spaceman Spiff' } })
+
+MyConfig[:calvin] = { :superhero => 'Stupendous Man' }
+
+MyConfig.calvin
+# => { :superhero => 'Stupendous Man' }
+
+MyConfig.calvin.superhero
+# => 'Stupendous Man'
+
+MyConfig.calvin[:detective] = 'Tracer Bullet'
+MyConfig.calvin.detective
+# => 'Tracer Bullet'
+
+MyConfig[:susie] = 'Derkins'
+MyConfig.susie
+# => 'Derkins'
+```
 
-Check out the unit tests for the nitty-gritty of how things should work.
+Contrast this with the following behavior:
+```ruby
+MyConfig.load({ :calvin => { :superhero => 'Spaceman Spiff' } })
+
+MyConfig.to_h[:calvin] = { :superhero => 'Stupendous Man' }
+
+# The following only works by coincidence because an accessor for :calvin
+# was defined when the config data was initially loaded
+MyConfig.calvin
+# => { :superhero => 'Stupendous Man' }
+
+MyConfig.calvin.superhero
+# => NoMethodError: undefined method `superhero' for {:superhero=>"Stupendous Man"}:Hash
+
+MyConfig.calvin.to_h[:detective] = 'Tracer Bullet'
+MyConfig.calvin.detective
+# => NoMethodError: undefined method `detective' for {:superhero=>"Stupendous Man", :detective=>"Tracer Bullet"}:Hash
+
+MyConfig.to_h[:susie] = 'Derkins'
+MyConfig.susie
+# => NoMethodError: undefined method `susie' for MyConfig:Class
+```
+
+As you can see, being sure to only use `[]=` on your class and it's values _directly_ ensures the proper accessors are maintained. Setting values on the return value of `to_h` is a recipe for disaster.
+
+### to_h
+`to_h -> data`
+
+Returns all data loaded to your class as a hash.
+```ruby
+MyConfig.load({ :names => ['Calvin', 'Hobbes'] })
+
+MyConfig.to_h
+# => { :names => ['Calvin', 'Hobbes'] }
+```

data/lib/accessible.rb

@@ -8,24 +8,27 @@ module Accessible
     base.extend(ClassMethods)
   end
 
+  def self.create
+    klass = Class.new { extend ClassMethods }
+    yield klass if block_given?
+    klass
+  end
+
   module ClassMethods
     def to_h
       @data ||= {}
     end
 
-    def load(source, namespace = nil)
+    def load(data_source, namespace = nil)
       to_h.clear
-      merge(source, namespace)
+      merge(data_source, namespace)
     end
 
-    def merge(source, namespace = nil)
-      new_data = DataLoader.load_source(source)
+    def merge(data_source, namespace = nil)
+      source_data = DataLoader.load_source(data_source)
+      new_data = namespace ? source_data.fetch(namespace) : source_data
 
-      if namespace
-        @data = HashMethods.deep_merge(to_h, new_data.fetch(namespace))
-      else
-        @data = HashMethods.deep_merge(to_h, new_data)
-      end
+      @data = HashMethods.deep_merge(to_h, new_data)
 
       Accessorizers.accessorize_obj(self)
       Accessorizers.accessorize_data(to_h)
@@ -40,7 +43,7 @@ module Accessible
     def []=(key, new_value)
       Accessorizers.define_accessors(to_h, key)
       Accessorizers.define_accessors(self, key)
-      to_h[key] = Accessible::Accessorizers.accessorize_data(new_value)
+      to_h[key] = Accessorizers.accessorize_data(new_value)
     end
   end
 end

data/lib/accessible/version.rb

@@ -1,3 +1,3 @@
 module Accessible
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/test/accessible_test.rb

@@ -2,186 +2,36 @@ require_relative 'test_helper'
 
 class AccessibleTest < Minitest::Spec
   describe Accessible do
-    let(:config) { Class.new { include Accessible } }
-
-    describe '#to_h' do
-      it 'should create `@data` if it does not exist' do
-        config.instance_variable_defined?(:@data).must_equal(false)
-        config.to_h
-        config.instance_variable_defined?(:@data).must_equal(true)
-      end
-
-      it 'should assign an empty hash to `@data` if it does not exist' do
-        config.instance_variable_defined?(:@data).must_equal(false)
-        config.to_h
-        config.instance_variable_get(:@data).must_equal({})
-      end
-
-      it 'should return a Hash instance' do
-        config.to_h.must_be_instance_of(Hash)
-        config.load({ :adding => ['data'] })
-        config.to_h.must_be_instance_of(Hash)
-      end
-
-      it 'should return `@data`' do
-        config.to_h.must_equal(config.instance_variable_get(:@data))
-      end
+    before do
+      @expected_class_methods = Accessible::ClassMethods.public_instance_methods
     end
 
-    describe '#load' do
-      it 'should reassign `@data` to the given data' do
-        config.load({ :a => 'a' })
-        config.to_h.must_equal({ :a => 'a' })
-        config.load({ :b => 'b' })
-        config.to_h.must_equal({ :b => 'b' })
-      end
-
-      it 'should assign all data if no namespace given' do
-        config.load({ :a => 'a', :b => 'b' })
-        config.to_h.must_equal({ :a => 'a', :b => 'b' })
-      end
-
-      it 'should assign namespaced data if namespace given' do
-        config.load({ :a => 'a', :foo => { :b => 'b'} }, :foo)
-        config.to_h.must_equal({ :b => 'b' })
-      end
-
-      it 'should raise a KeyError if the given namespace is not found' do
-        proc do
-          config.load({ :a => 'a', :foo => { :b => 'b'} }, :bar)
-        end.must_raise(KeyError)
-      end
-    end
-
-    describe '#merge' do
-      it 'should accept a hash and load it' do
-        config.merge({ :a => 'a' })
-        config.to_h.must_equal({ :a => 'a' })
-      end
-
-      it 'should accept a symbol and load the corresponding config file' do
-        config.merge(:my_config)
-        config.to_h.must_equal({ 'data' => 'data from config/my_config.yml' })
-      end
-
-      it 'should accept a file path and load the file' do
-        config.merge('config/more_configs/my_config.yaml')
-        config.to_h.must_equal({ 'data' => 'data from config/more_configs/my_config.yaml' })
-      end
-
-      it 'should raise an error when not given a hash, symbol, or string' do
-        begin
-          config.merge(100)
-        rescue RuntimeError => e
-          e.message.must_equal("Invalid data source: 100")
+    describe '#included' do
+      it 'should extended the including class with `ClassMethods`' do
+        IncludedTest = Class.new { include Accessible }
+        @expected_class_methods.each do |method|
+          IncludedTest.must_respond_to(method)
         end
       end
-
-      it 'should not require an initial source to have been `#load`ed' do
-        config.merge({ :a => 'a' })
-        config.to_h.must_equal({ :a => 'a' })
-      end
-
-      it 'should mutate `@data`' do
-        config.load({ :foo => 'original' })
-        config.merge({ :foo => 'new' })
-        config.to_h.must_equal({ :foo => 'new' })
-      end
-
-      it 'should merge all data if no namespace given' do
-        config.load({ :a => 'a'})
-        config.merge({ :a => 'a', :b => 'b' })
-        config.to_h.must_equal({ :a => 'a', :b => 'b' })
-      end
-
-      it 'should merge namespaced data if namespace given' do
-        config.load({ :a => 'a' })
-        config.merge({ :foo => { :a => 'new a' }, :b => 'b' }, :foo)
-        config.to_h.must_equal({ :a => 'new a' })
-      end
-
-      it 'should raise a KeyError if the given namespace is not found' do
-        proc do
-          config.merge({ :a => 'a', :foo => { :b => 'b'} }, :bar)
-        end.must_raise(KeyError)
-      end
-
-      it 'should perform a deep merge' do
-        h1 = { :a => true, :b => { :c => [1, 2, 3] } }
-        h2 = { :a => false, :b => { :x => [3, 4, 5] } }
-
-        config.load(h1)
-        config.merge(h2)
-        config.to_h.must_equal({
-          :a => false,
-          :b => {
-            :c => [1, 2, 3],
-            :x => [3, 4, 5]
-          }
-        })
-      end
-
-      it 'should define acessors on `@data`' do
-        config.merge({ :a => 'a' })
-        config.to_h.singleton_methods.must_include(:a)
-        config.to_h.singleton_methods.must_include(:a=)
-      end
-
-      it 'should define accessors on the class' do
-        config.merge({ :a => 'a' })
-        config.singleton_methods.must_include(:a)
-        config.singleton_methods.must_include(:a=)
-      end
-
-      it 'should return a Hash instance' do
-        config.merge({}).must_be_instance_of(Hash)
-      end
-
-      it 'should return the result of calling #to_h after the merge' do
-        config.load({ :a => 'a' })
-        merge_result = config.merge({ :b => 'b' })
-        merge_result.must_equal(config.to_h)
-      end
-    end
-
-    describe '#[]' do
-      it 'should delegate to `@data`' do
-        config.load({ :a => 'a' })
-        config[:a].must_equal(config.instance_variable_get(:@data)[:a])
-        config[:b].must_equal(config.instance_variable_get(:@data)[:b])
-      end
     end
 
-    describe '#[]=' do
-      it 'should add the key value pair to `@data`' do
-        config[:a] = 'a'
-        config.instance_variable_get(:@data)[:a].must_equal('a')
-      end
-
-      it 'should define acessors on `@data` for the given key' do
-        config[:a] = 'a'
-        config.instance_variable_get(:@data).singleton_methods.must_include(:a)
-        config.instance_variable_get(:@data).singleton_methods.must_include(:a=)
-      end
-
-      it 'should define accessors on the class for the given key' do
-        config[:a] = 'a'
-        config.singleton_methods.must_include(:a)
-        config.singleton_methods.must_include(:a=)
-      end
-
-      it 'should define accessors on set values' do
-        config[:a] = { :foo => 'foo value' }
-        config.a.singleton_methods.must_include(:foo)
-        config.a.foo.must_equal('foo value')
-      end
-
-      it 'should delegate to `@data`' do
-        (config[:a] = 'a').must_equal(config.instance_variable_get(:@data)[:a] = 'a')
+    describe '#create' do
+      it 'should return a `Class` instance extended with `ClassMethods`' do
+        CreateTestConst1 = Accessible.create
+        CreateTestConst1.must_be_instance_of(Class)
+        @expected_class_methods.each do |method|
+          CreateTestConst1.must_respond_to(method)
+        end
       end
 
-      it 'should return the set value' do
-        config.send(:[]=, :a, 'a').must_equal('a')
+      it 'should yield the extended `Class` instance to a block if given' do
+        Accessible.create do |klass|
+          klass.name.must_be_nil
+          klass.must_be_instance_of(Class)
+          @expected_class_methods.each do |method|
+            klass.must_respond_to(method)
+          end
+        end
       end
     end
   end

data/test/class_methods_test.rb

@@ -0,0 +1,190 @@
+require_relative 'test_helper'
+
+class ClassMethodsTest < Minitest::Spec
+  describe Accessible::ClassMethods do
+    let(:config) { Class.new { extend Accessible::ClassMethods } }
+
+    describe '#to_h' do
+      it 'should create `@data` if it does not exist' do
+        config.instance_variable_defined?(:@data).must_equal(false)
+        config.to_h
+        config.instance_variable_defined?(:@data).must_equal(true)
+      end
+
+      it 'should assign an empty hash to `@data` if it does not exist' do
+        config.instance_variable_defined?(:@data).must_equal(false)
+        config.to_h
+        config.instance_variable_get(:@data).must_equal({})
+      end
+
+      it 'should return a Hash instance' do
+        config.to_h.must_be_instance_of(Hash)
+        config.load({ :adding => ['data'] })
+        config.to_h.must_be_instance_of(Hash)
+      end
+
+      it 'should return `@data`' do
+        config.to_h.must_equal(config.instance_variable_get(:@data))
+      end
+    end
+
+    describe '#load' do
+      it 'should reassign `@data` to the given data' do
+        config.load({ :a => 'a' })
+        config.to_h.must_equal({ :a => 'a' })
+        config.load({ :b => 'b' })
+        config.to_h.must_equal({ :b => 'b' })
+      end
+
+      it 'should assign all data if no namespace given' do
+        config.load({ :a => 'a', :b => 'b' })
+        config.to_h.must_equal({ :a => 'a', :b => 'b' })
+      end
+
+      it 'should assign namespaced data if namespace given' do
+        config.load({ :a => 'a', :foo => { :b => 'b'} }, :foo)
+        config.to_h.must_equal({ :b => 'b' })
+      end
+
+      it 'should raise a KeyError if the given namespace is not found' do
+        proc do
+          config.load({ :a => 'a', :foo => { :b => 'b'} }, :bar)
+        end.must_raise(KeyError)
+      end
+    end
+
+    describe '#merge' do
+      it 'should accept a hash and load it' do
+        config.merge({ :a => 'a' })
+        config.to_h.must_equal({ :a => 'a' })
+      end
+
+      it 'should accept a symbol and load the corresponding config file' do
+        config.merge(:my_config)
+        config.to_h.must_equal({ 'data' => 'data from config/my_config.yml' })
+      end
+
+      it 'should accept a file path and load the file' do
+        config.merge('config/more_configs/my_config.yaml')
+        config.to_h.must_equal({ 'data' => 'data from config/more_configs/my_config.yaml' })
+      end
+
+      it 'should raise an error when not given a hash, symbol, or string' do
+        begin
+          config.merge(100)
+        rescue RuntimeError => e
+          e.message.must_equal("Invalid data source: 100")
+        end
+      end
+
+      it 'should not require an initial source to have been `#load`ed' do
+        config.merge({ :a => 'a' })
+        config.to_h.must_equal({ :a => 'a' })
+      end
+
+      it 'should mutate `@data`' do
+        config.load({ :foo => 'original' })
+        config.merge({ :foo => 'new' })
+        config.to_h.must_equal({ :foo => 'new' })
+      end
+
+      it 'should merge all data if no namespace given' do
+        config.load({ :a => 'a'})
+        config.merge({ :a => 'a', :b => 'b' })
+        config.to_h.must_equal({ :a => 'a', :b => 'b' })
+      end
+
+      it 'should merge namespaced data if namespace given' do
+        config.load({ :a => 'a' })
+        config.merge({ :foo => { :a => 'new a' }, :b => 'b' }, :foo)
+        config.to_h.must_equal({ :a => 'new a' })
+      end
+
+      it 'should raise a KeyError if the given namespace is not found' do
+        proc do
+          config.merge({ :a => 'a', :foo => { :b => 'b'} }, :bar)
+        end.must_raise(KeyError)
+      end
+
+      it 'should perform a deep merge' do
+        h1 = { :a => true, :b => { :c => [1, 2, 3] } }
+        h2 = { :a => false, :b => { :x => [3, 4, 5] } }
+
+        config.load(h1)
+        config.merge(h2)
+        config.to_h.must_equal({
+          :a => false,
+          :b => {
+            :c => [1, 2, 3],
+            :x => [3, 4, 5]
+          }
+        })
+      end
+
+      it 'should define acessors on `@data`' do
+        config.merge({ :a => 'a' })
+        config.to_h.singleton_methods.must_include(:a)
+        config.to_h.singleton_methods.must_include(:a=)
+      end
+
+      it 'should define accessors on the class' do
+        config.merge({ :a => 'a' })
+        config.singleton_methods.must_include(:a)
+        config.singleton_methods.must_include(:a=)
+      end
+
+      it 'should return a Hash instance' do
+        config.merge({}).must_be_instance_of(Hash)
+      end
+
+      it 'should return the result of calling #to_h after the merge' do
+        config.load({ :a => 'a' })
+        merge_result = config.merge({ :b => 'b' })
+        merge_result.must_equal(config.to_h)
+      end
+    end
+
+    describe '#[]' do
+      it 'should delegate to `@data`' do
+        config.load({ :a => 'a' })
+        config[:a].must_equal(config.instance_variable_get(:@data)[:a])
+        config[:b].must_equal(config.instance_variable_get(:@data)[:b])
+      end
+    end
+
+    describe '#[]=' do
+      it 'should add the key value pair to `@data`' do
+        config[:a] = 'a'
+        config.instance_variable_get(:@data)[:a].must_equal('a')
+      end
+
+      it 'should define acessors on `@data` for the given key' do
+        config[:a] = 'a'
+        config.instance_variable_get(:@data).singleton_methods.must_include(:a)
+        config.instance_variable_get(:@data).singleton_methods.must_include(:a=)
+      end
+
+      it 'should define accessors on the class for the given key' do
+        config[:a] = 'a'
+        config.singleton_methods.must_include(:a)
+        config.singleton_methods.must_include(:a=)
+      end
+
+      it 'should define accessors on set values' do
+        config[:a] = { :foo => 'foo value' }
+        config.a.singleton_methods.must_include(:foo)
+        config.a.foo.must_equal('foo value')
+      end
+
+      it 'should delegate to `@data`' do
+        config.load({ :a => 'a' })
+        (config[:a] = 'new a').must_equal(config.instance_variable_get(:@data)[:a] = 'new a')
+        (config[:b] = 'b').must_equal(config.instance_variable_get(:@data)[:b] = 'b')
+      end
+
+      it 'should return the set value' do
+        config.send(:[]=, :a, 'a').must_equal('a')
+      end
+    end
+  end
+end

data/test/hash_methods_test.rb

@@ -25,7 +25,6 @@ class HashMethodsTest < Minitest::Spec
 
       it 'should not pass non-hash values to the block' do
         raise_if_executed = proc { raise('block was excuted') }
-        class SubclassedHash < Hash; end
         Accessible::HashMethods.each_hash('foo', &raise_if_executed)
         Accessible::HashMethods.each_hash(:foo, &raise_if_executed)
         Accessible::HashMethods.each_hash(100, &raise_if_executed)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: accessible
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Scott Clark
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-09 00:00:00.000000000 Z
+date: 2015-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -89,7 +89,6 @@ extra_rdoc_files: []
 files:
 - ".coveralls.yml"
 - ".gitignore"
-- ".ruby-gemset"
 - ".ruby-version"
 - ".travis.yml"
 - Gemfile
@@ -108,6 +107,7 @@ files:
 - lib/accessible/version.rb
 - test/accessible_test.rb
 - test/accessorizers_test.rb
+- test/class_methods_test.rb
 - test/data_loader_test.rb
 - test/hash_methods_test.rb
 - test/test_helper.rb
@@ -131,13 +131,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Simple and flexible ruby app configuration.
 test_files:
 - test/accessible_test.rb
 - test/accessorizers_test.rb
+- test/class_methods_test.rb
 - test/data_loader_test.rb
 - test/hash_methods_test.rb
 - test/test_helper.rb

data/.ruby-gemset

@@ -1 +0,0 @@
-Accessible