simple_model 1.2.5 → 1.2.7

data/Gemfile

@@ -2,5 +2,4 @@ source "http://rubygems.org"
 
 
 # Specify your gem's dependencies in simple_model.gemspec
-gemspec
-
+gemspec

data/lib/simple_model/attributes.rb

@@ -1,13 +1,15 @@
-require 'simple_model/exceptions'
 module SimpleModel
   module Attributes
     include ExtendCore
     extend ActiveSupport::Concern
     include ActiveModel::AttributeMethods 
-    
+      
     def initialize(*attrs)     
       attrs = attrs.extract_options! 
-      set(attributes_with_for_init(attrs))
+      attrs = attributes_with_for_init(attrs)
+      attrs = self.class.before_initialize.call(self,attrs) if self.class.before_initialize
+      set(attrs)
+      self.class.after_initialize.call(self) if self.class.after_initialize
     end
     
     # Returns true if attribute has been initialized
@@ -59,6 +61,35 @@ module SimpleModel
     def allow_set_default?(d,k,v)
       (v[:default] && v[:initialize] && (d[k].blank? && (self.class.alias_attributes[k].blank? || d.key?(self.class.alias_attributes[k]) && d[self.class.alias_attributes[k]].blank?)))
     end
+    
+    private
+    
+    def allow_attribute_action?(obj,val,options)
+      return true if (options[:if].blank? && options[:unless].blank?)
+      b = true
+      if options[:if].is_a?(Symbol)
+        if options[:if] == :blank
+          b =  (b && val.blank?)
+        else
+          b = (b && send(options[:if]))
+        end
+      end
+      b = (b && options[:if].call(obj,val)) if options[:if].is_a?(Proc)
+      if options[:unless].is_a?(Symbol)
+        if options[:unless] == :blank
+          b = (b && !val.blank?)
+        else
+          b = (b && !send(options[:unless]))
+        end
+      end
+      b = (b && !options[:unless].call(obj,val)) if options[:unless].is_a?(Proc)
+      b
+    end
+    
+    # Rails 3.2 + required when searching for attributes in from inherited classes/cmodles
+    def attribute(name)
+      attributes[name.to_sym]
+    end
        
     module ClassMethods  
       # Creates a new instance where the attributes store is set to object
@@ -123,8 +154,8 @@ module SimpleModel
       # re-run to occur ONLY IN RAILS 3.0.
       def add_defined_attribute(attr,options)
         self.defined_attributes[attr] = options
-        @attribute_methods_generated = nil if (ActiveModel::VERSION::MAJOR == 3 && ActiveModel::VERSION::MINOR == 0)
-        define_attribute_methods self.defined_attributes.keys
+        @attribute_methods_generated = nil #if (ActiveModel::VERSION::MAJOR == 3 && ActiveModel::VERSION::MINOR == 0)
+        define_attribute_methods(self.defined_attributes.keys)
       end
       
       # builds the setter and getter methods
@@ -141,10 +172,11 @@ module SimpleModel
         add_defined_attribute(attr,options)
         options = default_attribute_settings.merge(options) if options[:on_get].blank?
         define_method(attr) do
-          if (options.key?(:default) && (!self.initialized?(attr) || (!options[:allow_blank] && self.attributes[attr].blank?)))
-            self.attributes[attr] = fetch_default_value(options[:default])
+          val = self.attributes[attr]
+          if (options.key?(:default) && (!self.initialized?(attr) || (!options[:allow_blank] && val.blank?)))
+            val = self.attributes[attr] = fetch_default_value(options[:default])
           end
-          options[:on_get].call(self,self.attributes[attr])
+          options[:on_get].call(self,val)
         end
         define_method("#{attr.to_s}?") do
           val = self.send(attr)
@@ -164,16 +196,14 @@ module SimpleModel
         add_defined_attribute(attr,options)
         options = default_attribute_settings.merge(options) if (options[:on_set].blank? || options[:after_set].blank?) 
         define_method("#{attr.to_s}=") do |val|
-          val = fetch_default_value(options[:default]) if (!options[:allow_blank] && options.key?(:default) && val.blank?)
-          begin   
-            val = options[:on_set].call(self,val)
-          rescue NoMethodError => e
-            raise ArgumentError, "#{val} could not be set for #{attr}: #{e.message}"
+          if allow_attribute_action?(self,val,options)
+            val = fetch_default_value(options[:default]) if (!options[:allow_blank] && options.key?(:default) && val.blank?)   
+            val = options[:on_set].call(self,val) unless (val.blank? && !options[:allow_blank] )
+            will_change = "#{attr}_will_change!".to_sym
+            self.send(will_change) if (initialized?(attr) && val != self.attributes[attr])       
+            self.attributes[attr] = val
+            options[:after_set].call(self,val) if options[:after_set] 
           end
