yamload 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cdaf18e91f87fa915da696af9e2d41d171313512
-  data.tar.gz: 93ed1e30105693344286755d3bd04db2f22d9032
+  metadata.gz: 831e871ab4c0d0dbe55c9465bad82ba229730d87
+  data.tar.gz: 52dbd15b58e1adc00928261b9490da7761bbc607
 SHA512:
-  metadata.gz: 8be6ad15459108a185e1d68c256e8174a7f7f2e92579c057184fcd28d94dbf9cdd4ec04674cb15e8e9fc0051c60d0d748e3ab67eafe52ed0d58ea07a494b4310
-  data.tar.gz: 2d2ce03a03a7818d5195e5d1efe8eaf0c1c1439ab6bbd41dff97587cc178758a31ee4c1f3b5a125fad41df3706ddbd2453be8c6b5ac84f933d00a2104737d147
+  metadata.gz: 36e4c622fabf2326406df940a8caa541268372cbedc3f1b829b3fa3fdbf9b5766d1d8322817cab0fce255c936b3e75df49ed09fd8312d720d1a35229849c47a9
+  data.tar.gz: ca1f592c5e75d2f1a34aa12385a9b8b16dd333bbc6d1f99d550ddf9a8569ae2475a3000eac9301ccc1354ad2c10ed6b37492b2031a32dea9c4963fc02e722ac4

data/CHANGELOG.md

@@ -0,0 +1,48 @@
+## 0.1.0 (2015-02-17)
+
+  - use proper semantic versioning (semver.org)
+
+Features:
+
+  - support loading valid yml files which don't define a hash
+  - deprecates `Yamload::Loader#loaded_hash` in favour of `Yamload::Loader#content`
+
+## 0.0.6 (2015-02-04)
+
+Bugfixes:
+
+  - check for directory existence
+
+## 0.0.5 (2015-02-04)
+
+Bugfixes:
+
+  - check for file existence
+  - check for validity of file contents
+
+## 0.0.4 (2015-02-04)
+
+Features:
+
+  - implement `Yamload::Loader#exist?` to check for file presence
+
+## 0.0.3 (2015-02-04)
+
+Features:
+
+  - use a faster schema validation engine with no dependencies
+
+## 0.0.2 (2015-02-04)
+
+Features:
+
+  - freeze the loaded hash
+
+## 0.0.1 (2015-02-04)
+
+Features:
+
+  - load valid yml files defining a hash
+  - conversion of loaded hash to immutable object
+  - default values
+  - schema validation

data/README.md

