accessible 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7ba9fa465e93322e6b9f7c2c37714e3c7cb96932
+  data.tar.gz: ad0299925c1b42408e90d184f1bbf49b531fd841
+SHA512:
+  metadata.gz: f81549a605ef57707f46b34e1a4f1cd212dc6defef01c91773045e3975c4922959a73f8f97327c2fa235c011053ec21bd4f4850b7dbc1030f85e93627bec3503
+  data.tar.gz: 8fa230b3242fa3ceb3a220d0d6cfa14ccd04751a35ce6a4f3dc4ed54f592e28c9dd8f66a524d85d5874c2c612f1dabac041e2dfdcafe4508312fa3ce88d6cc94

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

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

data/.ruby-gemset

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

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1.0

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+cache: bundler
+
+rvm:
+  - 2.0.0
+  - 2.1.0
+  - 2.2.1
+
+script: 'bundle exec rake test'
+
+notifications:
+  email:
+    recipients:
+      - sclarkdev@gmail.com
+    on_failure: change
+    on_success: never

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Scott Clark
+
+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,72 @@
+# 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.
+
+# 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.
+```ruby
+class MyConfig
+  include Accessible
+
+  load 'config/defaults.yml'
+  merge 'config/environments/dev.yml'
+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).
+
+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' }`)
+
+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.
+
+# Access your configuration data
+There are two ways to access your configuration data.
+
+Let's imagine the following data is loaded:
+```ruby
+{
+  :environments => {
+    :dev => {
+      :users => [
+        { :name => 'user0' },
+        { :name => 'user1' },
+        { :name => 'user2' }
+      ]
+    }
+  }
+}
+```
+
+__Methods__
+
+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.
+```ruby
+MyConfig.environments.dev.users[1].name # => 'user1'
+
+MyConfig.environments.dev.users[1].name = 'new_user1'
+MyConfig.environments.dev.users[1].name # => 'new_user1'
+
+MyConfig.does_not_exist # => NoMethodError
+MyConfig.does_not_exist = 'foo' # => NoMethodError
+```
+
+__Brackets__
+
+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.
+```ruby
+MyConfig[:environments][:dev][:users][1][:name] # => 'user1'
+
+MyConfig[:environments][:dev][:users][1][:name] = 'new_user1'
+MyConfig[:environments][:dev][:users][1][:name] # => 'new_user1'
+
+MyConfig[:does_not_exist] || 'default' # => 'default'
+MyConfig[:new_key] = 'foo' # => `:new_key => 'foo'` pair is created
+```
+
+---
+
+Check out the unit tests for the nitty-gritty of how things should work.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler/gem_tasks'
+require 'coveralls/rake/task'
+require 'rake/testtask'
+
+Coveralls::RakeTask.new
+
+Rake::TestTask.new do |t|
+  t.pattern = "test/*_test.rb"
+end
+
+task :default => [:test]

data/accessible.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'accessible/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'accessible'
+  spec.version       = Accessible::VERSION
+  spec.authors       = ['Scott Clark']
+  spec.email         = ['sclarkdev@gmail.com']
+  spec.summary       = 'Simple and flexible ruby app configuration.'
+  spec.description   = 'A simple and flexible means of configuration for Ruby applications.'
+  spec.homepage      = 'https://github.com/saclark/accessible'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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.required_ruby_version = '>= 2.0.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake', '~> 10.1'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'coveralls', '~> 0.7'
+  spec.add_development_dependency 'minitest-reporters'
+end

data/config/more_configs/my_config.yaml

@@ -0,0 +1 @@
+data: 'data from config/more_configs/my_config.yaml'

data/config/my_config.yml

@@ -0,0 +1 @@
+data: 'data from config/my_config.yml'

data/config/sample.yml

@@ -0,0 +1,3 @@
+numbers:
+  integers:
+    :one: <%= 1 / 1 %>

data/lib/accessible/accessorizers.rb

