simple_model 1.2.26 → 1.2.27

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NDZkZTQzYzExYjM5MWRiMzhmZjViZGRkYjA5NDQ1MjcxY2M1NDE4YQ==
+    NzIwOThmYzg1NGI0ZGZjN2YwNTdhZTU3NGM2YzNmMDBlMGJkMzA2NA==
   data.tar.gz: !binary |-
-    ODU0YTMzMWM4OTA0NGRlYWVkM2U1YTA2MTJhY2Q4MTQxNzc5YTE1NQ==
+    YWEwNDJjZDg4ZjExOTYxODYyMmQ0NjljZjNkY2VkOTg3Y2Q1ZjI5Nw==
 SHA512:
   metadata.gz: !binary |-
-    ZGM5YTJlY2I2NjU2Y2RkMmQ5MWY2MWJmNmMxNTQyOTdhZWQ1MzYxY2U0NGUy
-    OTQzZWZmN2RkNjg5NWIzMzUzZGM0YzBhYTMxNjk3ZTBhYWRmNjVkZmQwYjcz
-    YzFlY2VhZDE0ODM2YTExZmM0ODZlZDAyZTUzNzQ4OTc3MWQxYjU=
+    NDkyOTdlMDdmZTczMGI3MGQyZmZlNzliNDkzN2M2ZTY4NGU4MmNjNGZmZWI0
+    M2M3YmMzNWQ3Njg2ZjEwZWY4YTUzYzEwMjkwNDI2NTU5ZDc4MzdhNDdhZjYx
+    MzQ4OWRkZjY3MDczY2Q5Yzc4NTVjN2NiMjdiOWNlOGE4YzFlMGY=
   data.tar.gz: !binary |-
-    NGViMDY2YzUwYzhlYzdiZWNiMDFkNjg4NmY2MmY0NTc3YzMxN2QzN2E2ODgx
-    MDJlODJkM2VlMjkzYmY4MzJhNGQ4MzgyY2E4ZDZiYjcwZWU2Yzk3ZWIyOTFj
-    ZmZlMDgzYWQ5MDExNWUxZDYwMDE5ZGMzZDNiMWM3MzI3Y2EzNDQ=
+    YzhiNmE4MWU5ZDVhOWYzZTZlZGUyNmI1MzU1YmQxODY5MjdkMGRhNjg2MTJk
+    MWJhZDNiNDQyY2E1YTg1NzlmM2FkODViMmNlZTRiYzhlMWEwOWVjMmRhZDZi
+    ZDBhMzAwODQzYjM1MTBiYWIxNWI2YjNjYzBlM2Y0MGZjYzYyODc=

data/benchmarks/simple_model.rb

@@ -1,40 +1,95 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'benchmark'
+require 'simple_model'
+
 class BenchClass < SimpleModel::Base
+  has_attribute :foo
+  has_boolean :bool
   has_int :num
-  has_date :date, :default => :today
+  has_date :date, :default => :today, :allow_blank => false
+  has_time :time, :allow_blank => true
+  has_float :float, :default => 0.0
   has_decimal :dec
 
   def today
     Date.today
   end
 end
-Benchmark.bm do |b|
-  b.report("initialize") do
+
+puts `ruby -v`
+Benchmark.bmbm do |b|
+  b.report("init") do
     30000.times.each  do
       BenchClass.new()
     end
   end
 
-  b.report("initialize with attrs") do
+  b.report("init w/attrs") do
     30000.times.each  do
-      BenchClass.new(:num => 1, :dec => "12.4")
+      BenchClass.new(:foo => nil,
+        :bool => false, 
+        :num => 1, 
+        :dec => "12.4", 
+        :time => Time.now,
+        :float => 1.0
+        )
     end
   end
 
   b.report("get") do
     30000.times.each  do
-      klass = BenchClass.new
-      klass.num
-      klass.dec
-      klass.date
+      bc = BenchClass.new
+      bc.foo
+      bc.bool
+      bc.num
+      bc.dec
+      bc.date
+      bc.time
+      bc.float
+    end
+  end
+
+  b.report("get?") do
+    30000.times.each  do
+      bc = BenchClass.new
+      bc.foo?
+      bc.bool?
+      bc.num?
+      bc.dec?
+      bc.date?
+      bc.time?
+      bc.float?
     end
   end
 
   b.report("set") do
     30000.times.each  do
-      klass = BenchClass.new
-      klass.num = 1
-      klass.dec = '12.4'
-      klass.date = "2014-12-25"
+      bc = BenchClass.new
+      bc.foo = nil
+      bc.bool = true
+      bc.num = 1
+      bc.dec = '12.4'
+      bc.date = "" # check blank
+      bc.time = Time.now
+      bc.float = 10.0
     end
   end
 end
+
+# ruby 2.1.5p273 (2014-11-13 revision 48405) [x86_64-darwin14.0]
+
+# Rehearsal ------------------------------------------------
+# init           1.360000   0.000000   1.360000 (  1.364654)
+# init w/attrs   2.510000   0.000000   2.510000 (  2.512509)
+# get            1.620000   0.000000   1.620000 (  1.619021)
+# get?           1.700000   0.000000   1.700000 (  1.697857)
+# set            2.720000   0.000000   2.720000 (  2.724271)
+# --------------------------------------- total: 9.910000sec
+
+#                    user     system      total        real
+# init           1.350000   0.000000   1.350000 (  1.352561)
+# init w/attrs   2.530000   0.010000   2.540000 (  2.532518)
+# get            1.610000   0.000000   1.610000 (  1.613509)
+# get?           1.690000   0.000000   1.690000 (  1.693701)
+# set            2.700000   0.000000   2.700000 (  2.698375)
+