-          will_change = "#{attr}_will_change!".to_sym
-          self.send(will_change) if (initialized?(attr) && val != self.attributes[attr])       
-          self.attributes[attr] = val
-          options[:after_set].call(self,val) if options[:after_set] 
         end
       end
     
@@ -181,14 +211,14 @@ module SimpleModel
         :has_attribute => {:alias => :has_attributes},
         :has_boolean  => {:cast_to => :to_b, :alias => :has_booleans},
         :has_currency => {:cast_to => :to_d, :alias => :has_currencies},
-        :has_date => {:cast_to => :to_date, :alias => :has_dates}, 
+        :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}  
       }
       
-      AVAILABLE_ATTRIBUTE_METHODS.each do |method,method_options|   
+      AVAILABLE_ATTRIBUTE_METHODS.each do |method,method_options|
         define_method(method) do |*attributes|
           options = default_attribute_settings.merge(attributes.extract_options!)
           options[:on_set] = lambda {|obj,val| val.send(method_options[:cast_to]) } if method_options[:cast_to]
@@ -209,20 +239,57 @@ module SimpleModel
         end
       end
       
+      # A hook to perform actions on the pending attributes or the object before
+      # the pending attributes have been initialized.
+      # Expects an lambda that accept the object, the pending attributes hash and
+      # should return a hash to be set
+      # EX: lambda {|obj,attrs| attrs.select{|k,v| !v.blank?}}
+      def before_initialize
+        @before_initialize
+      end
+      
+      # Expects an lambda that accept the object, the pending attributes hash and
+      # should return a hash to be set
+      # EX: lambda {|obj,attrs| attrs.select{|k,v| !v.blank?}}  
+      def before_initialize=before_initialize
+        raise TypeError "before_initialize must be a lambda that accepts the attirbutes to be initialize" unless before_initialize.is_a?(Proc)
+        @before_initialize = before_initialize
+      end
+    
+      # A hook to perform actions after all attributes have been initialized
+      # Expects an lambda that accept the object and the pending attributes hash
+      # EX: lambda{|obj| puts "initialized"}
+      def after_initialize
+        @after_initialize
+      end
+      
+      # Expects an lambda that accept the object and the pending attributes hash
+      # EX: lambda{|obj| puts "initialized"}
+      def after_initialize=after_initialize
+        raise TypeError "after_initalize must be a Proc" unless after_initialize.is_a?(Proc)
+        @after_initialize = after_initialize
+      end
+      
+      
+      
       # Must inherit super's defined_attributes and alias_attributes
       # Rails 3.0 does some weird stuff with ActiveModel::Dirty so we need a
       # hack to keep things working when a class in inherits from a super that 
       # has ActiveModel::Dirty included
       def inherited(base)
         # Rails 3.0 Hack
-        if (ActiveModel::VERSION::MAJOR == 3 && ActiveModel::VERSION::MINOR == 0)
-          base.send(:include, ActiveModel::Dirty)
+        if (ActiveModel::VERSION::MAJOR == 3 && ActiveModel::VERSION::MINOR == 0)    
           base.attribute_method_suffix '_changed?', '_change', '_will_change!', '_was'
           base.attribute_method_affix :prefix => 'reset_', :suffix => '!'
         end
+        base.send(:include, ActiveModel::Dirty)
+
+        self.defined_attributes.each do |attr,options|
+          base.create_attribute_methods([attr],options)
+        end
         
-        base.defined_attributes = self.defined_attributes.merge(base.defined_attributes)
         base.alias_attributes = self.alias_attributes.merge(base.alias_attributes ) 
+        super
       end
     end
     
@@ -240,8 +307,8 @@ module SimpleModel
       
       # Rails 3.0 Hack
       if (ActiveModel::VERSION::MAJOR == 3 && ActiveModel::VERSION::MINOR == 0)
-          base.attribute_method_suffix '_changed?', '_change', '_will_change!', '_was'
-          base.attribute_method_affix :prefix => 'reset_', :suffix => '!'
+        base.attribute_method_suffix '_changed?', '_change', '_will_change!', '_was'
+        base.attribute_method_affix :prefix => 'reset_', :suffix => '!'
       end
     end
   end

data/lib/simple_model/base.rb

@@ -154,7 +154,7 @@ require 'active_support/core_ext/object/blank'
       default_options.merge!(methods.extract_options!)
       actions = [action,"#{action}!".to_sym]
       actions.each do |a|