@@ -0,0 +1,41 @@
+module Accessible
+  module Accessorizers
+    extend self
+
+    def accessorize_data(data)
+      HashMethods.each_hash(data) do |hash|
+        hash.each do |key, value|
+          define_accessors(hash, key)
+          accessorize_data(value)
+        end
+      end
+    end
+
+    def accessorize_obj(obj)
+      if !obj.respond_to?(:to_h)
+        raise(NotImplementedError, "Expected `#{obj}` to respond to `:to_h`")
+      end
+
+      obj.to_h.keys.each do |key|
+        define_accessors(obj, key)
+      end
+    end
+
+    def define_accessors(obj, key)
+      define_getter(obj, key)
+      define_setter(obj, key)
+    end
+
+    def define_getter(obj, key)
+      obj.define_singleton_method(key) do
+        obj.to_h.fetch(key)
+      end
+    end
+
+    def define_setter(obj, key)
+      obj.define_singleton_method("#{key}=") do |new_value|
+        obj.to_h[key] = Accessible::Accessorizers.accessorize_data(new_value)
+      end
+    end
+  end
+end

data/lib/accessible/data_loader.rb

@@ -0,0 +1,31 @@
+require 'yaml'
+require 'erb'
+
+module Accessible
+  module DataLoader
+    extend self
+
+    def evaluate_erb(text)
+      ERB.new(text).result
+    end
+
+    def load_yaml_erb(yaml_file)
+      contents = File.read(yaml_file)
+      evaluated_contents = evaluate_erb(contents)
+      YAML.load(evaluated_contents) || {}
+    end
+
+    def load_source(source)
+      case source
+      when Hash
+        source
+      when Symbol
+        load_yaml_erb("config/#{source}.yml")
+      when String
+        load_yaml_erb(source)
+      else
+        raise("Invalid data source: #{source}")
+      end
+    end
+  end
+end

data/lib/accessible/hash_methods.rb

@@ -0,0 +1,24 @@
+module Accessible
+  module HashMethods
+    extend self
+
+    def each_hash(data, &block)
+      case data
+      when Hash
+        block.call(data)
+      when Array
+        data.each { |elem| each_hash(elem, &block) }
+      end
+
+      data
+    end
+
+    def deep_merge(orig_data, new_data)
+      merger = proc do |key, v1, v2|
+        Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2
+      end
+
+      orig_data.merge(new_data, &merger)
+    end
+  end
+end

data/lib/accessible/version.rb

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

data/lib/accessible.rb

@@ -0,0 +1,46 @@
+require 'accessible/accessorizers'
+require 'accessible/data_loader'
+require 'accessible/hash_methods'
+require 'accessible/version'
+
+module Accessible
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def to_h
+      @data ||= {}
+    end
+
+    def load(source, namespace = nil)
+      to_h.clear
+      merge(source, namespace)
+    end
+
+    def merge(source, namespace = nil)
+      new_data = DataLoader.load_source(source)
+
+      if namespace
+        @data = HashMethods.deep_merge(to_h, new_data.fetch(namespace))
+      else
+        @data = HashMethods.deep_merge(to_h, new_data)
+      end
+
+      Accessorizers.accessorize_obj(self)
+      Accessorizers.accessorize_data(to_h)
+
+      to_h
+    end
+
+    def [](key)
+      to_h[key]
+    end
+
+    def []=(key, new_value)
+      Accessorizers.define_accessors(to_h, key)
+      Accessorizers.define_accessors(self, key)
+      to_h[key] = Accessible::Accessorizers.accessorize_data(new_value)
+    end
+  end
+end

data/test/accessible_test.rb

@@ -0,0 +1,188 @@
+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
+    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[:a] = 'a').must_equal(config.instance_variable_get(:@data)[:a] = 'a')
+      end
+
+      it 'should return the set value' do
+        config.send(:[]=, :a, 'a').must_equal('a')
+      end
+    end
+  end
+end

data/test/accessorizers_test.rb