data/gemfiles/4.2.gemfile

@@ -1,6 +1,6 @@
 source "https://rubygems.org"
 
-gem 'activesupport','~> 4.2.0.rc3'
-gem 'activemodel','~> 4.2.0.rc3'
+gem 'activesupport','~> 4.2.0'
+gem 'activemodel','~> 4.2.0'
 
 gemspec :path => "../"

data/lib/simple_model/attributes.rb

@@ -3,8 +3,26 @@ module SimpleModel
     include ExtendCore
     extend ActiveSupport::Concern
     include ActiveModel::AttributeMethods
+    include ActiveModel::Dirty
+
+    DEFAULT_ATTRIBUTE_SETTINGS = {:attributes_method => :attributes,
+                                  :allow_blank => false,
+                                  :initialize => true
+                                  }.freeze
+
+    AVAILABLE_ATTRIBUTE_METHODS = {
+      :has_attribute => {:alias => :has_attributes, :options => {:allow_blank => true}},
+      :has_boolean  => {:cast_to => :to_b, :alias => :has_booleans, :options =>  {:allow_blank => true, :boolean => true}},
+      :has_currency => {:cast_to => :to_d, :alias => :has_currencies},
+      :has_date => {:cast_to => :to_date, :alias => :has_dates} ,
+      :has_decimal  => {:cast_to => :to_d, :alias => :has_decimals},
+      :has_float => {:cast_to => :to_f, :alias => :has_floats},
+      :has_int => {:cast_to => :to_i, :alias => :has_ints},
+      :has_time => {:cast_to => :to_time, :alias => :has_times}
+    }.freeze
+
     attr_accessor :attributes
-    
+
     def initialize(*attrs)
       attrs = attrs.extract_options!
       attrs = attributes_for_init(attrs)
@@ -36,50 +54,68 @@ module SimpleModel
     end
     alias :set_attributes :set
 
-    def set_attribute(attr,val)
-      options = self.class.defined_attributes[attr] || {}
-      if allow_attribute_action?(val,options)
-        allow_blank = options[:allow_blank]
-        default = options[:default]
-        val = fetch_default_value(default) if (!allow_blank && default && val.blank?)
-        unless (val.blank? && !allow_blank)
-          val = options[:on_set].call(self,val) if options.key?(:on_set)
+    def set_attribute(attr,val,opts=nil)
+      opts ||= fetch_attribute_options(attr)
+      if allow_attribute_action?(val,opts)
+        allow_blank = opts[:allow_blank]
+        val = fetch_default_value(opts[:default]) unless skip_set_default?(attr,opts,val)
+        unless (opts[:boolean] ? (!allow_blank && val.blank? && (val != false)) : (!allow_blank && val.blank?))
+          val = opts[:on_set].call(self,val) if opts.key?(:on_set)
           send("#{attr}_will_change!") if (initialized?(attr) && val != attributes[attr])
           attributes[attr] = val
-          options[:after_set].call(self,val) if options[:after_set]
+          opts[:after_set].call(self,val) if opts[:after_set]
         end
       end
     end
 
-    def get_attribute(attr)
+    def get_attribute(attr,opts=nil)
+      opts ||= fetch_attribute_options(attr)
       val = attributes[attr]
-      options = self.class.defined_attributes[attr] || {}
-      if (options.key?(:default) && (!initialized?(attr) || (!options[:allow_blank] && val.blank?)))
-        val = attributes[attr] = fetch_default_value(options[:default])
-      end
-      if options[:on_get]
-        options[:on_get].call(self,val)
+      val = attributes[attr] ||= fetch_default_value(opts[:default]) unless skip_get_default?(attr,opts,val)
+      if opts[:on_get]
+        opts[:on_get].call(self,val)
       else
         val
       end
     end
 
+    def fetch_attribute_options(attr)
+      self.class.defined_attributes[attr] || {}
+    end
+
     def get_attribute?(attr)
-      return false unless val = get_attribute(attr)
+      return false unless val = send(attr)
       if val.respond_to?(:blank?)
         return !val.blank?
-      elsif val.respond_to?(:to_b) 
+      elsif val.respond_to?(:to_b)
         return val.to_b
       end
       !val.nil?
     end
 
-    private
-
     def attribute_defined?(attr)
       self.class.attribute_defined?(attr)
     end
 
+    # Rails 3.2 + required when searching for attributes in from inherited classes/models
+    def attribute(attr)
+      get_attribute(attr)
+    end
+
+    private
+
+    def skip_get_default?(attr,opts,val)
+      (val || !opts.key?(:default) || (opts[:boolean] && (val == false)))
+    end
+
+    def skip_set_default?(attr,opts,val)
+      return true if (!opts.key?(:default) ||
+                      initialized?(attr) ||
+                      (opts[:boolean] && (val == false)))
+      blnk = val.blank?
+      (!blnk || (blnk && opts[:allow_blank]))
+    end
+
     def fetch_default_value(arg)
       return send(arg) if (arg.is_a?(Symbol) && self.respond_to?(arg))
       arg
