default_value_for 1.0.7 → 2.0.0

data/README.rdoc

@@ -20,21 +20,18 @@ section. Please read on.
 
 == Installation
 
-=== Rails 2
-
-Install with:
-
-  ./script/plugin install git://github.com/FooBarWidget/default_value_for.git
-
 === Rails 3
 
-You can either install it as a plugin:
+Add it to your Gemfile:
 
-  rails plugin install git://github.com/FooBarWidget/default_value_for.git
+  gem "default_value_for"
 
-or install it by adding it to your Gemfile:
+=== Rails 2
 
-  gem "default_value_for"
+default_value_for no longer supports Rails 2! The last version that supported Rails
+2 is version 1.0.7. Install that with:
+
+  ./script/plugin install git://github.com/FooBarWidget/default_value_for.git -r release-1.0.7
 
 
 == The default_value_for method
@@ -84,6 +81,20 @@ whatever reason:
       UuidGenerator.new.generate_uuid
     end
   end
+  
+== default_value_for options
+
+* allows_nil (default: true) - Sets explicitly passed nil values if option is set to true.
+ 
+You can pass this options hash as 2nd parameter and have to pass the default value through the :value option in this case e.g.:
+
+  default_value_for :age, :value => 20, :allows_nil => false 
+ 
+You can still pass the default value through a block:
+  
+  default_value_for :uuid, :allows_nil => false do
+    UuidGenerator.new.generate_uuid
+  end
 
 == The default_values method
 
@@ -92,6 +103,11 @@ As a shortcut, you can use +default_values+ to set multiple default values at on
   default_values :age  => 20,
                  :uuid => lambda { UuidGenerator.new.generate_uuid }
 
+If you like to override default_value_for options for each attribute you can do so:
+
+  default_values :age  => { :value => 20 },
+                 :uuid => { :value => lambda { UuidGenerator.new.generate_uuid }, :allows_nil => false }
+
 The difference is purely aesthetic.  If you have lots of default values which are constants or constructed with one-line blocks, +default_values+ may look nicer.  If you have default values constructed by longer blocks, +default_value_for+ suit you better.  Feel free to mix and match.
 
 As a side note, due to specifics of Ruby's parser, you cannot say,
@@ -103,7 +119,7 @@ because it will not parse. One needs to write
   default_value_for(:uuid) { UuidGenerator.new.generate_uuid }
 
 instead. This is in part the inspiration for the +default_values+ syntax.
-
+ 
 == Rules
 
 === Instantiation of new record
@@ -113,7 +129,7 @@ the record. You've already seen this in the above examples.
 
 === Retrieval of existing record
 
-Upon retrieving an existing record, the declared default values are _not_
+Upon retrieving an existing record in the following case, the declared default values are _not_
 filled into the record. Consider the example with the UUID:
 
   user = User.create
@@ -123,6 +139,19 @@ filled into the record. Consider the example with the UUID:
   # UUID remains unchanged because it's retrieved from the database!
   user.uuid   # => "529c91b8bbd3e..."
 
+But when the declared default value is set to not allow nil and nil is passed the default values will be set on retrieval.
+Consider this example:
+
+  default_value_for(:number, :allows_nil => false) { 123 }
+
+  user = User.create
+  
+  # manual SQL by-passing active record and the default value for gem logic through ActiveRecord's after_initialize callback
+  user.update_attribute(:number, nil)
+  
+  # declared default value should be set
+  User.find(user.id).number # => 123 # = declared default value
+
 === Mass-assignment
 
 If a certain attribute is being assigned via the model constructor's
@@ -142,6 +171,28 @@ then it will be filled in:
   
   user = User.new(:name => "Jane")
   user.name   # => "Joe"
+  
+  # the without protection option will work as expected
+  user = User.new({:name => "Jane"}, :without_protection => true)
+  user.name   # => "Jane"
+
+Explicitly set nil values for accessible attributes will be accepted:
+
+  class User < ActiveRecord::Base
+    default_value_for :name, 'Joe'
+  end
+
+  user = User(:name => nil)
+  user.name # => nil
+
+... unless the accessible attribute is set to not allowing nil:
+
+  class User < ActiveRecord::Base
+    default_value_for :name, 'Joe', :allows_nil => false
+  end
+
+  user = User(:name => nil)
+  user.name # => "Joe"
 
 === Inheritance
 