@@ -0,0 +1,203 @@
+require_relative 'test_helper'
+
+class AccessorizersTest < Minitest::Spec
+  describe Accessible::Accessorizers do
+    let(:obj) do
+      Class.new do
+        def self.to_h
+          @data
+        end
+
+        def self.to_h=(data)
+          @data = data
+        end
+      end
+    end
+
+    describe '#accessorize_data' do
+      before do
+        @hash = {
+          :complex => {
+            :nested => {
+              :array => [
+                { :hash_0 => 'hash_0 value' },
+                { :hash_1 => [ { :inner => 'inner value' } ] }
+              ]
+            }
+          }
+        }
+      end
+
+      it 'should recursively define getters on the hash for every key' do
+        Accessible::Accessorizers.accessorize_data(@hash)
+        @hash.complex.must_equal(@hash[:complex])
+        @hash.complex.nested.array.must_equal(@hash[:complex][:nested][:array])
+        @hash.complex.nested.array[0].hash_0.must_equal('hash_0 value')
+        @hash.complex.nested.array[1].hash_1[0].inner.must_equal('inner value')
+      end
+
+      it 'should recursively define setters on the hash for every key' do
+        Accessible::Accessorizers.accessorize_data(@hash)
+        @hash.complex.nested.array[1].hash_1[0].inner = 'new inner value'
+        @hash.complex.nested.array[1].hash_1[0].inner.must_equal('new inner value')
+        @hash.complex = 'new value'
+        @hash.complex.must_equal('new value')
+      end
+
+      it 'should distinguish nested keys' do
+        data = {
+          :languages => {
+            :ruby => {
+              :typed => 'dynamic'
+            },
+            :haskell => {
+              :typed => 'static'
+            }
+          }
+        }
+        Accessible::Accessorizers.accessorize_data(data)
+        data.languages.ruby.typed.must_equal('dynamic')
+        data.languages.haskell.typed.must_equal('static')
+      end
+
+      it 'should allow non-standard or complex method names' do
+        data = { 'key with spaces' => 'key with spaces value' }
+        Accessible::Accessorizers.accessorize_data(data)
+        data.must_respond_to(:"key with spaces")
+      end
+
+      it 'should override conflicting methods' do
+        hash = { :class => 'overwritten' }
+        Accessible::Accessorizers.accessorize_data(hash)
+        hash.class.must_equal('overwritten')
+      end
+    end
+
+    describe '#accessorize_obj' do
+      it 'should define getters on the class for all first tier keys' do
+        obj.to_h = { :a => { :b => 'b' }, :c => 'c' }
+        Accessible::Accessorizers.accessorize_obj(obj)
+        obj.a.must_equal({ :b => 'b' })
+        obj.c.must_equal('c')
+        obj.wont_respond_to(:b)
+      end
+
+      it 'should define getters equivalent to calling `:fetch` on `@data` with the same key' do
+        obj.to_h = { :foo => 'foo value'}
+        Accessible::Accessorizers.accessorize_obj(obj)
+        (obj.to_h.fetch(:foo)).must_equal(obj.foo)
+
+        obj.to_h.delete(:foo)
+        proc { obj.foo }.must_raise(KeyError)
+      end
+
+      it 'should define setters on the class for all first tier keys' do
+        obj.to_h = { :a => { :b => 'b' }, :c => 'c' }
+        Accessible::Accessorizers.accessorize_obj(obj)
+
+        obj.a = 'new a value'
+        obj.a.must_equal('new a value')
+
+        obj.c = 'new c value'
+        obj.c.must_equal('new c value')
+
+        obj.wont_respond_to(:b=)
+      end
+
+      it 'should define accessors on values set after initial load' do
+        obj.to_h = { :foo => 'foo value' }
+        Accessible::Accessorizers.accessorize_obj(obj)
+        obj.foo = { :new_value => 'new value' }
+
+        obj.to_h[:foo].must_respond_to(:new_value)
+        obj.to_h[:foo].must_respond_to(:new_value=)
+      end
+
+      it 'should define setters equivalent using `:[]=`' do
+        obj.to_h = { :foo => 'foo value' }
+        Accessible::Accessorizers.accessorize_obj(obj)
+
+        (obj.foo = 'new foo value').must_equal(obj.to_h[:foo] = 'new foo value')
+
+        obj.to_h.delete(:foo)
+        obj.foo = 'restored foo'
+        obj.foo.must_equal('restored foo')
+      end
+
+      it 'should raise an error if the object does not respond to `:to_h`' do
+        proc { Accessible::Accessorizers.accessorize_obj(:foo) }.must_raise(NotImplementedError)
+
+        begin
+          Accessible::Accessorizers.accessorize_obj(:foo)
+        rescue NotImplementedError => e
+          e.message.must_equal("Expected `foo` to respond to `:to_h`")
+        end
+      end
+    end
+
+    describe '#define_accessors' do
+      it 'should' do
+        skip('pending')
+      end
+    end
+
+    describe '#define_getter' do
+      it 'should define a getter for the given key' do
+        hash = { :foo => 'foo value' }
+        Accessible::Accessorizers.define_getter(hash, :foo)
+        hash.foo.must_equal('foo value')
+      end
+
+      it 'should define a getter only on the instance' do
+        hash = { :foo => 'foo value' }
+        Accessible::Accessorizers.define_getter(hash, :foo)
+        {}.wont_respond_to(:foo)
+      end
+
+      it 'should be the same as calling :fetch on the hash with the same key' do
+        hash = { :foo => 'foo value'}
+
+        Accessible::Accessorizers.define_getter(hash, :foo)
+        (hash.fetch(:foo)).must_equal(hash.foo)
+
+        hash.delete(:foo)
+        proc { hash.foo }.must_raise(KeyError)
+      end
+    end
+
+    describe '#define_setter' do
+      it 'should define a setter for the given key' do
+        hash = { :foo => 'foo value' }
+        Accessible::Accessorizers.define_setter(hash, :foo)
+        hash.foo = 'new foo value'
+        hash[:foo].must_equal('new foo value')
+      end
+
+      it 'should define a setter only on the instance' do
+        hash = { :foo => 'foo value' }
+        Accessible::Accessorizers.define_setter(hash, :foo)
+        {}.wont_respond_to(:foo=)
+      end
+
+      it 'should define accessors on set values' do
+        hash = { :foo => 'foo value' }
+        Accessible::Accessorizers.define_setter(hash, :foo)
+        hash.foo = { :new_value => 'new value' }
+
+        hash[:foo].must_respond_to(:new_value)
+        hash[:foo].must_respond_to(:new_value=)
+      end
+
+      it 'should be the same as calling :[]= with the same key and value' do
+        hash = { :foo => 'foo value'}
+
+        Accessible::Accessorizers.define_setter(hash, :foo)
+        (hash.foo = 'new foo value').must_equal(hash[:foo] = 'new foo value')
+
+        Accessible::Accessorizers.define_setter(hash, :bar)
+        hash.bar = 'bar'
+        hash[:bar].must_equal('bar')
+      end
+    end
+  end
+end