@@ -104,57 +140,40 @@ module SimpleModel
     end
 
     def attributes_have_alias?(attrs,attr)
-      !(self.class.alias_attributes.select{ |a, m| (m == attr.to_sym && attrs.key?(a)) }).empty?
+      base_meth = self.class.alias_attributes.rassoc(attr.to_sym)
+      base_meth && attrs.key?(base_meth[0])
+      #!(self.class.alias_attributes.select{ |a, m| (m == attr.to_sym && attrs.key?(a)) }).empty?
     end
 
     def allow_attribute_action?(val,options)
       return true unless (options[:if] || options[:unless])
       b = true
-      opt = options[:if]
-      if opt.is_a?(Symbol)
-        if opt == :blank
-          b = val.blank?
-        else
-          b = send(opt)
+      if opt = options[:if]
+        if opt.is_a?(Symbol)
+          if opt == :blank
+            b = val.blank?
+          else
+            b = send(opt)
+          end
+        elsif opt.is_a?(Proc)
+          b = opt.call(self,val)
         end
-      elsif opt.is_a?(Proc)
-        b = opt.call(self,val)
       end
-      opt = options[:unless]
-      if opt.is_a?(Symbol)
-        if opt == :blank
-          b = !val.blank?
-        else
-          b = !send(opt)
+      if opt = options[:unless]
+        if opt.is_a?(Symbol)
+          if opt == :blank
+            b = !val.blank?
+          else
+            b = !send(opt)
+          end
+        elsif opt.is_a?(Proc)
+          b = !opt.call(self,val)
         end
-      elsif opt.is_a?(Proc)
-        b = !opt.call(self,val)
       end
       b
     end
 
-    # Rails 3.2 + required when searching for attributes in from inherited classes/models
-    def attribute(attr)
-       get_attribute(attr)
-    end
-
     module ClassMethods
-      DEFAULT_ATTRIBUTE_SETTINGS = {:attributes_method => :attributes,
-                                    :allow_blank => false,
-                                    :initialize => true
-                                    }.freeze
-
-      AVAILABLE_ATTRIBUTE_METHODS = {
-        :has_attribute => {:alias => :has_attributes, :options => {:allow_blank => true}},
-        :has_boolean  => {:cast_to => :to_b, :alias => :has_booleans, :options =>  {:allow_blank => true}},
-        :has_currency => {:cast_to => :to_d, :alias => :has_currencies},
-        :has_date => {:cast_to => :to_date, :alias => :has_dates} ,
-        :has_decimal  => {:cast_to => :to_d, :alias => :has_decimals},
-        :has_float => {:cast_to => :to_f, :alias => :has_floats},
-        :has_int => {:cast_to => :to_i, :alias => :has_ints},
-        :has_time => {:cast_to => :to_time, :alias => :has_times}
-      }.freeze
-
       AVAILABLE_ATTRIBUTE_METHODS.each do |method,method_options|
         define_method(method) do |*attributes|
           options = attributes.extract_options!
@@ -163,7 +182,7 @@ module SimpleModel
           options[:on_set] = lambda {|obj,val| val.send(method_options[:cast_to]) } if method_options[:cast_to]
           create_attribute_methods(attributes,options)
         end
-        module_eval("alias #{method_options[:alias]} #{method}")
+        module_eval("alias #{method_options[:alias]} #{method}") if method_options[:alias]
       end
 
       # Creates a new instance where the attributes store is set to object
@@ -251,7 +270,7 @@ module SimpleModel
 
       def define_reader_with_options(attr,options)
         define_method(attr) do
-          get_attribute(attr)
+          get_attribute(attr,options)
         end
         define_method("#{attr}?") do
           get_attribute?(attr)
@@ -263,14 +282,14 @@ module SimpleModel
       # initialized.
       def define_setter_with_options(attr,options)
         define_method("#{attr}=") do |val|
-          set_attribute(attr,val)
+          set_attribute(attr,val,options)
         end
       end
 
       # Creates alias setter and getter for the supplied attribute using the supplied alias
       # See spec for example.
       def alias_attribute(new_alias,attr)
-        
+
         # get to the base attribute
         while alias_attributes[attr]
           attr = alias_attributes[attr]
@@ -331,7 +350,7 @@ module SimpleModel
         base.alias_attributes = alias_attributes.merge(base.alias_attributes)
         super
         # Rails 3.0 Hack
-        if (ActiveModel::VERSION::MAJOR == 3 && ActiveModel::VERSION::MINOR == 0)
+        if (ActiveModel::VERSION::MAJOR == 3 && ActiveModel::VERSION::MINOR < 1)
           base.attribute_method_suffix '_changed?', '_change', '_will_change!', '_was'
           base.attribute_method_affix :prefix => 'reset_', :suffix => '!'
         end
@@ -343,7 +362,6 @@ module SimpleModel
     # ActiveModel::Dirty included
     def self.included(base)
       base.extend(Attributes::ClassMethods)
-      base.send(:include, ActiveModel::Dirty)
       base.send(:include, ActiveModel::Validations)
       base.send(:include, ActiveModel::Conversion)
       base.extend ActiveModel::Naming
@@ -351,7 +369,7 @@ module SimpleModel
       base.send(:include, ActiveModel::Validations::Callbacks)
 
       # Rails 3.0 Hack
-      if (ActiveModel::VERSION::MAJOR == 3 && ActiveModel::VERSION::MINOR == 0)
+      if (ActiveModel::VERSION::MAJOR == 3 && ActiveModel::VERSION::MINOR < 1)
         base.attribute_method_suffix '_changed?', '_change', '_will_change!', '_was'
         base.attribute_method_affix :prefix => 'reset_', :suffix => '!'
       end

data/lib/simple_model/extend_core.rb

@@ -1,7 +1,7 @@
 module SimpleModel
   module ToCurrencyS
     def to_currency_s(symbol='$',rnd=2)
-      cs = self.round(rnd).abs.to_s
+      cs = (rnd ? self.round(rnd) : self).abs.to_s
       while cs.index('.') != (cs.length-3)
         cs << '0'
       end

data/lib/simple_model/version.rb

@@ -1,3 +1,3 @@
 module SimpleModel
-  VERSION = "1.2.26"
+  VERSION = "1.2.27"
 end

data/spec/attributes_spec.rb

@@ -1,335 +1,503 @@
 require 'spec_helper.rb'
 
+class AttributesTest
+  include SimpleModel::Attributes
+end
+
 describe SimpleModel::Attributes do
-  before(:all) do
-    class TestInit
+
+  # We need a clean class for each spec
+  around(:each) do |example|
+    class AttributesTest
       include SimpleModel::Attributes
-      has_attributes :test1,:test2
     end
-    @init = TestInit.new(:test1 => "1", :test2 => '2')
-  end
 
-  it "should set provided attributes on initialize" do
-    @init.test1.should eql("1")
-    @init.test2.should eql("2")
-  end
+    example.run
 
-  it "should include set attributes in attributes hash" do
-    @init.attributes.should be_kind_of(ActiveSupport::HashWithIndifferentAccess)
-    @init.attributes[:test1].should eql("1")
-    @init.attributes[:test2].should eql("2")
+    Object.send(:remove_const,:AttributesTest) if defined?(:AttributesTest)
   end
 
-  context '#before_initialize' do
-    before(:all) do
-      class TestInit
-        include SimpleModel::Attributes
-        # Do not initialize blank attributes
-        self.before_initialize = lambda {|obj,attrs| attrs.select{|k,v| !v.blank?}}
-        has_attribute :far
-      end
-    end
+  context "class methods" do
 
-    it "should raise an exception if we try to set to something other than a Proc" do
-      lambda {TestInit.before_initialize = "bad stuff"}.should raise_error
-    end
+    describe '#create_attribute_methods' do
+      context "no options" do
+        before(:each) do
+          AttributesTest.create_attribute_methods([:has_foo],{})
+        end
 
-    it "should run the supplied lambda" do
-      t = TestInit.new(:far => "")
-      t.initialized?(:far).should eql(false)
-      t = TestInit.new(:far => "t")
-      t.initialized?(:far).should eql(true)
-    end
+        let(:attributes_test) { AttributesTest.new() }
 
-  end
+        it {expect(attributes_test).to respond_to(:has_foo)}
+        it {expect(attributes_test).to respond_to(:has_foo=)}
+        it {expect(attributes_test).to respond_to(:has_foo?)}
+        it "should set the value" do
+          expect(attributes_test.has_foo = "test").to eql("test")
+        end
 
-  context '#after_initialize' do
-    before(:all) do
-      class TestInit
-        include SimpleModel::Attributes
-        # Do not initialize blank attributes
-        self.after_initialize = lambda { |obj| obj.car = "test" if obj.car.blank?}
-        has_attribute :car
+        it "should get the value" do
+          attributes_test.has_foo = "test"
+          expect(attributes_test.has_foo).to eql("test")
+        end
+
+        it "should get? boolean value" do
+          expect(attributes_test).to_not be_has_foo
+          attributes_test.has_foo = "test"
+          expect(attributes_test).to be_has_foo
+        end
       end
-    end
 
-    it "should raise an exception if we try to set to something other than a Proc" do
-      lambda {TestInit.after_initialize = "bad stuff"}.should raise_error
-    end
+      context "options set" do
 
-    it "should run the supplied lambda" do
-      t = TestInit.new(:far => "")
-      t.car.should eql("test")
-    end
+        context "with default" do
 
-  end
+          context "with initialize == true" do
+            before(:each) do
+              AttributesTest.create_attribute_methods([:with_default], {:default => "foo", :initialize => true})
+            end
 
-  context '#new_with_store'do
-    it "should use the provided object as the attribute store" do
-      my_store = {:test1 => 1,:test2 => 2}
-      nw = TestInit.new_with_store(my_store)
-      nw.test1 = 3
-      nw.test1.should eql(3)
-      my_store[:test1].should eql(nw.test1)
-    end
-  end
+            let(:attributes_test) { AttributesTest.new() }
 