@@ -267,6 +318,9 @@ Also, stick with the following rules:
 - Make sure that +alias_method_chain+ is called *after* the last
   +default_value_for+ occurance.
 
+If your default value is accidentally similar to default_value_for's options hash wrap your default value like this:
+
+  default_value_for :attribute_name, :value => { :value => 123, :other_value => 1234 }
 
 == When (not) to use default_value_for?
 

data/default_value_for.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = %q{default_value_for}
-  s.version = "1.0.7"
+  s.version = "2.0.0"
   s.summary = %q{Provides a way to specify default values for ActiveRecord models}
   s.description = %q{The default_value_for plugin allows one to define default values for ActiveRecord models in a declarative manner}
   s.email = %q{info@phusion.nl}

data/lib/default_value_for.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2008, 2009, 2010, 2011 Phusion
+# Copyright (c) 2008-2012 Phusion
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -19,104 +19,144 @@
 # THE SOFTWARE.
 
 module DefaultValueFor
-	class NormalValueContainer
-		def initialize(value)
-			@value = value
-		end
+  class NormalValueContainer
+    def initialize(value)
+      @value = value
+    end
 
-		def evaluate(instance)
-			if @value.duplicable?
-				return @value.dup
-			else
-				return @value
-			end
-		end
-	end
+    def evaluate(instance)
+      if @value.duplicable?
+        return @value.dup
+      else
+        return @value
+      end
+    end
+  end
 
-	class BlockValueContainer
-		def initialize(block)
-			@block = block
-		end
+  class BlockValueContainer
+    def initialize(block)
+      @block = block
+    end
 
-		def evaluate(instance)
-			if @block.arity == 0
-				return @block.call
-			else
-				return @block.call(instance)
-			end
-		end
-	end
+    def evaluate(instance)
+      if @block.arity == 0
+        return @block.call
+      else
+        return @block.call(instance)
+      end
+    end
+  end
 
-	module ClassMethods
-		def default_value_for(attribute, value = nil, &block)
-			if !method_defined?(:initialize_with_defaults)
-				include(InstanceMethods)
-				alias_method_chain :initialize, :defaults
-				if respond_to?(:class_attribute)
-					class_attribute :_default_attribute_values
-				else
-					class_inheritable_accessor :_default_attribute_values
-				end
-				extend(DelayedClassMethods)
-				init_hash = true
-			end
-			if init_hash || !singleton_methods(false).to_s.include?("_default_attribute_values")
-				self._default_attribute_values = ActiveSupport::OrderedHash.new
-			end
-			if block_given?
-				container = BlockValueContainer.new(block)
-			else
-				container = NormalValueContainer.new(value)
-			end
-			_default_attribute_values[attribute.to_s] = container
-		end
+  module ClassMethods
+    # Declares a default value for the given attribute.
+    #
+    # Sets the default value to the given options parameter unless the given options equal { :value => ... }
+    #
+    # The <tt>options</tt> can be used to specify the following things:
+    # * <tt>value</tt> - Sets the default value.
+    # * <tt>allows_nil (default: true)</tt> - Sets explicitly passed nil values if option is set to true.
+    def default_value_for(attribute, options = {}, &block)
+      value = options.is_a?(Hash) && options.stringify_keys.has_key?('value') ? options.stringify_keys['value'] : options
+      allows_nil = options.is_a?(Hash) && options.stringify_keys.has_key?('allows_nil') ? options.stringify_keys['allows_nil'] : true
+      
+      if !method_defined?(:set_default_values)
+        include(InstanceMethods)
 
-		def default_values(values)
-			values.each_pair do |key, value|
-				if value.kind_of? Proc
-					default_value_for(key, &value)
-				else
-					default_value_for(key, value)
-				end
-			end
-		end
-	end
+        after_initialize :set_default_values
+        
+        if respond_to?(:class_attribute)
+          class_attribute :_default_attribute_values
+          class_attribute :_default_attribute_values_not_allowing_nil
+        else
+          class_inheritable_accessor :_default_attribute_values
+          class_inheritable_accessor :_default_attribute_values_not_allowing_nil
+        end
+        
+        extend(DelayedClassMethods)
+        init_hash = true
+      end
+      if init_hash || !singleton_methods(false).to_s.include?("_default_attribute_values")
+        self._default_attribute_values = ActiveSupport::OrderedHash.new
+        self._default_attribute_values_not_allowing_nil = []
+      end
+      if block_given?
+        container = BlockValueContainer.new(block)
+      else
+        container = NormalValueContainer.new(value)
+      end
+      _default_attribute_values[attribute.to_s] = container
+      _default_attribute_values_not_allowing_nil << attribute.to_s unless allows_nil
+    end
 