data/test/data_loader_test.rb

@@ -0,0 +1,57 @@
+require_relative 'test_helper'
+
+class DataLoaderTest < Minitest::Spec
+  describe Accessible::DataLoader do
+    before do
+      @file_path = 'config/sample.yml'
+    end
+
+    describe '#evaluate_erb' do
+      it 'should return the erb evaluated string' do
+        contents = File.read(@file_path)
+        Accessible::DataLoader.evaluate_erb(contents).must_equal("numbers:\n  integers:\n    :one: 1\n")
+      end
+    end
+
+    describe '#load_yaml_erb' do
+      it 'should return the file contents as a hash' do
+        Accessible::DataLoader.load_yaml_erb(@file_path).must_be_instance_of(Hash)
+      end
+
+      it 'should return file data as a hash with keys unaltered' do
+        Accessible::DataLoader.load_yaml_erb(@file_path)['numbers']['integers'][:one].wont_be_nil
+      end
+
+      it 'should return an empty hash if the file is empty' do
+        Accessible::DataLoader.load_yaml_erb('config/empty.yml').must_equal({})
+      end
+    end
+
+    describe '#load_source' do
+      it 'should accept a hash and return it' do
+        data = Accessible::DataLoader.load_source({ :a => 'a' })
+        data.must_equal({ :a => 'a' })
+      end
+
+      it 'should accept a symbol and return the corresponding file data' do
+        data = Accessible::DataLoader.load_source(:my_config)
+        data.must_equal({ 'data' => 'data from config/my_config.yml' })
+      end
+
+      it 'should accept a file path and return the file data' do
+        data = Accessible::DataLoader.load_source('config/more_configs/my_config.yaml')
+        data.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
+        proc { Accessible::DataLoader.load_source(100) }.must_raise(RuntimeError)
+
+        begin
+          Accessible::DataLoader.load_source(100)
+        rescue RuntimeError => e
+          e.message.must_equal("Invalid data source: 100")
+        end
+      end
+    end
+  end
+end