-  context "AVAILABLE_ATTRIBUTE_METHODS" do
-    SimpleModel::Attributes::ClassMethods::AVAILABLE_ATTRIBUTE_METHODS.each do |m,options|
-      it "should respond to #{m}" do
-        TestInit.respond_to?(m).should eql(true)
-      end
-      it "should respond to alias #{options[:alias]}" do
-        TestInit.respond_to?(options[:alias]).should eql(true)
-      end
-    end
-  end
+            it "should work" do
+              expect(attributes_test.attributes[:with_default]).to eql('foo')
+            end
+
+          end
+
+          context "with initialize == false" do
+            before(:each) do
+              AttributesTest.create_attribute_methods([:with_default_no_init], {:default => "foo", :initialize => false})
+            end
+
+            let(:attributes_test) { AttributesTest.new() }
+
+            it "should work" do
+              expect(attributes_test.attributes).to_not have_key(:with_default_no_init)
+            end
+
+            it "should set on get" do
+              expect(attributes_test.with_default_no_init).to eql('foo')
+            end
+          end
+
+          context "set to a symbol for a method" do
+            before(:each) do
+              AttributesTest.send(:define_method, :default_method) do
+                Date.today
+              end
+
+              AttributesTest.create_attribute_methods([:with_default_method], {:default => :default_method})
+            end
+            let(:attributes_test) { AttributesTest.new() }
+
+            it { expect(attributes_test.with_default_method).to eql(Date.today) }
+          end
 
-  context '#has_attribute' do
-    before(:all) do
-      class TestDefault
-        include SimpleModel::Attributes
-        has_attribute :foo, :default => "foo", :allow_blank => false
-        has_attribute :bar, :default => :default_value
-        has_attribute :fab, :default => :some_symbol
-        has_attribute :hop, :default => :default_hop, :allow_blank => false
-        has_attribute :tip, :default => "2", :initialize => false, :allow_blank => false
-        has_attribute :nap
-        has_attribute :my_array, :default => []
-        def default_value
-          "bar"
+          context "set to a non-method symbol" do
+            before(:each) do
+              AttributesTest.create_attribute_methods([:with_default_sym], {:default => :_foo})
+            end
+
+            let(:attributes_test) { AttributesTest.new() }
+
+            it { expect(attributes_test.with_default_sym).to eql(:_foo) }
+          end
+        end
+
+        context "with on_set" do
+          before(:each) do
+            AttributesTest.create_attribute_methods([:with_on_set], {:on_set => lambda {|obj,val| val.to_i } })
+          end
+
+          let(:attributes_test) { AttributesTest.new(:with_on_set => "1") }
+
+          it {expect(attributes_test.with_on_set).to eql(1)}
+        end
+
+        context "with allow_blank == false" do
+          before(:each) do
+            AttributesTest.create_attribute_methods([:prevent_blank], {:allow_blank =>  false})
+          end
+
+          let(:attributes_test) { AttributesTest.new(:prevent_blank => "") }
+
+          it "should not initialize" do
+            expect(attributes_test.attributes).to_not have_key(:prevent_blank)
+          end
+
+          it "should allow setting with non-blank value" do
+            attributes_test.prevent_blank = "not blank"
+            expect(attributes_test.prevent_blank).to eql("not blank")
+            attributes_test.prevent_blank = nil
+            expect(attributes_test.prevent_blank).to eql("not blank")
+            attributes_test.prevent_blank = 1
+            expect(attributes_test.prevent_blank).to eql(1)
+          end
+        end
+
+        context "with allow_blank == false and boolean == true" do
+          before(:each) do
+            AttributesTest.create_attribute_methods([:allow_false_boolean], {:allow_blank => false, :boolean => true})
+          end
+          let(:attributes_test) { AttributesTest.new(:allow_false_boolean => "") }
+
+          it "should not initialize" do
+            expect(attributes_test.attributes).to_not have_key(:allow_false_boolean)
+          end
+
+          it "should allow setting with non-blank value" do
+            attributes_test.allow_false_boolean = 1
+            expect(attributes_test.allow_false_boolean).to eql(1)
+            attributes_test.allow_false_boolean = nil
+            expect(attributes_test.allow_false_boolean).to eql(1)
+            attributes_test.allow_false_boolean = false
+            expect(attributes_test.allow_false_boolean).to eql(false)
+          end
         end
 
-        def default_hop
-          "hop" if nap
+        context "with :if" do
+          context "set to a proc" do
+            before(:each) do
+              AttributesTest.has_date :if_proc, :if => lambda {|obj,val| !val.blank?}
+            end
+
+            it {expect(AttributesTest.new(:if_proc => nil)).to_not be_initialized(:if_proc)}
+
+            it {expect(AttributesTest.new(:if_proc => "2014-05-01")).to be_initialized(:if_proc)}
+          end
+
+          context "set to a :blank" do
+            before(:each) do
+              AttributesTest.has_attribute :if_blank, :if => :blank
+            end
+            it "init" do
+              init = AttributesTest.new(:if_blank => "")
+              expect(init).to be_initialized(:if_blank)
+
+            end
+            it {expect(AttributesTest.new(:if_blank => nil)).to be_initialized(:if_blank)}
+            it {expect(AttributesTest.new(:if_blank => "foo")).to_not be_initialized(:if_blank)}
+
+          end
+
+          context "set to a symbol" do
+            before(:each) do
+              AttributesTest.has_attribute :if_attr_1, :if => :if_true
+              AttributesTest.has_attribute :if_attr_2, :if => :if_false
+
+              AttributesTest.send :define_method, :if_true do
+                true
+              end
+
+              AttributesTest.send :define_method, :if_false do
+                false
+              end
+            end
+
+            let(:attributes_test) { AttributesTest.new(:if_attr_1 => "test", :if_attr_2 => "test" ) }
+            it {expect(attributes_test).to be_initialized(:if_attr_1)}
+            it {expect(attributes_test).to_not be_initialized(:if_attr_2)}
+          end
         end