-	module DelayedClassMethods
-		def _all_default_attribute_values
-			return _default_attribute_values unless superclass.respond_to?(:_default_attribute_values)
-			superclass._all_default_attribute_values.merge(_default_attribute_values)
-		end
-	end
+    def default_values(values)
+      values.each_pair do |key, options|
+        options = options.stringify_keys if options.is_a?(Hash)
+        
+        value = options.is_a?(Hash) && options.has_key?('value') ? options['value'] : options
+        
+        if value.kind_of? Proc
+          default_value_for(key, options.is_a?(Hash) ? options : {}, &value)
+        else
+          default_value_for(key, options)
+        end
+      end
+    end
+  end
 
-	module InstanceMethods
-		def initialize_with_defaults(attrs = nil, *args, &block)
-			initialize_without_defaults(attrs, *args, &block)
-			if attrs
-				stringified_attrs = attrs.stringify_keys
-				safe_attrs = if respond_to? :sanitize_for_mass_assignment
-					sanitize_for_mass_assignment(stringified_attrs)
-				else
-					remove_attributes_protected_from_mass_assignment(stringified_attrs)
-				end
-				safe_attribute_names = safe_attrs.keys.map do |x|
-					x.to_s
-				end
-			end
-			self.class._all_default_attribute_values.each do |attribute, container|
-				if safe_attribute_names.nil? || !safe_attribute_names.any? { |attr_name| attr_name =~ /^#{attribute}($|\()/ }
-					__send__("#{attribute}=", container.evaluate(self))
-					changed_attributes.delete(attribute)
-				end
-			end
-			yield(self) if block_given?
-		end
-	end
+  module DelayedClassMethods
+    def _all_default_attribute_values
+      return _default_attribute_values unless superclass.respond_to?(:_default_attribute_values)
+      superclass._all_default_attribute_values.merge(_default_attribute_values)
+    end
+    
+    def _all_default_attribute_values_not_allowing_nil
+      return _default_attribute_values_not_allowing_nil unless superclass.respond_to?(:_default_attribute_values_not_allowing_nil)
+      superclass._all_default_attribute_values_not_allowing_nil.merge(_default_attribute_values_not_allowing_nil)
+    end
+  end
+
+  module InstanceMethods
+    def initialize(attributes = nil, options = {})
+      @initialization_attributes = attributes.is_a?(Hash) ? attributes.stringify_keys : {}
+      
+      unless options[:without_protection]
+        if respond_to?(:mass_assignment_options) && options.has_key?(:as)
+          @initialization_attributes = sanitize_for_mass_assignment(@initialization_attributes, options[:as])
+        elsif respond_to?(:sanitize_for_mass_assignment)
+          @initialization_attributes = sanitize_for_mass_assignment(@initialization_attributes)
+        else
+          @initialization_attributes = remove_attributes_protected_from_mass_assignment(@initialization_attributes)
+        end
+      end
+      
+      if ActiveRecord::VERSION::MAJOR > 3 || (ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR > 0)
+        super(attributes, options)
+      else
+        super(attributes)
+      end
+    end
+    
+    def set_default_values
+      self.class._all_default_attribute_values.each do |attribute, container|
+        next unless self.new_record? || self.class._all_default_attribute_values_not_allowing_nil.include?(attribute)
+        
+        connection_default_value_defined = new_record? && respond_to?("#{attribute}_changed?") && !__send__("#{attribute}_changed?")
+        
+        next unless connection_default_value_defined || self.attributes[attribute].blank?
+        
+        # allow explicitly setting nil through allow nil option
+        next if @initialization_attributes.is_a?(Hash) && @initialization_attributes.has_key?(attribute) && !self.class._all_default_attribute_values_not_allowing_nil.include?(attribute)
+        
+        __send__("#{attribute}=", container.evaluate(self))
+        changed_attributes.delete(attribute)
+      end
+    end
+  end
 end
 
 if defined?(Rails::Railtie)
-	require 'default_value_for/railtie'
+  require 'default_value_for/railtie'
 else
-	# Rails 2 initialization
-	ActiveRecord::Base.extend(DefaultValueFor::ClassMethods)
+  # Rails 2 initialization
+  ActiveRecord::Base.extend(DefaultValueFor::ClassMethods)
 end

data/test.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2008, 2009 Phusion
+# Copyright (c) 2008-2012 Phusion
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -18,13 +18,13 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-want_rails_version = '~> 3.1.0'
+want_rails_version = '~> ' + ENV.fetch('WANT_RAILS_VERSION', '3.2.0')
 
 require 'rubygems'
 gem 'rails', want_rails_version
 gem 'activerecord', want_rails_version
 begin
-	require 'rails/railtie'
+  require 'rails/railtie'
 rescue LoadError
 end
 require 'active_record'
@@ -36,335 +36,392 @@ require 'default_value_for'
 Dir.chdir(File.dirname(__FILE__))
 
 if RUBY_PLATFORM == "java"
-	database_adapter = "jdbcsqlite3"
+  database_adapter = "jdbcsqlite3"
 else
-	database_adapter = "sqlite3"
+  database_adapter = "sqlite3"
 end
 
 File.unlink('test.sqlite3') rescue nil
 ActiveRecord::Base.logger = Logger.new(STDERR)
 ActiveRecord::Base.logger.level = Logger::WARN
 ActiveRecord::Base.establish_connection(
-	:adapter => database_adapter,
-	:database => 'test.sqlite3'
+  :adapter => database_adapter,
+  :database => 'test.sqlite3'
 )
 ActiveRecord::Base.connection.create_table(:users, :force => true) do |t|
-	t.string :username
-	t.integer :default_number
+  t.string :username
+  t.integer :default_number
 end
 ActiveRecord::Base.connection.create_table(:numbers, :force => true) do |t|
-	t.string :type
-	t.integer :number
-	t.integer :count, :null => false, :default => 1
-	t.integer :user_id
-	t.timestamp :timestamp
+  t.string :type
+  t.integer :number
+  t.integer :count, :null => false, :default => 1
+  t.integer :user_id
+  t.timestamp :timestamp
 end
 
 if defined?(Rails::Railtie)
-	DefaultValueFor.initialize_railtie
-	DefaultValueFor.initialize_active_record_extensions
+  DefaultValueFor.initialize_railtie
+  DefaultValueFor.initialize_active_record_extensions
 end
 
 class User < ActiveRecord::Base
-	has_many :numbers, :class_name => 'TestClass'
+  has_many :numbers, :class_name => 'TestClass'
 end
 
 class Number < ActiveRecord::Base
 end
 
 class DefaultValuePluginTest < Test::Unit::TestCase
-	def setup
-		Number.create(:number => 9876)
-	end
-
-	def teardown
-		Number.delete_all
-	end
-
-	def define_model_class(name = "TestClass", parent_class_name = "ActiveRecord::Base", &block)
-		Object.send(:remove_const, name) rescue nil
-		eval("class #{name} < #{parent_class_name}; end", TOPLEVEL_BINDING)
-		klass = eval(name, TOPLEVEL_BINDING)
-		klass.class_eval do
-			set_table_name 'numbers'
-		end
-		klass.class_eval(&block) if block_given?
-	end
-
-	def test_default_value_can_be_passed_as_argument
-		define_model_class do
-			default_value_for(:number, 1234)
-		end
-		object = TestClass.new
-		assert_equal 1234, object.number
-	end
-
-	def test_default_value_can_be_passed_as_block
-		define_model_class do
-			default_value_for(:number) { 1234 }
-		end
-		object = TestClass.new
-		assert_equal 1234, object.number
-	end
-
-	def test_works_with_create
-		define_model_class do
-			default_value_for :number, 1234
-		end
-		TestClass.create
-		assert_not_nil TestClass.find_by_number(1234)
-	end
-
-	def test_overwrites_db_default
-		define_model_class do
-			default_value_for :count, 1234
-		end
-		object = TestClass.new
-		assert_equal 1234, object.count
-	end
-
-	def test_doesnt_overwrite_values_provided_by_mass_assignment
-		define_model_class do
-			default_value_for :number, 1234
-		end
-		object = TestClass.new(:number => 1, :count => 2)
-		assert_equal 1, object.number
-	end
-
-	def test_doesnt_overwrite_values_provided_by_multiparameter_assignment
-		define_model_class do
-			default_value_for :timestamp, Time.mktime(2000, 1, 1)
-		end
-		timestamp = Time.mktime(2009, 1, 1)
-		object = TestClass.new('timestamp(1i)' => '2009', 'timestamp(2i)' => '1', 'timestamp(3i)' => '1')
-		assert_equal timestamp, object.timestamp
-	end
-
-	def test_doesnt_overwrite_values_provided_by_constructor_block
-		define_model_class do
-			default_value_for :number, 1234
-		end
-		object = TestClass.new do |x|
-			x.number = 1
-			x.count = 2
-		end
-		assert_equal 1, object.number
-	end
-
-	def test_doesnt_overwrite_explicitly_provided_nil_values_in_mass_assignment
-		define_model_class do
-			default_value_for :number, 1234
-		end
-		object = TestClass.new(:number => nil)
-		assert_nil object.number
-	end
-
-	def test_default_values_are_inherited
-		define_model_class("TestSuperClass") do
-			default_value_for :number, 1234
-		end
-		define_model_class("TestClass", "TestSuperClass")
-		object = TestClass.new
-		assert_equal 1234, object.number
-	end
-
-	def test_default_values_in_subclass
-		define_model_class("TestSuperClass") do
-		end
-		define_model_class("TestClass", "TestSuperClass") do
-			default_value_for :number, 5678
-		end
-
-		object = TestClass.new
-		assert_equal 5678, object.number
-
-		object = TestSuperClass.new
-		assert_nil object.number
-	end
-
-	def test_multiple_default_values_in_subclass_with_default_values_in_parent_class
-		define_model_class("TestSuperClass") do
-			default_value_for :other_number, nil
-			attr_accessor :other_number
-		end
-		define_model_class("TestClass", "TestSuperClass") do
-			default_value_for :number, 5678
-
-			# Ensure second call in this class doesn't reset _default_attribute_values,
-			# and also doesn't consider the parent class' _default_attribute_values when
-			# making that check.
-			default_value_for :user_id, 9999
-		end
-
-		object = TestClass.new
-		assert_nil object.other_number
-		assert_equal 5678, object.number
-		assert_equal 9999, object.user_id
-	end
-
-	def test_override_default_values_in_subclass
-		define_model_class("TestSuperClass") do
-			default_value_for :number, 1234
-		end
-		define_model_class("TestClass", "TestSuperClass") do
-			default_value_for :number, 5678
-		end
-
-		object = TestClass.new
-		assert_equal 5678, object.number
-
-		object = TestSuperClass.new
-		assert_equal 1234, object.number
-	end
-
-	def test_default_values_in_subclass_do_not_affect_parent_class
-		define_model_class("TestSuperClass") do
-			default_value_for :number, 1234
-		end
-		define_model_class("TestClass", "TestSuperClass") do
-			default_value_for :hello, "hi"
-			attr_accessor :hello
-		end
-
-		assert_nothing_raised { TestSuperClass.new }
-		assert !TestSuperClass._default_attribute_values.include?(:hello)
-	end
-
-	def test_doesnt_set_default_on_saved_records
-		define_model_class do
-			default_value_for :number, 1234
-		end
-		assert_equal 9876, TestClass.find(:first).number
-	end
-
-	def test_also_works_on_attributes_that_arent_database_columns
-		define_model_class do
-			default_value_for :hello, "hi"
-			attr_accessor :hello
-		end
-		object = TestClass.new
-		assert_equal 'hi', object.hello
-	end
-
-	def test_constructor_ignores_forbidden_mass_assignment_attributes
-		define_model_class do
-			default_value_for :number, 1234
-			attr_protected :number
-		end
-		object = TestClass.new(:number => 5678, :count => 987)
-		assert_equal 1234, object.number
-		assert_equal 987, object.count
-	end
-
-	def test_doesnt_conflict_with_overrided_initialize_method_in_model_class
-		define_model_class do
-			def initialize(attrs = {})
-				@initialized = true
-				super(:count => 5678)
-			end
-
-			default_value_for :number, 1234
-		end
-		object = TestClass.new
-		assert_equal 1234, object.number
-		assert_equal 5678, object.count
-		assert object.instance_variable_get('@initialized')
-	end
-
-	def test_model_instance_is_passed_to_the_given_block
-		$instance = nil
-		define_model_class do
-			default_value_for :number do |n|
-				$instance = n
-			end
-		end
-		object = TestClass.new
-		assert_same object, $instance
-	end
-
-	def test_can_specify_default_value_via_association
-		user = User.create(:username => 'Kanako', :default_number => 123)
-		define_model_class do
-			belongs_to :user
-
-			default_value_for :number do |n|
-				n.user.default_number
-			end
-		end
-		object = user.numbers.create
-		assert_equal 123, object.number
-	end
-
-	def test_default_values
-		define_model_class do
-			default_values :type => "normal",
-				:number => lambda { 10 + 5 },
-				:timestamp => lambda {|_| Time.now }
-		end
-
-		object = TestClass.new
-		assert_equal("normal", object.type)
-		assert_equal(15, object.number)
-	end
-
-	def test_default_value_order
-		define_model_class do
-			default_value_for :count, 5
-			default_value_for :number do |this|
-				this.count * 2
-			end
-		end
-		object = TestClass.new
-		assert_equal(5, object.count)
-		assert_equal(10, object.number)
-	end
-
-	def test_attributes_with_default_values_are_not_marked_as_changed
-		define_model_class do
-			default_value_for :count, 5
-			default_value_for :number, 2
-		end
-
-		object = TestClass.new
-		assert(!object.changed?)
-		assert_equal([], object.changed)
-
-		object.type = "foo"
-		assert(object.changed?)
-		assert_equal(["type"], object.changed)
-	end
-
-	def test_default_values_are_duplicated
-		define_model_class do
-			set_table_name "users"
-			default_value_for :username, "hello"
-		end
-		user1 = TestClass.new
-		user1.username << " world"
-		user2 = TestClass.new
-		assert_equal("hello", user2.username)
-	end
-
-	def test_default_values_are_shallow_copied
-		define_model_class do
-			set_table_name "users"
-			attr_accessor :hash
-			default_value_for :hash, { 1 => [] }
-		end
-		user1 = TestClass.new
-		user1.hash[1] << 1
-		user2 = TestClass.new
-		assert_equal([1], user2.hash[1])
-	end
-
-	def test_constructor_does_not_affect_the_hash_passed_to_it
-		define_model_class do
-			default_value_for :count, 5
-		end
-
-		options = { :count => 5, :user_id => 1 }
-		options_dup = options.dup
-		object = TestClass.new(options)
-		assert_equal(options_dup, options)
-	end
+  def setup
+    Number.create(:number => 9876)
+  end
+
+  def teardown
+    Number.delete_all
+  end
+
+  def define_model_class(name = "TestClass", parent_class_name = "ActiveRecord::Base", &block)
+    Object.send(:remove_const, name) rescue nil
+    eval("class #{name} < #{parent_class_name}; end", TOPLEVEL_BINDING)
+    klass = eval(name, TOPLEVEL_BINDING)
+    klass.class_eval do
+      if respond_to?(:table_name=)
+        self.table_name = 'numbers'
+      else
+        set_table_name 'numbers'
+      end
+    end
+    klass.class_eval(&block) if block_given?
+  end
+
+  def test_default_value_can_be_passed_as_argument
+    define_model_class do
+      default_value_for(:number, 1234)
+    end
+    object = TestClass.new
+    assert_equal 1234, object.number
+  end
+
+  def test_default_value_can_be_passed_as_block
+    define_model_class do
+      default_value_for(:number) { 1234 }
+    end
+    object = TestClass.new
+    assert_equal 1234, object.number
+  end
+
+  def test_works_with_create
+    define_model_class do
+      default_value_for :number, 1234
+    end
+    
+    object = TestClass.create
+    assert_not_nil TestClass.find_by_number(1234)
+    
+    # allows nil for existing records
+    object.update_attribute(:number, nil)
+    assert_nil TestClass.find_by_number(1234)
+    assert_nil TestClass.find(object.id).number
+  end
+
+  def test_does_not_allow_nil_for_existing_record
+    define_model_class do
+      default_value_for(:number, :allows_nil => false) { 1234 }
+    end
+    
+    object = TestClass.create
+    
+    # allows nil for existing records
+    object.update_attribute(:number, nil)
+    assert_nil TestClass.find_by_number(1234)
+    assert_equal 1234, TestClass.find(object.id).number
+  end
+
+   def test_overwrites_db_default
+    define_model_class do
+      default_value_for :count, 1234
+    end
+    object = TestClass.new
+    assert_equal 1234, object.count
+  end
+
+  def test_doesnt_overwrite_values_provided_by_mass_assignment
+    define_model_class do
+      default_value_for :number, 1234
+    end
+    object = TestClass.new(:number => 1, :count => 2)
+    assert_equal 1, object.number
+  end
+
+  def test_doesnt_overwrite_values_provided_by_multiparameter_assignment
+    define_model_class do
+      default_value_for :timestamp, Time.mktime(2000, 1, 1)
+    end
+    timestamp = Time.mktime(2009, 1, 1)
+    object = TestClass.new('timestamp(1i)' => '2009', 'timestamp(2i)' => '1', 'timestamp(3i)' => '1')
+    assert_equal timestamp, object.timestamp
+  end
+
+  def test_doesnt_overwrite_values_provided_by_constructor_block
+    define_model_class do
+      default_value_for :number, 1234
+    end
+    object = TestClass.new do |x|
+      x.number = 1
+      x.count = 2
+    end
+    assert_equal 1, object.number
+  end
+
+  def test_doesnt_overwrite_explicitly_provided_nil_values_in_mass_assignment
+    define_model_class do
+      default_value_for :number, 1234
+    end
+    object = TestClass.new(:number => nil)
+    assert_equal nil, object.number
+  end
+
+  def test_overwrites_explicitly_provided_nil_values_in_mass_assignment
+    define_model_class do
+      default_value_for :number, :value => 1234, :allows_nil => false
+    end
+    object = TestClass.new(:number => nil)
+    assert_equal 1234, object.number
+  end
+
+  def test_default_values_are_inherited
+    define_model_class("TestSuperClass") do
+      default_value_for :number, 1234
+    end
+    define_model_class("TestClass", "TestSuperClass")
+    object = TestClass.new
+    assert_equal 1234, object.number
+  end
+
+  def test_default_values_in_subclass
+    define_model_class("TestSuperClass") do
+    end
+    define_model_class("TestClass", "TestSuperClass") do
+      default_value_for :number, 5678
+    end
+
+    object = TestClass.new
+    assert_equal 5678, object.number
+
+    object = TestSuperClass.new
+    assert_nil object.number
+  end
+
+  def test_multiple_default_values_in_subclass_with_default_values_in_parent_class
+    define_model_class("TestSuperClass") do
+      default_value_for :other_number, nil
+      attr_accessor :other_number
+    end
+    define_model_class("TestClass", "TestSuperClass") do
+      default_value_for :number, 5678
+
+      # Ensure second call in this class doesn't reset _default_attribute_values,
+      # and also doesn't consider the parent class' _default_attribute_values when
+      # making that check.
+      default_value_for :user_id, 9999
+    end
+
+    object = TestClass.new
+    assert_nil object.other_number
+    assert_equal 5678, object.number
+    assert_equal 9999, object.user_id
+  end
+
+  def test_override_default_values_in_subclass
+    define_model_class("TestSuperClass") do
+      default_value_for :number, 1234
+    end
+    define_model_class("TestClass", "TestSuperClass") do
+      default_value_for :number, 5678
+    end
+
+    object = TestClass.new
+    assert_equal 5678, object.number
+
+    object = TestSuperClass.new
+    assert_equal 1234, object.number
+  end
+
+  def test_default_values_in_subclass_do_not_affect_parent_class
+    define_model_class("TestSuperClass") do
+      default_value_for :number, 1234
+    end
+    define_model_class("TestClass", "TestSuperClass") do
+      default_value_for :hello, "hi"
+      attr_accessor :hello
+    end
+
+    assert_nothing_raised { TestSuperClass.new }
+    assert !TestSuperClass._default_attribute_values.include?(:hello)
+  end
+
+  def test_doesnt_set_default_on_saved_records
+    define_model_class do
+      default_value_for :number, 1234
+    end
+    assert_equal 9876, TestClass.find(:first).number
+  end
+
+  def test_also_works_on_attributes_that_arent_database_columns
+    define_model_class do
+      default_value_for :hello, "hi"
+      attr_accessor :hello
+    end
+    object = TestClass.new
+    assert_equal 'hi', object.hello
+  end
+
+  def test_constructor_ignores_forbidden_mass_assignment_attributes
+    define_model_class do
+      default_value_for :number, 1234
+      attr_protected :number
+    end
+    object = TestClass.new(:number => 5678, :count => 987)
+    assert_equal 1234, object.number
+    assert_equal 987, object.count
+  end
+
+  def test_constructor_respects_without_protection_option
+    define_model_class do
+      default_value_for :number, 1234
+      attr_protected :number
+      
+      def respond_to_mass_assignment_options?
+        respond_to? :mass_assignment_options
+      end
+    end
+    
+    if TestClass.new.respond_to_mass_assignment_options?
+      # test without protection feature if available in current ActiveRecord version
+      object = TestClass.create!({:number => 5678, :count => 987}, :without_protection => true)
+      assert_equal 5678, object.number
+      assert_equal 987, object.count
+    end
+  end
+
+  def test_doesnt_conflict_with_overrided_initialize_method_in_model_class
+    define_model_class do
+      def initialize(attrs = {})
+        @initialized = true
+        super(:count => 5678)
+      end
+
+      default_value_for :number, 1234
+    end
+    object = TestClass.new
+    assert_equal 1234, object.number
+    assert_equal 5678, object.count
+    assert object.instance_variable_get('@initialized')
+  end
+
+  def test_model_instance_is_passed_to_the_given_block
+    $instance = nil
+    define_model_class do
+      default_value_for :number do |n|
+        $instance = n
+      end
+    end
+    object = TestClass.new
+    assert_same object, $instance
+  end
+
+  def test_can_specify_default_value_via_association
+    user = User.create(:username => 'Kanako', :default_number => 123)
+    define_model_class do
+      belongs_to :user
+
+      default_value_for :number do |n|
+        n.user.default_number
+      end
+    end
+    object = user.numbers.create
+    assert_equal 123, object.number
+  end
+
+  def test_default_values
+    define_model_class do
+      default_values :type => "normal",
+        :number => lambda { 10 + 5 },
+        :timestamp => lambda {|_| Time.now }
+    end
+
+    object = TestClass.new
+    assert_equal("normal", object.type)
+    assert_equal(15, object.number)
+  end
+
+  def test_default_value_order
+    define_model_class do
+      default_value_for :count, 5
+      default_value_for :number do |this|
+        this.count * 2
+      end
+    end
+    object = TestClass.new
+    assert_equal(5, object.count)
+    assert_equal(10, object.number)
+  end
+
+  def test_attributes_with_default_values_are_not_marked_as_changed
+    define_model_class do
+      default_value_for :count, 5
+      default_value_for :number, 2
+    end
+
+    object = TestClass.new
+    assert(!object.changed?)
+    assert_equal([], object.changed)
+
+    object.type = "foo"
+    assert(object.changed?)
+    assert_equal(["type"], object.changed)
+  end
+
+  def test_default_values_are_duplicated
+    define_model_class do
+      if respond_to?(:table_name=)
+        self.table_name = "users"
+      else
+        set_table_name "users"
+      end
+      default_value_for :username, "hello"
+    end
+    user1 = TestClass.new
+    user1.username << " world"
+    user2 = TestClass.new
+    assert_equal("hello", user2.username)
+  end
+
+  def test_default_values_are_shallow_copied
+    define_model_class do
+      if respond_to?(:table_name=)
+        self.table_name = "users"
+      else
+        set_table_name "users"
+      end
+      attr_accessor :hash
+      default_value_for :hash, { 1 => [] }
+    end
+    user1 = TestClass.new
+    user1.hash[1] << 1
+    user2 = TestClass.new
+    assert_equal([1], user2.hash[1])
+  end
+  
+  def test_constructor_does_not_affect_the_hash_passed_to_it
+    define_model_class do
+      default_value_for :count, 5
+    end
+
+    options = { :count => 5, :user_id => 1 }
+    options_dup = options.dup
+    object = TestClass.new(options)
+    assert_equal(options_dup, options)
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: default_value_for
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 15
   prerelease: 
   segments: 
-  - 1
+  - 2
   - 0
-  - 7
-  version: 1.0.7
+  - 0
+  version: 2.0.0
 platform: ruby
 authors: 
 - Hongli Lai
@@ -15,8 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-02 00:00:00 +01:00
-default_executable: 
+date: 2012-05-27 00:00:00 Z
 dependencies: []
 
 description: The default_value_for plugin allows one to define default values for ActiveRecord models in a declarative manner
@@ -36,7 +35,6 @@ files:
 - init.rb
 - lib/default_value_for.rb
 - lib/default_value_for/railtie.rb
-has_rdoc: true
 homepage: http://github.com/FooBarWidget/default_value_for
 licenses: []
 
@@ -66,9 +64,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.2
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: Provides a way to specify default values for ActiveRecord models
 test_files: []
 
+has_rdoc: