chozo 0.1.0 → 0.2.0

data/Gemfile

@@ -27,7 +27,7 @@ group :development do
     end rescue Errno::ENOENT
 
   elsif RbConfig::CONFIG['target_os'] =~ /linux/i
-    gem 'libnotify',  '~> 0.7.1', require: false
+    gem 'libnotify',  '~> 0.8.0', require: false
     gem 'rb-inotify', require: false
 
   elsif RbConfig::CONFIG['target_os'] =~ /mswin|mingw/i

data/chozo.gemspec

@@ -19,4 +19,5 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'activesupport', '>= 3.2.0'
   s.add_runtime_dependency 'activemodel', '>= 3.2.0'
   s.add_runtime_dependency 'multi_json', '>= 1.3.0'
+  s.add_runtime_dependency 'hashie'
 end

data/lib/chozo.rb

@@ -4,7 +4,9 @@ module Chozo
   autoload :Errors, 'chozo/errors'
   autoload :Platform, 'chozo/platform'
   autoload :RubyEngine, 'chozo/ruby_engine'
+  autoload :VariaModel, 'chozo/varia_model'
 end
 
 require 'chozo/core_ext'
+require 'chozo/hashie_ext'
 require 'active_support/core_ext'

data/lib/chozo/config.rb

@@ -1,101 +1,7 @@
-require 'active_model'
-require 'chozo/errors'
-
 module Chozo
   # @author Jamie Winsor <jamie@vialstudios.com>
   module Config
+    autoload :Abstract, 'chozo/config/abstract'
     autoload :JSON, 'chozo/config/json'
-
-    extend ActiveSupport::Concern
-
-    included do
-      include ActiveModel::AttributeMethods
-      include ActiveModel::Validations
-      attribute_method_suffix('=')
-    end
-
-    module ClassMethods
-      # @return [Set]
-      def attributes
-        @attributes ||= Set.new
-      end
-
-      # @return [Hash]
-      def defaults
-        @defaults ||= Hash.new
-      end
-
-      # @param [Symbol] name
-      # @param [Hash] options
-      #
-      # @return [Hash]
-      def attribute(name, options = {})
-        if options[:default]
-          default_for_attribute(name, options[:default])
-        end
-        define_attribute_method(name)
-        attributes << name.to_sym
-      end
-
-      private
-
-        def default_for_attribute(name, value)
-          defaults[name.to_sym] = value
-        end
-    end
-
-    attr_accessor :path
-
-    # @param [String] path
-    # @param [Hash] attributes
-    def initialize(path = nil, attributes = {})
-      @path = File.expand_path(path) if path
-      self.attributes = attributes
-    end
-
-    # @param [Symbol] key
-    #
-    # @return [Object]
-    def attribute(key)
-      instance_variable_get("@#{key}") || self.class.defaults[key.to_sym]
-    end
-    alias_method :[], :attribute
-
-    # @param [Symbol] key
-    # @param [Object] value
-    def attribute=(key, value)
-      instance_variable_set("@#{key}", value)
-    end
-    alias_method :[]=, :attribute=
-
-    # @param [Hash] new_attributes
-    def attributes=(new_attributes)
-      new_attributes.symbolize_keys!
-
-      self.class.attributes.each do |attr_name|
-        send(:attribute=, attr_name, new_attributes[attr_name.to_sym])
-      end
-    end
-
-    # @param [Symbol] key
-    #
-    # @return [Boolean]
-    def attribute?(key)
-      instance_variable_get("@#{key}").present?
-    end
-
-    # @return [Hash]
-    def attributes
-      {}.tap do |attrs|
-        self.class.attributes.each do |attr|
-          attrs[attr] = attribute(attr)
-        end
-      end
-    end
-
-    # @return [String]
-    def to_s
-      "[#{self.class}] '#{self.path}': #{self.attributes}"
-    end
   end
 end

data/lib/chozo/config/abstract.rb