+
+        context "with :unless" do
+          context "set to a proc" do
+            before(:each) do
+              AttributesTest.has_date :unless_proc, :unless => lambda {|obj,val| val.blank?}
+            end
+
+            it {expect(AttributesTest.new(:unless_proc => nil)).to_not be_initialized(:unless_proc)}
+
+            it {expect(AttributesTest.new(:unless_proc => "2014-05-01")).to be_initialized(:unless_proc)}
+          end
+
+          context "set to a :blank" do
+            before(:each) do
+              AttributesTest.has_attribute :unless_blank, :unless => :blank
+            end
+
+            it {expect(AttributesTest.new(:unless_blank => "")).to_not be_initialized(:unless_blank)}
+            it {expect(AttributesTest.new(:unless_blank => nil)).to_not be_initialized(:unless_blank)}
+            it {expect(AttributesTest.new(:unless_blank => "foo")).to be_initialized(:unless_blank)}
+
+          end
+
+          context "set to a symbol" do
+            before(:each) do
+              AttributesTest.has_attribute :unless_attr_1, :unless => :unless_true
+              AttributesTest.has_attribute :unless_attr_2, :unless => :unless_false
+
+              AttributesTest.send :define_method, :unless_true do
+                true
+              end
+
+              AttributesTest.send :define_method, :unless_false do
+                false
+              end
+            end
+
+            let(:attributes_test) { AttributesTest.new(:unless_attr_1 => "test", :unless_attr_2 => "test" ) }
+            it {expect(attributes_test).to_not be_initialized(:unless_attr_1)}
+            it {expect(attributes_test).to be_initialized(:unless_attr_2)}
+          end
+        end
+      end # end with options
+    end # end #create_attribute_methods
+
+    describe '#has_attribute' do
+      it {expect(AttributesTest).to respond_to(:has_attribute)}
+
+      before(:each) do
+        AttributesTest.has_attribute(:test_attr)
       end
 
-    end
+      let(:attributes_test) { AttributesTest.new() }
 
-    before(:each) do
-      @default = TestDefault.new
-    end
+      it {expect(attributes_test).to respond_to(:test_attr)}
 
-    it "should define setter method" do
-      @default.respond_to?(:foo=).should eql(true)
     end
 
-    it "should define reader/getter method" do
-      @default.respond_to?(:foo).should eql(true)
-    end
+    describe '#has_boolean' do
+      it {expect(AttributesTest).to respond_to(:has_boolean)}
 
-    context ':initialize => false' do
-      it "should not initialize with the default value" do
-        @default.attributes[:tip].should be_nil
-        @default.tip.should eql("2")
+      before(:each) do
+        AttributesTest.has_boolean(:test_bool)
       end
-      context "allow_blank => false"do
-        it "should not initialize, but should set the value on get" do
-          @default.attributes[:tip].should be_nil
-          @default.tip.should eql("2")
-        end
+      let(:attributes_test) { AttributesTest.new() }
+
+      it {expect(attributes_test).to respond_to(:test_bool)}
+
+      it "should cast to a boolean" do
+        attributes_test.test_bool = "false"
+        expect(attributes_test.test_bool).to eql(false)
+
+        attributes_test.test_bool = "true"
+        expect(attributes_test.test_bool).to eql(true)
       end
     end
 
-    it "should call the method it describe by the default value if it exists" do
-      @default.attributes[:bar].should eql("bar")
-    end
+    describe '#has_date' do
+      it {expect(AttributesTest).to respond_to(:has_date)}
 
-    it "should set the default to the supplied symbol, if the method does not exist" do
-      @default.attributes[:fab].should eql(:some_symbol)
-    end
+      before(:each) do
+        AttributesTest.has_date(:test_date)
+      end
 
-    it "should allow default value to be an empty array" do
-      @default.my_array.should eql([])
-    end
+      let(:attributes_test) { AttributesTest.new() }
 
-    it "should create a boolean? method for each attribute" do
-      @default.respond_to?(:foo?).should eql(true)
-    end
+      it {expect(attributes_test).to respond_to(:test_date)}
 
-    it "should return !blank?" do
-      @default.my_array.should eql([]) # blank array
-      @default.my_array?.should eql(false)
-      @default.my_array << 1
-      @default.my_array?.should eql(true)
+      it "should cast to a date" do
+        attributes_test.test_date = "2014-12-22"
+        expect(attributes_test.test_date).to be_a(Date)
+      end
     end
 
-    it "should not allow blank if set" do
-      @default.foo.should eql("foo")
-      @default.foo = ""
-      @default.foo.should eql("foo")
-      @default.foo = "not blank"
-      @default.foo.should eql("not blank")
-    end
+    describe '#has_decimal' do
+      it {expect(AttributesTest).to respond_to(:has_decimal)}
+
+      before(:each) do
+        AttributesTest.has_decimal(:test_deci)
+      end
 
-    it "should try for the default if its blank on get" do
-      @default.hop.blank?.should eql(true)
-      @default.nap = "yep"
-      @default.hop.should eql("hop")
+      let(:attributes_test) { AttributesTest.new() }
+
+      it {expect(attributes_test).to respond_to(:test_deci)}
+
+      it "should cast to a decimal" do
+        attributes_test.test_deci = "1.0"
+        expect(attributes_test.test_deci).to be_a(BigDecimal)
+      end
     end
-  end
 