-        define_method(a) do |opts={}|
+        define_method(a) do |opts = {}|
           options = default_options.merge(opts)
           options[:raise_exception] = a.to_s.match(/\!$/)
           self.run_callbacks(action) do  

data/lib/simple_model/exceptions.rb

@@ -1,5 +1,4 @@
 module SimpleModel
   class ActionError < StandardError; end
   class ValidationError < StandardError; end
-  class ArgumentError < StandardError; end  
 end

data/lib/simple_model/version.rb

@@ -1,3 +1,3 @@
 module SimpleModel
-  VERSION = "1.2.5"
+  VERSION = "1.2.7"
 end

data/spec/attributes_spec.rb

@@ -9,7 +9,7 @@ describe SimpleModel::Attributes do
     @init = TestInit.new(:test1 => "1", :test2 => '2')
   end
 
-  it "should set provided attributes on initialize" do   
+  it "should set provided attributes on initialize" do
     @init.test1.should eql("1")
     @init.test2.should eql("2")
   end
@@ -19,7 +19,51 @@ describe SimpleModel::Attributes do
     @init.attributes[:test1].should eql("1")
     @init.attributes[:test2].should eql("2")
   end
-  
+
+  context '#before_initialize' do
+    before(:all) do
+      class TestInit
+        include SimpleModel::Attributes
+        # Do not initalize blank attributes
+        self.before_initialize = lambda {|obj,attrs| attrs.select{|k,v| !v.blank?}}
+        has_attribute :far
+      end
+    end
+
+    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
+
+    it "should run the supplied lambda" do
+      t = TestInit.new(:far => "")
+      t.initialized?(:far).should be_false
+      t = TestInit.new(:far => "t")
+      t.initialized?(:far).should be_true
+    end
+
+  end
+
+  context '#after_initialize' do
+    before(:all) do
+      class TestInit
+        include SimpleModel::Attributes
+        # Do not initalize blank attributes
+        self.after_initialize = lambda { |obj| obj.car = "test" if obj.car.blank?}
+        has_attribute :car
+      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
+
+    it "should run the supplied lambda" do
+      t = TestInit.new(:far => "")
+      t.car.should eql("test")
+    end
+
+  end
+
   context '#new_with_store'do
     it "should use the provided object as the attribute store" do
       my_store = {:test1 => 1,:test2 => 2}
@@ -29,7 +73,7 @@ describe SimpleModel::Attributes do
       my_store[:test1].should eql(new.test1)
     end
   end
-  
+
   context "AVAILABLE_ATTRIBUTE_METHODS" do
     SimpleModel::Attributes::ClassMethods::AVAILABLE_ATTRIBUTE_METHODS.each do |m,options|
       it "should respond to #{m}" do
@@ -55,14 +99,14 @@ describe SimpleModel::Attributes do
         def default_value
           "bar"
         end
-        
+
         def default_hop
           "hop" if nap
         end
       end
-      
+
     end
-    
+
     before(:each) do
       @default = TestDefault.new
     end
@@ -70,11 +114,11 @@ describe SimpleModel::Attributes do
     it "should define setter method" do
       @default.respond_to?(:foo=).should be_true
     end
-  
+
     it "should define reader/getter method" do
       @default.respond_to?(:foo).should be_true
     end
-    
+
     context ':initialize => false' do
       it "should not initialize with the default value" do
         @default.attributes[:tip].should be_nil
@@ -87,30 +131,30 @@ describe SimpleModel::Attributes do
         end
       end
     end
-    
-    it "should call the method it describe by the default value if it exists" do 
+
+    it "should call the method it describe by the default value if it exists" do
       @default.attributes[:bar].should eql("bar")
     end
-    
-    it "should set the defaul to the supplied symbol, if the method does not exist" do 
+
+    it "should set the defaul to the supplied symbol, if the method does not exist" do
       @default.attributes[:fab].should eql(:some_symbol)
     end
-    
+
     it "should allow default value to be an empty array" do
       @default.my_array.should eql([])
     end
-    
+
     it "should create a boolean? method for each attribute" do
       @default.respond_to?(:foo?).should be_true
     end
-    
+
     it "should return !blank?" do
       @default.my_array.should eql([]) # blank array
       @default.my_array?.should be_false
       @default.my_array << 1
       @default.my_array?.should be_true
     end
-    
+
     it "should not allow blank if set" do
       @default.foo.should eql("foo")
       @default.foo = ""
@@ -118,51 +162,61 @@ describe SimpleModel::Attributes do
       @default.foo = "not blank"
       @default.foo.should eql("not blank")
     end