@@ -0,0 +1,36 @@
+require 'forwardable'
+require 'chozo/varia_model'
+
+module Chozo
+  module Config
+    # @author Jamie Winsor <jamie@vialstudios.com>
+    # @api private
+    class Abstract
+      include VariaModel
+      
+      attr_accessor :path
+
+      # @param [String] path
+      # @param [Hash] attributes
+      def initialize(path = nil, attributes = {})
+        @path = File.expand_path(path) if path
+
+        mass_assign(attributes)
+      end
+
+      def [](key)
+        self.attributes[key]
+      end
+
+      def []=(key, value)
+        self.attributes[key] = value
+      end
+
+      protected
+
+        def mass_assign(new_attributes = {})
+          attributes.deep_merge!(new_attributes)
+        end
+    end
+  end
+end

data/lib/chozo/config/json.rb

@@ -1,13 +1,11 @@
+require 'chozo/errors'
 require 'multi_json'
 
 module Chozo
   module Config
     # @author Jamie Winsor <jamie@vialstudios.com>
-    module JSON
-      extend ActiveSupport::Concern
-      include Chozo::Config
-
-      module ClassMethods
+    class JSON < Config::Abstract
+      class << self
         # @param [String] data
         #
         # @return [~Chozo::Config::JSON]
@@ -43,16 +41,20 @@ module Chozo
       #
       # @return [~Chozo::Config::JSON]
       def from_json(json, options = {})
-        self.attributes = MultiJson.decode(json, options)
+        mass_assign(MultiJson.decode(json, options))
         self
       rescue MultiJson::DecodeError => e
         raise Chozo::Errors::InvalidConfig, e
       end
 
       def save(destination = self.path)
+        if destination.nil?
+          raise Errors::ConfigSaveError, "Cannot save configuration without a destination. Provide one to save or set one on the object."
+        end
+
         FileUtils.mkdir_p(File.dirname(destination))
         File.open(destination, 'w+') do |f|
-          f.write(self.to_json)
+          f.write(self.to_json(pretty: true))
         end
       end
     end

data/lib/chozo/core_ext/boolean.rb

@@ -0,0 +1,4 @@
+# @author Jamie Winsor <jamie@vialstudios.com>
+module Boolean; end
+class TrueClass; include Boolean; end
+class FalseClass; include Boolean; end

data/lib/chozo/errors.rb

@@ -4,5 +4,6 @@ module Chozo
     class ChozoError < StandardError; end
     class ConfigNotFound < ChozoError; end
     class InvalidConfig < ChozoError; end
+    class ConfigSaveError < ChozoError; end
   end
 end

data/lib/chozo/hashie_ext.rb

@@ -0,0 +1,5 @@
+require 'hashie'
+
+Dir["#{File.dirname(__FILE__)}/hashie_ext/*.rb"].sort.each do |path|
+  require "chozo/hashie_ext/#{File.basename(path, '.rb')}"
+end

data/lib/chozo/hashie_ext/mash.rb

@@ -0,0 +1,49 @@
+module Hashie
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  class Mash < Hashie::Hash
+    alias_method :old_setter, :[]=
+    alias_method :old_dup, :dup
+
+    attr_writer :coercions
+
+    # @return [Hash]
+    def coercions
+      @coercions ||= HashWithIndifferentAccess.new
+    end
+
+    def coercion(key)
+      self.coercions[key]
+    end
+
+    def set_coercion(key, fun)
+      self.coercions[key] = fun
+    end
+
+    # Override setter to coerce the given value if a coercion is defined
+    def []=(key, value)
+      coerced_value = coercion(key).present? ? coercion(key).call(value) : value
+      old_setter(key, coerced_value)
+    end
+
+    # Return the containing Hashie::Mash of the given dotted path
+    #
+    # @param [String] path
+    #
+    # @return [Hashie::Mash, nil]
+    def container(path)
+      parts = path.split('.', 2)
+      match = (self[parts[0].to_s] || self[parts[0].to_sym])
+      if !parts[1] or match.nil?
+        self
+      else
+        match.container(parts[1])
+      end
+    end
+
+    def dup
+      mash = old_dup
+      mash.coercions = self.coercions
+      mash
+    end
+  end
+end

data/lib/chozo/varia_model.rb