-  context 'number and date/time attributes' do
-    before(:all) do
-      class NumDateTime
-        include SimpleModel::Attributes
-        has_date :my_date
-        has_time :my_time
-        has_int :my_int
-        has_int :blank_int, :allow_blank => true
-        has_decimal :my_decimal
-        has_decimal :blank_decimal, :allow_blank => true
-        has_float :my_float
-        has_attribute :my_attr
-        has_boolean :my_boolean
+    describe '#has_float' do
+      it {expect(AttributesTest).to respond_to(:has_float)}
+
+      before(:each) do
+        AttributesTest.has_float(:test_float)
+      end
+
+      let(:attributes_test) { AttributesTest.new() }
+
+      it {expect(attributes_test).to respond_to(:test_float)}
+
+      it "should cast to a float" do
+        attributes_test.test_float = "1.0"
+        expect(attributes_test.test_float).to be_a(Float)
       end
     end
-    context "default options for number attributes" do
-      context "set with blank value" do
-        it "should not initialize" do
-          num_date_time = NumDateTime.new(:my_date => nil, :my_time => "", :my_int => " ", :my_decimal => nil, :my_float => '')
-          expect(num_date_time.initialized?(:my_date)).to eql(false)
-          expect(num_date_time.initialized?(:my_time)).to eql(false)
-          expect(num_date_time.initialized?(:my_int)).to eql(false)
-          expect(num_date_time.initialized?(:my_decimal)).to eql(false)
-          expect(num_date_time.initialized?(:my_float)).to eql(false)
-        end
+
+    describe '#has_int' do
+      it {expect(AttributesTest).to respond_to(:has_int)}
+
+      before(:each) do
+        AttributesTest.has_int(:test_int)
       end
-      context "override to allow_blank" do
-        it "should not initialize" do
-          num_date_time = NumDateTime.new(:blank_int => nil, :blank_decimal => "")
-          expect(num_date_time.initialized?(:blank_int)).to eql(true)
-          expect(num_date_time.initialized?(:blank_decimal)).to eql(true)
-        end
+
+      let(:attributes_test) { AttributesTest.new() }
+
+      it {expect(attributes_test).to respond_to(:test_int)}
+
+      it "should cast to a float" do
+        attributes_test.test_int = "1"
+        expect(attributes_test.test_int).to be_a(Fixnum)
       end
     end
 
-    context "set with blank value" do
-      it "should not initialize" do
-        num_date_time = NumDateTime.new(:my_attr => nil, :my_boolean => "")
-        expect(num_date_time.initialized?(:my_attr)).to eql(true)
-        expect(num_date_time.initialized?(:my_boolean)).to eql(true)
+    describe '#has_time' do
+      it {expect(AttributesTest).to respond_to(:has_time)}
+
+      before(:each) do
+        AttributesTest.has_time(:test_time)
+      end
+
+      let(:attributes_test) { AttributesTest.new() }
+
+      it {expect(attributes_test).to respond_to(:test_time)}
+
+      it "should cast to a date" do
+        attributes_test.test_time = "2014-12-22"
+        expect(attributes_test.test_time).to be_a(Time)
       end
     end
-  end
 
-  context 'options with conditional' do
-    before(:all) do
-      class WithConditional
-        include SimpleModel::Attributes
-        has_date :my_date, :if => lambda {|obj,val| !val.blank?}
-        has_date :my_other_date, :unless => :blank
+    describe '#alias_attribute' do
+      before(:each) do
+        AttributesTest.has_attribute :base_foo
+        AttributesTest.alias_attribute :alias_foo, :base_foo
+      end
+
+      context "attribute is not defined" do
+        it { expect {AttributesTest.alias_attribute :alias_foo, :nope}.to raise_error(SimpleModel::UndefinedAttribute) }
+      end
+
+      it "should work" do
+        test_alias = AttributesTest.new(:alias_foo => "foo")
+        expect(test_alias.alias_foo).to eql("foo")
+        expect(test_alias.base_foo).to eql("foo")
       end
     end
-    it "should not raise error" do
-      new = WithConditional.new(:my_date => nil)
-      new.initialized?(:my_date).should eql(false)
+
+  end # end class methods
+
+
+
+  context "initializing" do
+
+    before(:each) do
+      AttributesTest.has_attributes :test1,:test2
     end
 
-    it "should call blank on val if :blank is supplied" do
-      new = WithConditional.new(:my_other_date => nil)
-      new.initialized?(:my_other_date).should eql(false)
+    let(:init_test) { AttributesTest.new(:test1 => '1', :test2 => '2') }
+
+
+    it { expect(init_test.test1).to eql('1') }
+    it { expect(init_test.test2).to eql('2') }
+
+    describe '#attributes' do
+      it { expect(init_test).to respond_to(:attributes) }
+      it { expect(init_test.attributes).to be_a(HashWithIndifferentAccess)}
     end
-  end
 
-  context "on get" do
-    it "should perform on_get when set" do
-      class OnGet
-        include SimpleModel::Attributes
-        has_attribute :foo, :on_get => lambda{|obj,attr| (attr.blank? ? obj.send(:foo_default) : attr)}
 
-        def foo_default
-          "test"
-        end
+
+    describe '#before_initialize' do
+
+      context "before_initialize is not a Proc" do
+        it { expect {AttributesTest.before_initialize = "bad stuff"}.to raise_error }
       end
 