-    
+
     it "should try for the default if its blank on get" do
       @default.hop.blank?.should be_true
       @default.nap = "yep"
       @default.hop.should eql("hop")
     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
+      end
+    end
+    it "should not raise error" do
+      new = WithConditional.new(:my_date => nil)
+      new.initialized?(:my_date).should be_false
+    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 be_false
+    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
       end
-      
+
       new = OnGet.new
       new.foo.should eql("test")
       new.foo = "foo"
       new.foo.should eql("foo")
     end
   end
-  
+
   context 'if supplied value can be cast' do
-    it "should throw an exception" do  
-      class TestThrow
+    before(:all) do
+      class TestAlias
         include SimpleModel::Attributes
-        has_booleans :boo
-      end 
-      
-      lambda{TestThrow.new(:boo => [])}.should raise_error(SimpleModel::ArgumentError)
+        has_attribute :foo, :default => "bar"
+        alias_attribute(:bar,:foo)
+      end
     end
     context '#alias_attribute' do
       it "should create alias for attribute" do
-        class TestAlias
-          include SimpleModel::Attributes
-          has_attribute :foo, :default => "bar"
-          alias_attribute(:bar,:foo)
-        end
-      
         t = TestAlias.new(:bar => "foo")
         t.bar.should eql("foo")
         t.foo.should eql('foo')
@@ -170,29 +224,49 @@ describe SimpleModel::Attributes do
         t.bar.should eql("foo")
         t.foo.should eql('foo')
       end
-    end   
+    end
   end
-  
+
   context "regression tests" do
-    it "should merge defined attributes when class are inhereted" do
+    before(:all) do
       class MyBase
         include SimpleModel::Attributes
         has_boolean :bar
+        has_attribute :str
+        has_dates :some, :thing, :default => :fetch_date, :allow_blank => false, :initialize => false
+
+        def fetch_date
+          Date.today
+        end
       end
-    
+
       class NewerBase < MyBase
         has_boolean :foo
+        has_int :str
       end
-    
+    end
+    it "should merge defined attributes when class are inhereted" do
       NewerBase.defined_attributes[:bar].blank?.should be_false
       n = NewerBase.new
       n.respond_to?(:bar_will_change!).should be_true
     end
+
+    it "should defaults that were not initialized should work from parent class" do
+      n = NewerBase.new
+      n.some.should eql(Date.today)
+      n.thing.should eql(Date.today)
+    end
+
+    it "should allow redefining methods in child classes" do
+      n = NewerBase.new
+      n.str = '1'
+      n.str.should eql(1)
+    end
   end
-  
+
   after(:all) do
-    [:TestThrow,:OnGet,:TestDefault,:TestInit,:MyBase,:NewerBase].each do |test_klass|
-      Object.send(:remove_const,test_klass)
+    [:OnGet,:TestDefault,:TestInit,:MyBase,:NewerBase].each do |test_klass|
+      Object.send(:remove_const,test_klass) if defined?(test_klass)
     end
   end
-end
+end

data/spec/simple_model_spec.rb

@@ -204,15 +204,18 @@ describe SimpleModel do
     before(:each) do
       class TestStuff < SimpleModel::Base
         has_attribute :bar
+        validates_presence_of :bar
       end
       
-      class OtherStuff < SimpleModel::Base
-        has_attribute :bar
-      end
-    
       class NewTestStuff < TestStuff
         has_boolean :foo
       end
+      
+      class OtherStuff < NewTestStuff
+        has_attribute :other
+        validates_numericality_of :other
+      end
+           
     end
     it "should merge defined attributes when class are inhereted" do
       NewTestStuff.defined_attributes[:bar].blank?.should be_false
@@ -225,8 +228,16 @@ describe SimpleModel do
       NewTestStuff.new.respond_to?(:bar_will_change!).should be_true
       NewTestStuff.new.respond_to?(:foo_will_change!).should be_true
     end
+    
+    it "should not throw exception method missing" do
+      o = OtherStuff.new
+      lambda { o.valid? }.should_not raise_error
+    end
+    
     after(:each) do
-      Object.send(:remove_const,:NewTestStuff)
+      [:OtherStuff,:NewTestStuff].each do |con|
+        Object.send(:remove_const,con)
+      end
     end
   end
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple_model
 version: !ruby/object:Gem::Version
-  version: 1.2.5
+  version: 1.2.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-22 00:00:00.000000000 Z
+date: 2013-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -127,7 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: simple_model
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Simpifies building tableless models or models backed by webservices