@@ -0,0 +1,180 @@
+require 'chozo/core_ext'
+require 'chozo/hashie_ext'
+
+module Chozo
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  module VariaModel
+    module ClassMethods
+      # @return [HashWithIndifferentAccess]
+      def attributes
+        @attributes ||= Hashie::Mash.new
+      end
+
+      # @return [HashWithIndifferentAccess]
+      def validations
+        @validations ||= HashWithIndifferentAccess.new
+      end
+
+      # @param [#to_s] name
+      # @option options [Symbol, Array<Symbol>] :type
+      # @option options [Boolean] :required
+      # @option options [Object] :default
+      # @option options [Proc] :coerce
+      def attribute(name, options = {})
+        name = name.to_s
+        options[:type] = Array(options[:type])
+        options[:required] ||= false
+
+        register_attribute(name, options)
+        define_mimic_methods(name, options)
+      end
+
+      # @param [String] name
+      #
+      # @return [Array]
+      def validations_for(name)
+        self.validations[name] ||= Array.new
+      end
+
+      # @param [Constant, Array<Constant>] types
+      # @param [VariaModel] model
+      # @param [String] key
+      #
+      # @return [Array]
+      def validate_kind_of(types, model, key)
+        errors  = Array.new
+        types   = types.uniq
+        matches = false
+
+        types.each do |type|
+          if model.attributes.dig(key).is_a?(type)
+            matches = true
+            break
+          end
+        end
+
+        if matches
+          [ :ok, "" ]
+        else
+          types_msg = types.collect { |type| "'#{type}'" }
+          [ :error, "Expected attribute: '#{key}' to be a type of: #{types_msg.join(', ')}" ]
+        end
+      end
+
+      # @param [VariaModel] model
+      # @param [String] key
+      #
+      # @return [Array]
+      def validate_required(model, key)
+        if model.attributes.dig(key).present?
+          [ :ok, "" ]
+        else
+          [ :error, "A value is required for attribute: '#{key}'" ]
+        end
+      end
+
+      private
+
+        def register_attribute(name, options = {})
+          if options[:type] && options[:type].any?
+            unless options[:required]
+              options[:type] << NilClass
+            end
+            register_validation(name, lambda { |object, key| validate_kind_of(options[:type], object, key) })
+          end
+
+          if options[:required]
+            register_validation(name, lambda { |object, key| validate_required(object, key) })
+          end
+
+          class_eval do
+            new_attributes = Hashie::Mash.from_dotted_path(name, options[:default])
+            self.attributes.merge!(new_attributes)
+            
+            if options[:coerce].is_a?(Proc)
+              register_coercion(name, options[:coerce])
+            end
+          end
+        end
+
+        def register_validation(name, fun)
+          self.validations[name] = (self.validations_for(name) << fun)
+        end
+
+        def register_coercion(name, fun)
+          self.attributes.container(name).set_coercion(name.split('.').last, fun)
+        end
+
+        def define_mimic_methods(name, options = {})
+          fun_name = name.split('.').first
+          
+          class_eval do
+            define_method fun_name do
+              self.attributes[fun_name]
+            end
+
+            define_method "#{fun_name}=" do |value|
+              value = if options[:coerce].is_a?(Proc)
+                options[:coerce].call(value)
+              else
+                value
+              end
+
+              self.attributes[fun_name] = value
+            end
+          end
+        end
+    end
+
+    class << self
+      def included(base)
+        base.extend(ClassMethods)
+      end
+    end
+
+    # @return [HashWithIndifferentAccess]
+    def attributes
+      @attributes ||= self.class.attributes.dup
+    end
+
+    # @return [HashWithIndifferentAccess]
+    def validate
+      self.class.validations.each do |attr_path, validations|
+        validations.each do |validation|
+          status, messages = validation.call(self, attr_path)
+
+          if status == :error
+            if messages.is_a?(Array)
+              messages.each do |message|
+                self.add_error(attr_path, message)
+              end
+            else
+              self.add_error(attr_path, messages)
+            end
+          end
+        end
+      end
+
+      self.errors
+    end
+
+    # @return [Boolean]
+    def valid?
+      validate.empty?
+    end
+
+    # @return [HashWithIndifferentAccess]
+    def errors
+      @errors ||= HashWithIndifferentAccess.new
+    end
+
+    protected
+
+      # @param [String] attribute
+      # @param [String] message
+      def add_error(attribute, message)
+        self.errors[attribute] ||= Array.new
+        self.errors[attribute] << message
+      end    
+  end
+end