@@ -44,7 +44,7 @@ Load YAML files from the directory and access keys
 ```ruby
 # Load config/test.yml
 loader = Yamload::Loader.new(:test)
-loader.loaded_hash('attribute')
+loader.content('attribute')
 # => true
 loader.obj.attribute
 # => true

data/lib/yamload/conversion/array.rb

@@ -0,0 +1,20 @@
+module Yamload
+  module Conversion
+    class Array
+      def initialize(array)
+        fail ArgumentError, "#{array} is not an Array" unless array.is_a?(::Array)
+        @array = array
+      end
+
+      def to_immutable
+        convert_elements.freeze
+      end
+
+      private
+
+      def convert_elements
+        @array.map { |element| Object.new(element).to_immutable }
+      end
+    end
+  end
+end

data/lib/yamload/conversion/hash.rb

@@ -0,0 +1,33 @@
+require 'facets/hash/rekey'
+require 'anima'
+
+module Yamload
+  module Conversion
+    class Hash
+      def initialize(hash)
+        fail ArgumentError, "#{array} is not a Hash" unless hash.is_a?(::Hash)
+        @hash = hash.rekey
+      end
+
+      def to_immutable
+        immutable_objects_factory.new(converted_hash)
+      end
+
+      private
+
+      def immutable_objects_factory
+        anima = Anima.new(*@hash.keys)
+        Class.new do
+          include Adamantium
+          include anima
+        end
+      end
+
+      def converted_hash
+        @hash.map.with_object({}) { |(key, value), hash|
+          hash[key] = Object.new(value).to_immutable
+        }
+      end
+    end
+  end
+end

data/lib/yamload/conversion/object.rb

@@ -0,0 +1,29 @@
+require 'facets/object/dup'
+require 'ice_nine'
+
+module Yamload
+  module Conversion
+    class Object
+      def initialize(object)
+        @object = object.clone? ? object.clone : object
+      end
+
+      def to_immutable
+        convert
+      end
+
+      private
+
+      def convert
+        case @object
+        when ::Array
+          Array.new(@object).to_immutable
+        when ::Hash
+          Hash.new(@object).to_immutable
+        else
+          IceNine.deep_freeze!(@object)
+        end
+      end
+    end
+  end
+end

data/lib/yamload/conversion.rb

@@ -0,0 +1,8 @@
+module Yamload
+  module Conversion
+  end
+end
+
+require 'yamload/conversion/array'
+require 'yamload/conversion/hash'
+require 'yamload/conversion/object'

data/lib/yamload/defaults/hash.rb

@@ -0,0 +1,26 @@
+require 'facets/hash/deep_merge'
+
+module Yamload
+  module Defaults
+    class Hash
+      attr_reader :defaults
+
+      def initialize(defaults = nil)
+        self.defaults = defaults
+      end
+
+      def defaults=(defaults)
+        unless defaults.is_a?(::Hash) || defaults.nil?
+          fail ArgumentError, "#{defaults} is not a hash"
+        end
+        @defaults = defaults
+      end
+
+      def merge(hash)
+        return hash if @defaults.nil?
+        fail ArgumentError, "#{hash} is not a hash" unless hash.is_a?(::Hash)
+        @defaults.deep_merge(hash)
+      end
+    end
+  end
+end

data/lib/yamload/defaults.rb

@@ -0,0 +1,6 @@
+module Yamload
+  module Defaults
+  end
+end
+
+require 'yamload/defaults/hash'

data/lib/yamload/loader.rb

@@ -1,76 +1,84 @@
 require 'yaml'
-require 'classy_hash'
-require 'facets/hash/deep_merge'
+require 'ice_nine'
+require 'yamload/loading'
+require 'yamload/conversion'
+require 'yamload/defaults'
+require 'yamload/validation'
 
 module Yamload
   class Loader
     def initialize(file, dir = Yamload.dir)
-      @file = file
-      @dir  = dir
+      @loader = Loading::Yaml.new(file, dir)
     end
 
     def exist?
-      File.exist?(filepath)
+      @loader.exist?
     end
 
+    # <b>DEPRECATED:</b> Please use <tt>content</tt> instead.
     def loaded_hash
-      @loaded_hash ||= IceNine.deep_freeze(defaults.deep_merge(load))
+      warn '[DEPRECATION] `loaded_hash` is deprecated.  Please use `content` instead.'
+      content
+    end
+
+    def content
+      @content ||= IceNine.deep_freeze(content_with_defaults)
     end
 
     def obj
-      @immutable_obj ||= HashToImmutableObject.new(loaded_hash).call
+      @immutable_obj ||= Conversion::Object.new(content).to_immutable
     end
 
     def reload
-      @loaded_hash = @immutable_obj = nil
-      loaded_hash
+      @content = @immutable_obj = nil
+      @loader.reload
+      content
     end
 
-    attr_writer :schema
+    def defaults=(defaults)
+      defaults_merger.defaults = defaults
+    end
 
-    def schema
-      @schema ||= {}
+    def defaults
+      defaults_merger.defaults
     end
 
-    attr_writer :defaults
+    def schema=(schema)
+      validator.schema = schema
+    end
 
-    def defaults
-      @defaults ||= {}
+    def schema
+      validator.schema
     end
 
     def valid?
-      validate!
-      true
-    rescue SchemaError
-      false
+      validation_result.valid?
     end
 
     def validate!
-      @error = nil
-      ClassyHash.validate(loaded_hash, schema)
-    rescue RuntimeError => e
-      @error = e.message
-      raise SchemaError, @error
+      fail SchemaError, validation_result.error unless validation_result.valid?
     end
 
     def error
-      return nil if valid?
-      @error
+      validation_result.error
     end
 
     private
 
-    def load
-      fail IOError, "#{@file}.yml could not be found" unless exist?
-      YAML.load_file(filepath).tap do |hash|
-        fail IOError, "#{@file}.yml is invalid" unless hash.is_a? Hash
-      end
+    def content_with_defaults
+      defaults_merger.merge(@loader.content)
+    end
+
+    def defaults_merger
+      @defaults_merger ||= Defaults::Hash.new
+    end
+
+    def validator
+      @validator ||= Validation::Hash.new
     end
 
-    def filepath
-      fail IOError, 'No yml files directory specified' if @dir.nil?
-      fail IOError, "#{@dir} is not a valid directory" unless File.directory?(@dir)
-      File.join(@dir, "#{@file}.yml")
+    def validation_result
+      validator.validate(content)
     end
   end
 

data/lib/yamload/loading/yaml.rb

@@ -0,0 +1,41 @@
+require 'facets/kernel'
+require 'ice_nine'
+
+module Yamload
+  module Loading
+    class Yaml
+      def initialize(file, dir)
+        @file = file
+        @dir  = dir
+      end
+
+      def exist?
+        File.exist?(filepath)
+      end
+
+      def content
+        @content ||= IceNine.deep_freeze(load)
+      end
+
+      def reload
+        @content = @immutable_obj = nil
+        content
+      end
+
+      private
+
+      def load
+        fail IOError, "#{@file}.yml could not be found" unless exist?
+        YAML.load_file(filepath).tap do |content|
+          fail IOError, "#{@file}.yml is blank" if content.blank?
+        end
+      end
+
+      def filepath
+        fail IOError, 'No yml files directory specified' if @dir.nil?
+        fail IOError, "#{@dir} is not a valid directory" unless File.directory?(@dir)
+        File.join(@dir, "#{@file}.yml")
+      end
+    end
+  end
+end

data/lib/yamload/loading.rb

@@ -0,0 +1,6 @@
+module Yamload
+  module Loading
+  end
+end
+
+require 'yamload/loading/yaml'

data/lib/yamload/validation/hash.rb

@@ -0,0 +1,28 @@
+require 'classy_hash'
+
+module Yamload
+  module Validation
+    class Hash
+      attr_reader :schema
+
+      def initialize(schema = nil)
+        self.schema = schema
+      end
+
+      def schema=(schema)
+        unless schema.is_a?(::Hash) || schema.nil?
+          fail ArgumentError, "#{schema} is not a hash"
+        end
+        @schema = schema
+      end
+
+      def validate(hash)
+        fail ArgumentError, "#{hash} is not a hash" unless hash.is_a?(::Hash)
+        ClassyHash.validate(hash, @schema) unless @schema.nil?
+        Result.new(true)
+      rescue RuntimeError => e
+        Result.new(false, e.message)
+      end
+    end
+  end
+end

data/lib/yamload/validation/result.rb

@@ -0,0 +1,16 @@
+module Yamload
+  module Validation
+    class Result
+      attr_reader :error
+
+      def initialize(valid, error = nil)
+        @valid = valid
+        @error = error
+      end
+
+      def valid?
+        @valid
+      end
+    end
+  end
+end

data/lib/yamload/validation.rb

@@ -0,0 +1,7 @@
+module Yamload
+  module Validation
+  end
+end
+
+require 'yamload/validation/hash'
+require 'yamload/validation/result'

data/lib/yamload/version.rb

@@ -1,3 +1,3 @@
 module Yamload
-  VERSION = '0.0.6'
+  VERSION = '0.1.0'
 end

data/lib/yamload.rb

@@ -7,4 +7,3 @@ module Yamload
 end
 
 require 'yamload/loader'
-require 'yamload/hash_to_immutable_object'

data/spec/conversion_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+require 'yamload/conversion'
+
+describe Yamload::Conversion do
+  let(:number)  { 42 }
+  let(:string)  { 'a string' }
+  let(:array)   { [number, string] }
+  let(:hash) {
+    {
+      string:   string,
+      array:    array,
+      sub_hash: { something: 'else' }
+    }
+  }
+
+  subject!(:immutable_object) { converter.to_immutable }
+
+  context 'when converting a number' do
+    let(:converter) { Yamload::Conversion::Object.new(number) }
+    specify { is_expected.to eq number }
+  end
+
+  context 'when converting a string' do
+    let(:converter) { Yamload::Conversion::Object.new(string) }
+    specify { expect(string).not_to be_frozen }
+    specify { is_expected.to be_frozen }
+    specify { is_expected.to eq string }
+  end
+
+  context 'when converting an array' do
+    let(:converter) { Yamload::Conversion::Object.new(array) }
+    specify { expect(array).not_to be_frozen }
+    specify { is_expected.to be_frozen }
+    specify { is_expected.to be_an Array }
+    specify { expect(immutable_object.size).to eq 2 }
+    specify { expect(immutable_object[0]).to eq number }
+    specify { expect(immutable_object[1]).to be_frozen }
+    specify { expect(immutable_object[1]).to eq string }
+  end
+
+  context 'when converting a hash' do
+    let(:converter)  { Yamload::Conversion::Object.new(hash) }
+    specify { expect(hash).not_to be_frozen }
+    specify { is_expected.to be_frozen }
+    specify { expect(immutable_object.string).to eq string }
+    specify { expect(immutable_object.array.size).to eq 2 }
+    specify { expect(immutable_object.array[0]).to eq number }
+    specify { expect(immutable_object.array[1]).to be_frozen }
+    specify { expect(immutable_object.array[1]).to eq string }
+    specify { expect(immutable_object.sub_hash).to be_frozen }
+    specify { expect(immutable_object.sub_hash.something).to be_frozen }
+    specify { expect(immutable_object.sub_hash.something).to eq 'else' }
+  end
+end

data/spec/fixtures/array.yml

@@ -0,0 +1,4 @@
+---
+- first
+- second
+- third

data/spec/fixtures/empty.yml

@@ -1 +0,0 @@
-

data/spec/fixtures/string.yml

@@ -0,0 +1,7 @@
+---
+1
+first
+2
+second
+3
+third

data/spec/fixtures/test.yml

@@ -22,4 +22,4 @@ users:
       country: Specland
     email: speccy.speccer@spec.com
 settings:
-  remote_access: true
+  remote_access: true

data/spec/loader_spec.rb

@@ -2,201 +2,278 @@ require 'spec_helper'
 
 require 'yamload'
 
-describe Yamload do
+describe Yamload::Loader do
   let(:file)    { :test }
   let(:loader)  { Yamload::Loader.new(file) }
-
-  specify { expect(loader).to exist }
+  let(:content)  { loader.content }
 
   context 'if the directory is not specified' do
     let(:loader) { Yamload::Loader.new(file, nil) }
-    specify { expect { config }.to raise_error IOError, 'No yml files directory specified' }
+    specify { expect { content }.to raise_error IOError, 'No yml files directory specified' }
   end
 
   context 'if the directory is invalid' do
     let(:current_file_dir)  { File.expand_path(File.dirname(__FILE__)) }
     let(:invalid_dir)       { File.join(current_file_dir, 'invalid') }
     let(:loader)            { Yamload::Loader.new(file, invalid_dir) }
-    specify { expect { config }.to raise_error IOError, "#{invalid_dir} is not a valid directory" }
+    specify { expect { content }.to raise_error IOError, "#{invalid_dir} is not a valid directory" }
   end
 
   context 'with a non existing file' do
     let(:file) { :non_existing }
     specify { expect(loader).not_to exist }
-    specify { expect { config }.to raise_error IOError, 'non_existing.yml could not be found' }
+    specify { expect { content }.to raise_error IOError, 'non_existing.yml could not be found' }
   end
 
-  let(:config) { loader.loaded_hash }
-
   context 'with an empty file' do
     let(:file) { :empty }
     specify { expect(loader).to exist }
-    specify { expect { config }.to raise_error IOError, 'empty.yml is invalid' }
+    specify { expect { content }.to raise_error IOError, 'empty.yml is blank' }
   end
 
-  let(:expected_config) {
-    {
-      'test'  => true,
-      'users' => [
-        {
-          'first_name' => 'Testy',
-          'last_name'  => 'Tester',
-          'address'    => {
-            'address_line_1' => '1 Test Avenue',
-            'address_line_2' => nil,
-            'city'           => 'Testville',
-            'state'          => 'TST',
-            'post_code'      => 1234,
-            'country'        => 'Testalia'
-          },
-          'email'      => 'testy.tester@test.com'
-        },
-        {
-          'first_name' => 'Speccy',
-          'last_name'  => 'Speccer',
-          'address'    => {
-            'address_line_1' => 'Unit 1',
-            'address_line_2' => '42 Spec Street',
-            'city'           => 'Specwood',
-            'state'          => 'SPC',
-            'post_code'      => 5678,
-            'country'        => 'Specland'
-          },
-          'email'      => 'speccy.speccer@spec.com'
-        }
-      ],
-      'settings' => {
-        'remote_access' => true
+  context 'with a file defining an array' do
+    let(:file) { :array }
+    let(:expected_content) { %w(first second third) }
+    specify { expect(loader).to exist }
+    specify { expect { content }.not_to raise_error }
+    specify { expect(content).to eq expected_content }
+
+    context 'when defaults are defined' do
+      let(:defaults) { { test: true } }
+      before { loader.defaults = defaults }
+      specify {
+        expect { content }
+          .to raise_error ArgumentError, "#{expected_content} is not a hash"
       }
-    }
-  }
-
-  specify { expect(config).to eq expected_config }
-
-  let(:config_obj)  { loader.obj }
-
-  specify { expect(config_obj.test).to eq true }
-  specify { expect(config_obj.users[0].first_name).to eq 'Testy' }
-  specify { expect(config_obj.users[0].last_name).to eq 'Tester' }
-  specify { expect(config_obj.users[0].address.address_line_1).to eq '1 Test Avenue' }
-  specify { expect(config_obj.users[0].address.address_line_2).to eq nil }
-  specify { expect(config_obj.users[0].address.city).to eq 'Testville' }
-  specify { expect(config_obj.users[0].address.state).to eq 'TST' }
-  specify { expect(config_obj.users[0].address.post_code).to eq 1234 }
-  specify { expect(config_obj.users[0].address.country).to eq 'Testalia' }
-  specify { expect(config_obj.users[0].email).to eq 'testy.tester@test.com' }
-  specify { expect(config_obj.users[1].first_name).to eq 'Speccy' }
-  specify { expect(config_obj.users[1].last_name).to eq 'Speccer' }
-  specify { expect(config_obj.users[1].address.address_line_1).to eq 'Unit 1' }
-  specify { expect(config_obj.users[1].address.address_line_2).to eq '42 Spec Street' }
-  specify { expect(config_obj.users[1].address.city).to eq 'Specwood' }
-  specify { expect(config_obj.users[1].address.state).to eq 'SPC' }
-  specify { expect(config_obj.users[1].address.post_code).to eq 5678 }
-  specify { expect(config_obj.users[1].address.country).to eq 'Specland' }
-  specify { expect(config_obj.users[1].email).to eq 'speccy.speccer@spec.com' }
-  specify { expect(config_obj.settings.remote_access).to eq true }
-
-  context 'when trying to modify the loaded hash' do
-    let(:new_user) { double('new user') }
-    specify 'the hash should be immutable' do
-      expect { config['users'] << new_user }
-        .to raise_error RuntimeError, "can't modify frozen Array"
-      expect(config['users']).not_to include new_user
     end
-  end
 
-  context 'when trying to modify the configuration object' do
-    let(:new_user) { double('new user') }
-    specify 'the object should be immutable' do
-      expect { config_obj.users << new_user }
-        .to raise_error RuntimeError, "can't modify frozen Array"
-      expect(config_obj.users).not_to include new_user
+    context 'when a schema is defined' do
+      let(:schema) { { test: true } }
+      before { loader.schema = schema }
+      specify {
+        expect { loader.valid? }
+          .to raise_error ArgumentError, "#{expected_content} is not a hash"
+      }
     end
   end
 
-  context 'when no schema is defined' do
-    specify { expect(loader).to be_valid }
-    specify { expect(loader.error).to be_nil }
-    specify { expect { loader.validate! }.not_to raise_error }
+  context 'with a file defining a string' do
+    let(:file) { :string }
+    let(:expected_content) { '1 first 2 second 3 third' }
+    specify { expect(loader).to exist }
+    specify { expect { content }.not_to raise_error }
+    specify { expect(content).to eq expected_content }
+
+    context 'when defaults are defined' do
+      let(:defaults) { { test: true } }
+      before { loader.defaults = defaults }
+      specify {
+        expect { content }
+          .to raise_error ArgumentError, "#{expected_content} is not a hash"
+      }
+    end
+
+    context 'when a schema is defined' do
+      let(:schema) { { test: true } }
+      before { loader.schema = schema }
+      specify {
+        expect { loader.valid? }
+          .to raise_error ArgumentError, "#{expected_content} is not a hash"
+      }
+    end
   end
 
-  context 'when a schema is defined' do
-    let(:schema) {
+  context 'with a file defining a hash' do
+    specify { expect(loader).to exist }
+
+    let(:expected_content) {
       {
-        'test'     => TrueClass,
-        'users'    => [
-          [
-            {
-              'first_name' => String,
-              'last_name'  => String,
-              'address'    => {
-                'address_line_1' => String,
-                'address_line_2' => [:optional, String, NilClass],
-                'city'           => String,
-                'state'          => String,
-                'post_code'      => Integer,
-                'country'        => String
-              },
-              'email'      => String
-            }
-          ]
+        'test'  => true,
+        'users' => [
+          {
+            'first_name' => 'Testy',
+            'last_name'  => 'Tester',
+            'address'    => {
+              'address_line_1' => '1 Test Avenue',
+              'address_line_2' => nil,
+              'city'           => 'Testville',
+              'state'          => 'TST',
+              'post_code'      => 1234,
+              'country'        => 'Testalia'
+            },
+            'email'      => 'testy.tester@test.com'
+          },
+          {
+            'first_name' => 'Speccy',
+            'last_name'  => 'Speccer',
+            'address'    => {
+              'address_line_1' => 'Unit 1',
+              'address_line_2' => '42 Spec Street',
+              'city'           => 'Specwood',
+              'state'          => 'SPC',
+              'post_code'      => 5678,
+              'country'        => 'Specland'
+            },
+            'email'      => 'speccy.speccer@spec.com'
+          }
         ],
         'settings' => {
-          'remote_access' => TrueClass
+          'remote_access' => true
         }
       }
     }
 
-    before { loader.schema = schema }
+    specify 'deprecated `loaded_hash` still works' do
+      expect(loader.loaded_hash).to eq loader.content
+    end
+
+    specify { expect(content).to eq expected_content }
+
+    let(:content_obj)  { loader.obj }
 
-    specify { expect(loader).to be_valid }
-    specify { expect(loader.error).to be_nil }
-    specify { expect { loader.validate! }.not_to raise_error }
+    specify { expect(content_obj.test).to eq true }
+    specify { expect(content_obj.users[0].first_name).to eq 'Testy' }
+    specify { expect(content_obj.users[0].last_name).to eq 'Tester' }
+    specify { expect(content_obj.users[0].address.address_line_1).to eq '1 Test Avenue' }
+    specify { expect(content_obj.users[0].address.address_line_2).to eq nil }
+    specify { expect(content_obj.users[0].address.city).to eq 'Testville' }
+    specify { expect(content_obj.users[0].address.state).to eq 'TST' }
+    specify { expect(content_obj.users[0].address.post_code).to eq 1234 }
+    specify { expect(content_obj.users[0].address.country).to eq 'Testalia' }
+    specify { expect(content_obj.users[0].email).to eq 'testy.tester@test.com' }
+    specify { expect(content_obj.users[1].first_name).to eq 'Speccy' }
+    specify { expect(content_obj.users[1].last_name).to eq 'Speccer' }
+    specify { expect(content_obj.users[1].address.address_line_1).to eq 'Unit 1' }
+    specify { expect(content_obj.users[1].address.address_line_2).to eq '42 Spec Street' }
+    specify { expect(content_obj.users[1].address.city).to eq 'Specwood' }
+    specify { expect(content_obj.users[1].address.state).to eq 'SPC' }
+    specify { expect(content_obj.users[1].address.post_code).to eq 5678 }
+    specify { expect(content_obj.users[1].address.country).to eq 'Specland' }
+    specify { expect(content_obj.users[1].email).to eq 'speccy.speccer@spec.com' }
+    specify { expect(content_obj.settings.remote_access).to eq true }
 
-    context 'when the schema is not matched' do
+    context 'when trying to modify the loaded hash' do
+      let(:new_user) { double('new user') }
+      specify 'the hash should be immutable' do
+        expect { content['users'] << new_user }
+          .to raise_error RuntimeError, "can't modify frozen Array"
+        expect(content['users']).not_to include new_user
+      end
+    end
+
+    context 'when trying to modify the content object' do
+      let(:new_user) { double('new user') }
+      specify 'the object should be immutable' do
+        expect { content_obj.users << new_user }
+          .to raise_error RuntimeError, "can't modify frozen Array"
+        expect(content_obj.users).not_to include new_user
+      end
+    end
+
+    context 'when no schema is defined' do
+      specify { expect(loader).to be_valid }
+      specify { expect(loader.error).to be_nil }
+      specify { expect { loader.validate! }.not_to raise_error }
+    end
+
+    context 'when the schema is not a hash' do
+      let(:schema) { 'not a hash' }
+      specify {
+        expect { loader.schema = schema }
+          .to raise_error ArgumentError, "#{schema} is not a hash"
+      }
+    end
+
+    context 'when a schema is defined' do
       let(:schema) {
         {
-          'users' => [
+          'test'     => TrueClass,
+          'users'    => [
             [
               {
-                'expected_attribute' => String
+                'first_name' => String,
+                'last_name'  => String,
+                'address'    => {
+                  'address_line_1' => String,
+                  'address_line_2' => [:optional, String, NilClass],
+                  'city'           => String,
+                  'state'          => String,
+                  'post_code'      => Integer,
+                  'country'        => String
+                },
+                'email'      => String
               }
             ]
-          ]
+          ],
+          'settings' => {
+            'remote_access' => TrueClass
+          }
         }
       }
 
-      let(:expected_error) { '"users"[0]["expected_attribute"] is not present' }
-      specify { expect(loader).not_to be_valid }
-      specify { expect(loader.error).to eq expected_error }
-      specify { expect { loader.validate! }.to raise_error Yamload::SchemaError, expected_error }
+      before do
+        loader.schema = schema
+      end
+
+      specify { expect(loader.schema).to eq schema }
+      specify { expect(loader).to be_valid }
+      specify { expect(loader.error).to be_nil }
+      specify { expect { loader.validate! }.not_to raise_error }
+
+      context 'when the schema is not matched' do
+        let(:schema) {
+          {
+            'users' => [
+              [
+                {
+                  'expected_attribute' => String
+                }
+              ]
+            ]
+          }
+        }
+
+        let(:expected_error) { '"users"[0]["expected_attribute"] is not present' }
+        specify { expect(loader).not_to be_valid }
+        specify { expect(loader.error).to eq expected_error }
+        specify { expect { loader.validate! }.to raise_error Yamload::SchemaError, expected_error }
+      end
     end
-  end
 
-  context 'when defaults are defined' do
-    let(:defaults) {
-      {
-        'settings' => {
-          'remember_user' => false,
-          'remote_access' => false
+    context 'when the defaults object is not a hash' do
+      let(:defaults) { 'not a hash' }
+      specify {
+        expect { loader.defaults = defaults }
+          .to raise_error ArgumentError, "#{defaults} is not a hash"
+      }
+    end
+
+    context 'when defaults are defined' do
+      let(:defaults) {
+        {
+          'settings' => {
+            'remember_user' => false,
+            'remote_access' => false
+          }
         }
       }
-    }
 
-    before do
-      loader.defaults = defaults
-    end
+      before do
+        loader.defaults = defaults
+      end
 
-    specify { expect(config_obj.settings.remember_user).to eq false }
-    specify { expect(config_obj.settings.remote_access).to eq true }
-  end
+      specify { expect(loader.defaults).to eq defaults }
+      specify { expect(content_obj.settings.remember_user).to eq false }
+      specify { expect(content_obj.settings.remote_access).to eq true }
+    end
 
-  context 'when reloading' do
-    let(:original_hash) { loader.loaded_hash }
-    before do
-      original_hash
-      loader.reload
+    context 'when reloading' do
+      let(:original_hash) { loader.content }
+      before do
+        original_hash
+        loader.reload
+      end
+      specify { expect(loader.content).not_to be original_hash }
     end
-    specify { expect(loader.loaded_hash).not_to be original_hash }
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yamload
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors:
 - Alessandro Berardi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-04 00:00:00.000000000 Z
+date: 2015-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: anima
@@ -162,15 +162,29 @@ files:
 - ".rubocop.yml"
 - ".ruby-version"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/yamload.rb
-- lib/yamload/hash_to_immutable_object.rb
+- lib/yamload/conversion.rb
+- lib/yamload/conversion/array.rb
+- lib/yamload/conversion/hash.rb
+- lib/yamload/conversion/object.rb
+- lib/yamload/defaults.rb
+- lib/yamload/defaults/hash.rb
 - lib/yamload/loader.rb
+- lib/yamload/loading.rb
+- lib/yamload/loading/yaml.rb
+- lib/yamload/validation.rb
+- lib/yamload/validation/hash.rb
+- lib/yamload/validation/result.rb
 - lib/yamload/version.rb
+- spec/conversion_spec.rb
+- spec/fixtures/array.yml
 - spec/fixtures/empty.yml
+- spec/fixtures/string.yml
 - spec/fixtures/test.yml
 - spec/loader_spec.rb
 - spec/spec_helper.rb
@@ -200,7 +214,10 @@ signing_key:
 specification_version: 4
 summary: YAML files loader
 test_files:
+- spec/conversion_spec.rb
+- spec/fixtures/array.yml
 - spec/fixtures/empty.yml
+- spec/fixtures/string.yml
 - spec/fixtures/test.yml
 - spec/loader_spec.rb
 - spec/spec_helper.rb

data/lib/yamload/hash_to_immutable_object.rb

@@ -1,40 +0,0 @@
-require 'facets/hash/rekey'
-require 'anima'
-
-module Yamload
-  class HashToImmutableObject
-    def initialize(hash)
-      @hash = hash.rekey
-    end
-
-    def call
-      immutable_objects_factory.new(converted_hash)
-    end
-
-    private
-
-    def immutable_objects_factory
-      anima = Anima.new(*@hash.keys)
-      Class.new do
-        include Adamantium
-        include anima
-      end
-    end
-
-    def converted_hash
-      @hash.map.with_object({}) { |(key, value), hash|
-        hash[key] = convert(value)
-      }
-    end
-
-    def convert(value)
-      if value.is_a?(Hash)
-        self.class.new(value).call
-      elsif value.is_a?(Array)
-        value.map { |element| convert(element) }
-      else
-        value
-      end
-    end
-  end
-end