data/test/hash_methods_test.rb

@@ -0,0 +1,61 @@
+require_relative 'test_helper'
+
+class HashMethodsTest < Minitest::Spec
+  describe Accessible::HashMethods do
+    describe '#each_hash' do
+      it 'should execute the block on the given value if it is a hash' do
+        begin
+          Accessible::HashMethods.each_hash({}) do |hash|
+            raise(hash.to_s)
+          end
+        rescue RuntimeError => e
+          e.message.must_equal('{}')
+        end
+      end
+
+      it 'should recursively execute the block on hashes nested in arrays' do
+        begin
+          Accessible::HashMethods.each_hash([{}]) do |hash|
+            raise(hash.to_s)
+          end
+        rescue RuntimeError => e
+          e.message.must_equal('{}')
+        end
+      end
+
+      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)
+        Accessible::HashMethods.each_hash(nil, &raise_if_executed)
+        Accessible::HashMethods.each_hash(true, &raise_if_executed)
+        Accessible::HashMethods.each_hash([], &raise_if_executed)
+        Accessible::HashMethods.each_hash(proc{}, &raise_if_executed)
+        Accessible::HashMethods.each_hash(Accessible, &raise_if_executed)
+      end
+
+      it 'should return the value it was given' do
+        result = Accessible::HashMethods.each_hash({ :a => 'a' }) { :foo }
+        result.must_equal({ :a => 'a' })
+      end
+    end
+
+    describe '#deep_merge' do
+      it 'should merge neseted hashes' do
+        hash_1 = { :a => false, :b => "b", :c => { :c1 => "c1", :c2 => "c2", :c3 => { :d1 => "d1" } } }
+        hash_2 = { :a => 1, :c => { :c1 => 2, :c3 => { :d2 => "d2" } } }
+        expected = { :a => 1, :b => "b", :c => { :c1 => 2, :c2 => "c2", :c3 => { :d1 => "d1", :d2 => "d2" } } }
+
+        Accessible::HashMethods.deep_merge(hash_1, hash_2).must_equal(expected)
+      end
+    end
+
+    describe '#symbolize_keys' do
+      it 'should' do
+        skip('pending')
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+require 'simplecov'
+require 'coveralls'
+require 'minitest/autorun'
+require 'minitest/reporters'
+require 'minitest/spec'
+
+Minitest::Reporters.use!(Minitest::Reporters::SpecReporter.new)
+SimpleCov.formatter = SimpleCov::Formatter::HTMLFormatter
+SimpleCov.start { add_filter '/test/' }
+Coveralls.wear!
+
+require 'accessible'

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: accessible
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Scott Clark
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  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 simple and flexible means of configuration for Ruby applications.
+email:
+- sclarkdev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".coveralls.yml"
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- accessible.gemspec
+- config/empty.yml
+- config/more_configs/my_config.yaml
+- config/my_config.yml
+- config/sample.yml
+- lib/accessible.rb
+- lib/accessible/accessorizers.rb
+- lib/accessible/data_loader.rb
+- lib/accessible/hash_methods.rb
+- lib/accessible/version.rb
+- test/accessible_test.rb
+- test/accessorizers_test.rb
+- test/data_loader_test.rb
+- test/hash_methods_test.rb
+- test/test_helper.rb
+homepage: https://github.com/saclark/accessible
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Simple and flexible ruby app configuration.
+test_files:
+- test/accessible_test.rb
+- test/accessorizers_test.rb
+- test/data_loader_test.rb
+- test/hash_methods_test.rb
+- test/test_helper.rb