data/lib/chozo/version.rb

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

data/spec/support/matchers/each.rb

@@ -0,0 +1,12 @@
+RSpec::Matchers.define :each do |check|
+  match do |actual|
+    actual.each_with_index do |index, o|
+      @object = o
+      index.should check
+    end
+  end
+
+  failure_message_for_should do |actual|
+    "at[#{@object}] #{check.failure_message_for_should}"
+  end
+end

data/spec/unit/chozo/config/json_spec.rb

@@ -1,18 +1,6 @@
 require 'spec_helper'
-require 'shared_examples/chozo/config'
-
-TestJSONConfig = Class.new do
-  include Chozo::Config::JSON
-
-  attribute :name
-  validates_presence_of :name
-
-  attribute :job
-end
 
 describe Chozo::Config::JSON do
-  it_behaves_like "Chozo::Config", TestJSONConfig
-
   let(:json) do
     %(
       {
@@ -24,10 +12,15 @@ describe Chozo::Config::JSON do
   end
 
   describe "ClassMethods" do
-    subject { TestJSONConfig }
+    subject do
+      Class.new(Chozo::Config::JSON) do
+        attribute :name, required: true
+        attribute :job
+      end
+    end
 
     describe "::from_json" do
-      it "returns an instance of the including class" do
+      it "returns an instance of the inheriting class" do
         subject.from_json(json).should be_a(subject)
       end
 
@@ -37,12 +30,6 @@ describe Chozo::Config::JSON do
         config[:name].should eql("reset")
         config[:job].should eql("programmer")
       end
-
-      it "does not set an attribute value for undefined attributes" do
-        config = subject.from_json(json)
-
-        config[:status].should be_nil
-      end
     end
 
     describe "::from_file" do
@@ -52,8 +39,8 @@ describe Chozo::Config::JSON do
         File.open(file, "w") { |f| f.write(json) }
       end
 
-      it "returns an instance of the including class" do
-        subject.from_file(file).should be_a(TestJSONConfig)
+      it "returns an instance of the inheriting class" do
+        subject.from_file(file).should be_a(subject)
       end
 
       it "sets the object's filepath to the path of the loaded file" do
@@ -70,7 +57,12 @@ describe Chozo::Config::JSON do
     end
   end
 
-  subject { TestJSONConfig.new }
+  subject do
+    Class.new(Chozo::Config::JSON) do
+      attribute :name, required: true
+      attribute :job
+    end.new
+  end
 
   describe "#to_json" do
     before(:each) do
@@ -90,20 +82,24 @@ describe Chozo::Config::JSON do
 
   describe "#from_json" do
     it "returns an instance of the updated class" do
-      subject.from_json(json).should be_a(subject.class)
+      subject.from_json(json).should be_a(Chozo::Config::JSON)
     end
 
     it "assigns values for each defined attribute" do
       config = subject.from_json(json)
 
-      config[:name].should eql("reset")
-      config[:job].should eql("programmer")
+      config.name.should eql("reset")
+      config.job.should eql("programmer")
     end
+  end
 
-    it "does not set an attribute value for undefined attributes" do
-      config = subject.from_json(json)
+  describe "#save" do
+    it "raises a ConfigSaveError if no path is set or given" do
+      subject.path = nil
 
-      config[:status].should be_nil
+      lambda {
+        subject.save
+      }.should raise_error(Chozo::Errors::ConfigSaveError)
     end
   end
 end

data/spec/unit/chozo/varia_model_spec.rb

@@ -0,0 +1,395 @@
+require 'spec_helper'
+
+describe Chozo::VariaModel do
+  describe "ClassMethods" do
+    subject do
+      Class.new do
+        include Chozo::VariaModel
+      end
+    end
+
+    describe "::attributes" do
+      it "returns a Hashie::Mash" do
+        subject.attributes.should be_a(Hashie::Mash)
+      end
+
+      it "is empty by default" do
+        subject.attributes.should be_empty
+      end
+    end
+
+    describe "::attribute" do
+      it "adds an attribute to the attributes hash for each attribute function call" do
+        subject.attribute 'jamie.winsor'
+        subject.attribute 'brooke.winsor'
+
+        subject.attributes.should have(2).items
+      end
+
+      it "adds a validation if :required option is true" do
+        subject.attribute 'brooke.winsor', required: true
+
+        subject.validations.should have(1).item
+      end
+
+      it "adds a validation if the :type option is provided" do
+        subject.attribute 'brooke.winsor', type: :string
+
+        subject.validations.should have(1).item
+      end
+
+      it "sets a default value if :default option is provided" do
+        subject.attribute 'brooke.winsor', default: 'rhode island'
+
+        subject.attributes.dig('brooke.winsor').should eql('rhode island')
+      end
+    end
+
+    describe "::validations" do
+      it "returns a HashWithIndifferentAccess" do
+        subject.validations.should be_a(HashWithIndifferentAccess)
+      end
+
+      it "is empty by default" do
+        subject.validations.should be_empty
+      end
+    end
+
+    describe "::validations_for" do
+      context "when an attribute is registered and has validations" do
+        before(:each) do
+          subject.attribute("nested.attribute", required: true, type: String)
+        end
+
+        it "returns an array of procs" do
+          validations = subject.validations_for("nested.attribute")
+
+          validations.should be_a(Array)
+          validations.should each be_a(Proc)
+        end
+      end
+
+      context "when an attribute is registered but has no validations" do
+        before(:each) do
+          subject.attribute("nested.attribute")
+        end
+
+        it "returns an empty array" do
+          validations = subject.validations_for("nested.attribute")
+
+          validations.should be_a(Array)
+          validations.should be_empty
+        end
+      end
+
+      context "when an attribute is not registered" do
+        it "returns an empty array" do
+          validations = subject.validations_for("not_existing.attribute")
+
+          validations.should be_a(Array)
+          validations.should be_empty
+        end
+      end
+    end
+
+    describe "::validate_kind_of" do
+      let(:types) do
+        [
+          String,
+          Boolean
+        ]
+      end
+
+      let(:key) do
+        'nested.one'
+      end
+
+      subject do
+        Class.new do
+          include Chozo::VariaModel
+
+          attribute 'nested.one', types: [String, Boolean]
+        end
+      end
+
+      let(:model) do
+        subject.new
+      end
+
+      it "returns an array" do
+        subject.validate_kind_of(types, model, key).should be_a(Array)
+      end
+
+      context "failure" do
+        before(:each) do
+          model.nested.one = nil
+        end
+
+        it "returns an array where the first element is ':error'" do
+          subject.validate_kind_of(types, model, key).first.should eql(:error)
+        end
+
+        it "returns an array where the second element is an error message containing the attribute and types" do
+          types.each do |type|
+            subject.validate_kind_of(types, model, key)[1].should =~ /#{type}/
+          end
+          subject.validate_kind_of(types, model, key)[1].should =~ /#{key}/
+        end
+      end
+
+      context "success" do
+        before(:each) do
+          model.nested.one = true
+        end
+
+        it "returns an array where the first element is ':ok'" do
+          subject.validate_kind_of(types, model, key).first.should eql(:ok)
+        end
+
+        it "returns an array where the second element is a blank string" do
+          subject.validate_kind_of(types, model, key)[1].should be_blank
+        end
+      end
+
+      context "when given two types of the same kind" do
+        let(:types) do
+          [
+            String,
+            String
+          ]
+        end
+
+        let(:key) do
+          'nested.one'
+        end
+
+        subject do
+          Class.new do
+            include Chozo::VariaModel
+
+            attribute 'nested.one', types: [String, Boolean]
+          end
+        end
+
+        let(:model) do
+          subject.new
+        end
+
+        before(:each) do
+          model.nested.one = nil
+        end
+
+        it "returns a error message that contains the type error only once" do
+          subject.validate_kind_of(types, model, key)[1].should eql("Expected attribute: 'nested.one' to be a type of: 'String'")
+        end
+      end
+    end
+
+    describe "::validate_required" do
+      let(:key) do
+        'nested.one'
+      end
+
+      subject do
+        Class.new do
+          include Chozo::VariaModel
+
+          attribute 'nested.one', required: true
+        end
+      end
+
+      let(:model) do
+        subject.new
+      end
+
+      it "returns an array" do
+        subject.validate_required(model, key).should be_a(Array)
+      end
+
+      context "failure" do
+        before(:each) do
+          model.nested.one = nil
+        end
+
+        it "returns an array where the first element is ':error'" do
+          subject.validate_required(model, key).first.should eql(:error)
+        end
+
+        it "returns an array where the second element is an error message containing the attribute name" do
+          subject.validate_required(model, key)[1].should =~ /#{key}/
+        end
+      end
+
+      context "success" do
+        before(:each) do
+          model.nested.one = "hello"
+        end
+
+        it "returns an array where the first element is ':ok'" do
+          subject.validate_required(model, key).first.should eql(:ok)
+        end
+
+        it "returns an array where the second element is a blank string" do
+          subject.validate_required(model, key)[1].should be_blank
+        end
+      end
+    end
+  end
+
+  subject do
+    Class.new do
+      include Chozo::VariaModel
+
+      attribute 'nested.not_coerced', default: 'hello'
+      attribute 'nested.no_default'
+      attribute 'nested.coerced', coerce: lambda { |m| m.to_s }
+      attribute 'toplevel', default: 'hello'
+      attribute 'no_default'
+      attribute 'coerced', coerce: lambda { |m| m.to_s }
+    end.new
+  end
+
+  describe "GeneratedAccessors" do
+    describe "nested getter" do
+      it "returns the default value" do
+        subject.nested.not_coerced.should eql('hello')
+      end
+
+      it "returns nil if there is no default value" do
+        subject.nested.no_default.should be_nil
+      end
+    end
+
+    describe "toplevel getter" do
+      it "returns the default value" do
+        subject.toplevel.should eql('hello')
+      end
+
+      it "returns nil if there is no default value" do
+        subject.no_default.should be_nil
+      end
+    end
+
+    describe "nested setter" do
+      it "sets the value of the nested attribute" do
+        subject.nested.not_coerced = 'world'
+
+        subject.nested.not_coerced.should eql('world')
+      end
+    end
+
+    describe "toplevel setter" do
+      it "sets the value of the top level attribute" do
+        subject.toplevel = 'world'
+
+        subject.toplevel.should eql('world')
+      end
+    end
+
+    describe "nested coerced setter" do
+      it "sets the value of the nested coerced attribute" do
+        subject.nested.coerced = 1
+
+        subject.nested.coerced.should eql("1")
+      end
+    end
+
+    describe "toplevel coerced setter" do
+      it "sets the value of the top level coerced attribute" do
+        subject.coerced = 1
+
+        subject.coerced.should eql('1')
+      end
+    end
+
+    context "given two nested attributes with a common parent and default values" do
+      subject do
+        Class.new do
+          include Chozo::VariaModel
+
+          attribute 'nested.one', default: 'val_one'
+          attribute 'nested.two', default: 'val_two'
+        end.new
+      end
+
+      it "sets a default value for each nested attribute" do
+        subject.nested.one.should eql('val_one')
+        subject.nested.two.should eql('val_two')
+      end
+    end
+
+    context "given two nested attributes with a common parent and coercions" do
+      subject do
+        Class.new do
+          include Chozo::VariaModel
+
+          attribute 'nested.one', coerce: lambda { |m| m.to_s }
+          attribute 'nested.two', coerce: lambda { |m| m.to_s }
+        end.new
+      end
+
+      it "coerces each value if both have a coercion" do
+        subject.nested.one = 1
+        subject.nested.two = 2
+
+        subject.nested.one.should eql("1")
+        subject.nested.two.should eql("2")
+      end
+    end
+  end
+
+  describe "Validations" do
+    describe "validate required" do
+      subject do
+        Class.new do
+          include Chozo::VariaModel
+
+          attribute 'brooke.winsor', required: true
+        end.new
+      end
+
+      it "is not valid if it fails validation" do
+        subject.should_not be_valid
+      end
+
+      it "adds an error for each attribute that fails validations" do
+        subject.validate
+
+        subject.errors.should have(1).item
+      end
+
+      it "adds a message for each failed validation" do
+        subject.validate
+
+        subject.errors['brooke.winsor'].should have(1).item
+        subject.errors['brooke.winsor'][0].should eql("A value is required for attribute: 'brooke.winsor'")
+      end
+    end
+
+    describe "validate type" do
+      subject do
+        Class.new do
+          include Chozo::VariaModel
+
+          attribute 'brooke.winsor', type: String
+        end.new
+      end
+
+      before(:each) do
+        subject.brooke.winsor = false
+      end
+
+      it "returns false if it fails validation" do
+        subject.should_not be_valid
+      end
+
+      it "adds an error if it fails validation" do
+        subject.validate
+
+        subject.errors.should have(1).item
+        subject.errors['brooke.winsor'].should have(1).item
+        subject.errors['brooke.winsor'][0].should eql("Expected attribute: 'brooke.winsor' to be a type of: 'String', 'NilClass'")
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chozo
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-29 00:00:00.000000000 Z
+date: 2012-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -59,6 +59,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A collection of supporting libraries and Ruby core extensions
 email:
 - jamie@vialstudios.com
@@ -77,22 +93,28 @@ files:
 - chozo.gemspec
 - lib/chozo.rb
 - lib/chozo/config.rb
+- lib/chozo/config/abstract.rb
 - lib/chozo/config/json.rb
 - lib/chozo/core_ext.rb
+- lib/chozo/core_ext/boolean.rb
 - lib/chozo/core_ext/hash.rb
 - lib/chozo/core_ext/kernel.rb
 - lib/chozo/errors.rb
+- lib/chozo/hashie_ext.rb
+- lib/chozo/hashie_ext/mash.rb
 - lib/chozo/platform.rb
 - lib/chozo/ruby_engine.rb
+- lib/chozo/varia_model.rb
 - lib/chozo/version.rb
 - spec/shared_examples/chozo/config.rb
 - spec/spec_helper.rb
 - spec/support/helpers.rb
+- spec/support/matchers/each.rb
 - spec/unit/chozo/config/json_spec.rb
-- spec/unit/chozo/config_spec.rb
 - spec/unit/chozo/core_ext/hash_spec.rb
 - spec/unit/chozo/platform_spec.rb
 - spec/unit/chozo/ruby_engine_spec.rb
+- spec/unit/chozo/varia_model_spec.rb
 homepage: https://github.com/reset/chozo
 licenses: []
 post_install_message: 
@@ -113,7 +135,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3399825819985301824
+      hash: 3079662827452475923
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -124,8 +146,10 @@ test_files:
 - spec/shared_examples/chozo/config.rb
 - spec/spec_helper.rb
 - spec/support/helpers.rb
+- spec/support/matchers/each.rb
 - spec/unit/chozo/config/json_spec.rb
-- spec/unit/chozo/config_spec.rb
 - spec/unit/chozo/core_ext/hash_spec.rb
 - spec/unit/chozo/platform_spec.rb
 - spec/unit/chozo/ruby_engine_spec.rb
+- spec/unit/chozo/varia_model_spec.rb
+has_rdoc: 

data/spec/unit/chozo/config_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-require 'shared_examples/chozo/config'
-
-TestConfig = Class.new do
-  include Chozo::Config
-
-  attribute :name
-  validates_presence_of :name
-
-  attribute :job
-end
-
-describe Chozo::Config do
-  it_behaves_like "Chozo::Config", TestConfig
-
-  subject do
-    TestConfig.new
-  end
-
-  describe "Validations" do
-    it "is valid if all required attributes are specified" do
-      subject.name = "reset"
-
-      subject.should be_valid
-    end
-
-    it "is not valid if a required attribute is not specified" do
-      subject.name = nil
-
-      subject.should_not be_valid
-    end
-  end
-end