-      new = OnGet.new
-      new.foo.should eql("test")
-      new.foo = "foo"
-      new.foo.should eql("foo")
-    end
-  end
+      before(:each) do
+        # Do not initialize blank attributes
+        AttributesTest.before_initialize = lambda {|obj,attrs| attrs.select{|k,v| !v.blank?}}
+        AttributesTest.has_attribute :before_init
+      end
 
-  context 'if supplied value can be cast' do
-    before(:all) do
-      class TestAlias
-        include SimpleModel::Attributes
-        has_attribute :foo, :default => "bar"
-        alias_attribute(:bar,:foo)
+      it "should work" do
+        expect(AttributesTest.new(:before_init => "")).to_not be_initialized(:before_init)
+        expect(AttributesTest.new(:before_init => "t")).to be_initialized(:before_init)
       end
+
     end
-    context '#alias_attribute' do
-      it "should create alias for attribute" do
-        t = TestAlias.new(:bar => "foo")
-        t.bar.should eql("foo")
-        t.foo.should eql('foo')
-        t = TestAlias.new(:foo => "foo")
-        t.bar.should eql("foo")
-        t.foo.should eql('foo')
+
+    describe '#after_initialize' do
+
+      context "before_initialize is not a Proc" do
+        it { expect {AttributesTest.after_initialize = "bad stuff"}.to raise_error }
       end
-    end
-  end
 
-  context "regression tests" do
-    before(:all) do
-      class MyBase
-        include SimpleModel::Attributes
-        has_boolean :bar
-        has_attribute :str, :stuff
-        has_currency :amount, :default => BigDecimal("0.0"), :initialize => false
-        has_dates :some, :thing, :default => :fetch_date, :allow_blank => false, :initialize => false
-        alias_attribute :other, :bar
-        alias_attribute :other_amount, :amount
-
-        def fetch_date
-          Date.today
-        end
+      before(:each) do
+        # Do not initialize blank attributes
+        AttributesTest.after_initialize = lambda { |obj| obj.after_init = "test" if obj.after_init.blank?}
+        AttributesTest.has_attribute :after_init
       end
 
-      class NewerBase < MyBase
-        has_boolean :foo
-        has_int :str
+      it "should work" do
+        expect(AttributesTest.new(:after_init => "").after_init).to eql("test")
       end
 
-      class NewestBase < NewerBase
-        alias_attribute :some_amount, :other_amount
+    end
+
+    describe '#new_with_store'do
+      it "should work" do
+        my_store = {:test1 => 1,:test2 => 2}
+        nw = AttributesTest.new_with_store(my_store)
+        expect(AttributesTest.new_with_store(my_store).attributes.object_id).to eql(my_store.object_id)
       end
+    end
 
+  end
+
+  context "inheritance" do
+    class MyBase
+      include SimpleModel::Attributes
+      has_boolean :bar
+      has_attribute :str, :stuff
+      has_currency :amount, :default => BigDecimal("0.0"), :initialize => false
+      has_dates :some, :thing, :default => :fetch_date, :allow_blank => false, :initialize => false
+      alias_attribute :other, :bar
+      alias_attribute :other_amount, :amount
+
+      def fetch_date
+        Date.today
+      end
     end
+
+    class NewerBase < MyBase
+      has_boolean :foo
+      has_int :str
+    end
+
+    class NewestBase < NewerBase
+      alias_attribute :some_amount, :other_amount
+    end
+
     it "should merge defined attributes when class are inherited" do
-      NewerBase.attribute_defined?(:bar).should eql(true)
-      n = NewerBase.new
-      n.respond_to?(:bar_will_change!).should eql(true)
+      expect(NewerBase).to be_attribute_defined(:bar)
+      newer_base = NewerBase.new
+      expect(newer_base).to respond_to(:bar_will_change!)
     end
 
     it "should set defaults that were not initialized should work from parent class" do
-      n = NewerBase.new
-      n.some.should eql(n.send(:fetch_date))
-      n.thing.should eql(n.send(:fetch_date))
+      newer_base = NewerBase.new
+      expect(newer_base.some).to eql(newer_base.send(:fetch_date))
+      expect(newer_base.thing).to eql(newer_base.send(:fetch_date))
     end
 
     it "should allow redefining methods in child classes" do
-      n = NewerBase.new
-      n.str = '1'
-      n.str.should eql(1)
+      newer_base = NewerBase.new
+      newer_base.str = '1'
+      expect(newer_base.str).to eql(1)
     end
 
     it "should set attribute from alias" do
-      MyBase.new(:other => true).bar?.should eql(true)
-      NewerBase.new(:other => true).bar?.should eql(true)
+      expect(MyBase.new(:other => true)).to be_bar
+      expect(NewerBase.new(:other => true)).to be_bar
     end
 
     it "should properly alias attributes from parent class" do
-      nb =  NewestBase.new(:some_amount => 1.0)
-      nb.other_amount.should eql(1.0.to_d)
-      nb.amount.should eql(1.0.to_d)
-    end
-  end
-
-  after(:all) do
-    [:OnGet,:TestDefault,:TestInit,:MyBase,:NewerBase].each do |test_klass|
-      Object.send(:remove_const,test_klass) if defined?(test_klass)
+      newer_base =  NewestBase.new(:some_amount => 1.0)
+      expect(newer_base.other_amount).to eql(1.0.to_d)
+      expect(newer_base.amount).to eql(1.0.to_d)
     end
   end
 end