dolzenko-default_value_for 1.0.1

data/LICENSE.TXT

@@ -0,0 +1,19 @@
+Copyright (c) 2008 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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,436 @@
+= Introduction
+
+The default_value_for plugin allows one to define default values for ActiveRecord
+models in a declarative manner. For example:
+
+  class User < ActiveRecord::Base
+    default_value_for :name, "(no name)"
+    default_value_for :last_seen do
+      Time.now
+    end
+  end
+  
+  u = User.new
+  u.name       # => "(no name)"
+  u.last_seen  # => Mon Sep 22 17:28:38 +0200 2008
+
+*Note*: critics might be interested in the "When (not) to use default_value_for?"
+section. Please read on.
+
+
+== Installation
+
+Install with:
+
+  ./script/plugin install git://github.com/FooBarWidget/default_value_for.git
+
+
+== The default_value_for method
+
+The +default_value_for+ method is available in all ActiveRecord model classes.
+
+The first argument is the name of the attribute for which a default value should
+be set. This may either be a Symbol or a String.
+
+The default value itself may either be passed as the second argument:
+
+  default_value_for :age, 20
+
+...or it may be passed as the return value of a block:
+
+  default_value_for :age do
+    if today_is_sunday?
+      20
+    else
+      30
+    end
+  end
+
+If you pass a value argument, then the default value is static and never
+changes. However, if you pass a block, then the default value is retrieved by
+calling the block. This block is called not once, but every time a new record is
+instantiated and default values need to be filled in.
+
+The latter form is especially useful if your model has a UUID column. One can
+generate a new, random UUID for every newly instantiated record:
+
+  class User < ActiveRecord::Base
+    default_value_for :uuid do
+      UuidGenerator.new.generate_uuid
+    end
+  end
+  
+  User.new.uuid  # => "51d6d6846f1d1b5c9a...."
+  User.new.uuid  # => "ede292289e3484cb88...."
+
+Note that record is passed to the block as an argument, in case you need it for
+whatever reason:
+
+  class User < ActiveRecord::Base
+    default_value_for :uuid do |x|
+      x   # <--- a User object
+      UuidGenerator.new.generate_uuid
+    end
+  end
+
+== The default_values method
+
+As a shortcut, you can use +default_values+ to set multiple default values at once.
+
+  default_values :age  => 20,
+                 :uuid => lambda { UuidGenerator.new.generate_uuid }
+
+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,
+
+  default_value :uuid { UuidGenerator.new.generate_uuid }
+
+because it will not parse.  This is in part the inspiration for the +default_values+ syntax.
+
+== Rules
+
+=== Instantiation of new record
+
+Upon instantiating a new record, the declared default values are filled into
+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_
+filled into the record. Consider the example with the UUID:
+
+  user = User.create
+  user.uuid   # => "529c91b8bbd3e..."
+  
+  user = User.find(user.id)
+  # UUID remains unchanged because it's retrieved from the database!
+  user.uuid   # => "529c91b8bbd3e..."
+
+=== Mass-assignment
+
+If a certain attribute is being assigned via the model constructor's
+mass-assignment argument, that the default value for that attribute will _not_
+be filled in:
+
+  user = User.new(:uuid => "hello")
+  user.uuid   # => "hello"
+
+However, if that attribute is protected by +attr_protected+ or +attr_accessible+,
+then it will be filled in:
+
+  class User < ActiveRecord::Base
+    default_value_for :name, 'Joe'
+    attr_protected :name
+  end
+  
+  user = User.new(:name => "Jane")
+  user.name   # => "Joe"
+
+=== Inheritance
+
+Inheritance works as expected. All default values are inherited by the child
+class:
+
+  class User < ActiveRecord::Base
+    default_value_for :name, 'Joe'
+  end
+  
+  class SuperUser < User
+  end
+  
+  SuperUser.new.name   # => "Joe"
+
+=== Attributes that aren't database columns
+
++default_value_for+ also works with attributes that aren't database columns.
+It works with anything for which there's an assignment method:
+
+  # Suppose that your 'users' table only has a 'name' column.
+  class User < ActiveRecord::Base
+    default_value_for :name, 'Joe'
+    default_value_for :age, 20
+    default_value_for :registering, true
+    
+    attr_accessor :age
+    
+    def registering=(value)
+      @registering = true
+    end
+  end
+  
+  user = User.new
+  user.age    # => 20
+  user.instance_variable_get('@registering')    # => true
+
+=== Default values are duplicated
+
+The given default values are duplicated when they are filled in, so if
+you mutate a value that was filled in with a default value, then it will
+not affect all subsequent default values:
+
+  class Author < ActiveRecord::Base
+    # This model only has a 'name' attribute.
+  end
+  
+  class Book < ActiveRecord::Base
+    belongs_to :author
+    
+    # By default, a Book belongs to a new, unsaved author.
+    default_value_for :author, Author.new
+  end
+  
+  book1 = Book.new
+  book1.author.name  # => nil
+  # This does not mutate the default value:
+  book1.author.name = "John"
+  
+  book2 = Book.new
+  book2.author.name  # => nil
+
+However the duplication is shallow. If you modify any objects that are
+referenced by the default value then it will affect subsequent default values:
+
+  class Author < ActiveRecord::Base
+    attr_accessor :useless_hash
+    default_value_for :useless_hash, { :foo => [] }
+  end
+  
+  author1 = Author.new
+  author1.useless_hash    # => { :foo => [] }
+  # This mutates the referred array:
+  author1.useless_hash[:foo] << 1
+  
+  author2 = Author.new
+  author2.useless_hash    # => { :foo => [1] }
+
+You can prevent this from happening by passing a block to +default_value_for+,
+which returns a new object instance with fresh references every time:
+
+  class Author < ActiveRecord::Base
+    attr_accessor :useless_hash
+    default_value_for :useless_hash do
+      { :foo => [] }
+    end
+  end
+  
+  author1 = Author.new
+  author1.useless_hash    # => { :foo => [] }
+  author1.useless_hash[:foo] << 1
+  
+  author2 = Author.new
+  author2.useless_hash    # => { :foo => [] }
+
+=== Caveats
+
+A conflict can occur if your model class overrides the 'initialize' method,
+because this plugin overrides 'initialize' as well to do its job.
+
+  class User < ActiveRecord::Base
+    def initialize  # <-- this constructor causes problems
+      super(:name => 'Name cannot be changed in constructor')
+    end
+  end
+
+We recommend you to alias chain your initialize method in models where you use
++default_value_for+:
+
+  class User < ActiveRecord::Base
+    default_value_for :age, 20
+    
+    def initialize_with_my_app
+      initialize_without_my_app(:name => 'Name cannot be changed in constructor')
+    end
+    
+    alias_method_chain :initialize, :my_app
+  end
+
+Also, stick with the following rules:
+- There is no need to +alias_method_chain+ your initialize method in models that
+  don't use +default_value_for+.
+- Make sure that +alias_method_chain+ is called *after* the last
+  +default_value_for+ occurance.
+
+
+== When (not) to use default_value_for?
+
+You can also specify default values in the database schema. For example, you
+can specify a default value in a migration as follows:
+
+  create_table :users do |t|
+    t.string    :username,  :null => false, :default => 'default username'
+    t.integer   :age,       :null => false, :default => 20
+  end
+
+This has similar effects as passing the default value as the second argument to
++default_value_for+:
+
+  default_value_for(:username, 'default_username')
+  default_value_for(:age, 20)
+
+Default values are filled in whether you use the schema defaults or the
+default_value_for defaults:
+
+  user = User.new
+  user.username   # => 'default username'
+  user.age        # => 20
+
+It's recommended that you use this over +default_value_for+ whenever possible.
+
+However, it's not possible to specify a schema default for serialized columns.
+With +default_value_for+, you can:
+
+  class User < ActiveRecord::Base
+    serialize :color
+    default_value_for :color, [255, 0, 0]
+  end
+
+And if schema defaults don't provide the flexibility that you need, then
++default_value_for+ is the perfect choice. For example, with +default_value_for+
+you could specify a per-environment default:
+
+  class User < ActiveRecord::Base
+    if RAILS_ENV == "development"
+      default_value_for :is_admin, true
+    end
+  end
+
+Or, as you've seen in an earlier example, you can use +default_value_for+ to
+generate a default random UUID:
+
+  class User < ActiveRecord::Base
+    default_value_for :uuid do
+      UuidGenerator.new.generate_uuid
+    end
+  end
+
+Or you could use it to generate a timestamp that's relative to the time at which
+the record is instantiated:
+
+  class User < ActiveRecord::Base
+    default_value_for :account_expires_at do
+      3.years.from_now
+    end
+  end
+  
+  User.new.account_expires_at   # => Mon Sep 22 18:43:42 +0200 2008
+  sleep(2)
+  User.new.account_expires_at   # => Mon Sep 22 18:43:44 +0200 2008
+
+Finally, it's also possible to specify a default via an association:
+
+  # Has columns: 'name' and 'default_price'
+  class SuperMarket < ActiveRecord::Base
+    has_many :products
+  end
+  
+  # Has columns: 'name' and 'price'
+  class Product < ActiveRecord::Base
+    belongs_to :super_market
+    
+    default_value_for :price do |product|
+      product.super_market.default_price
+    end
+  end
+  
+  super_market = SuperMarket.create(:name => 'Albert Zwijn', :default_price => 100)
+  soap = super_market.products.create(:name => 'Soap')
+  soap.price   # => 100
+
+=== What about before_validate/before_save?
+
+True, +before_validate+ and +before_save+ does what we want if we're only
+interested in filling in a default before saving. However, if one wants to be
+able to access the default value even before saving, then be prepared to write
+a lot of code. Suppose that we want to be able to access a new record's UUID,
+even before it's saved. We could end up with the following code:
+
+  # In the controller
+  def create
+    @user = User.new(params[:user])
+    @user.generate_uuid
+    email_report_to_admin("#{@user.username} with UUID #{@user.uuid} created.")
+    @user.save!
+  end
+  
+  # Model
+  class User < ActiveRecord::Base
+    before_save :generate_uuid_if_necessary
+    
+    def generate_uuid
+      self.uuid = ...
+    end
+    
+    private
+      def generate_uuid_if_necessary
+        if uuid.blank?
+          generate_uuid
+        end
+      end
+  end
+
+The need to manually call +generate_uuid+ here is ugly, and one can easily forget
+to do that. Can we do better? Let's see:
+
+  # Controller
+  def create
+    @user = User.new(params[:user])
+    email_report_to_admin("#{@user.username} with UUID #{@user.uuid} created.")
+    @user.save!
+  end
+  
+  # Model
+  class User < ActiveRecord::Base
+    before_save :generate_uuid_if_necessary
+    
+    def uuid
+      value = read_attribute('uuid')
+      if !value
+        value = generate_uuid
+        write_attribute('uuid', value)
+      end
+      value
+    end
+    
+    # We need to override this too, otherwise User.new.attributes won't return
+    # a default UUID value. I've never tested with User.create() so maybe we
+    # need to override even more things.
+    def attributes
+      uuid
+      super
+    end
+    
+    private
+      def generate_uuid_if_necessary
+        uuid  # Reader method automatically generates UUID if it doesn't exist
+      end
+  end
+
+That's an awful lot of code. Using +default_value_for+ is easier, don't you think?
+
+=== What about other plugins?
+
+I've only been able to find 2 similar plugins:
+
+- Default Value: http://agilewebdevelopment.com/plugins/default_value
+- ActiveRecord Defaults: http://agilewebdevelopment.com/plugins/activerecord_defaults
+
+'Default Value' appears to be unmaintained; its SVN link is broken. This leaves
+only 'ActiveRecord Defaults'. However, it is semantically dubious, which leaves
+it wide open for corner cases. For example, it is not clearly specified what
+ActiveRecord Defaults will do when attributes are protected by +attr_protected+
+or +attr_accessible+. It is also not clearly specified what one is supposed to
+do if one needs a custom +initialize+ method in the model.
+
+I've taken my time to thoroughly document default_value_for's behavior.
+
+
+== Credits
+
+I've wanted such functionality for a while now and it baffled me that ActiveRecord
+doesn't provide a clean way for me to specify default values. After reading
+http://groups.google.com/group/rubyonrails-core/browse_thread/thread/b509a2fe2b62ac5/3e8243fa1954a935,
+it became clear that someone needs to write a plugin. This is the result.
+
+Thanks to Pratik Naik for providing the initial code snippet on which this plugin
+is based on: http://m.onkey.org/2007/7/24/how-to-set-default-values-in-your-model

data/Rakefile

@@ -0,0 +1,6 @@
+task :default => :test
+
+desc "Run unit tests."
+task :test do
+	ruby "test.rb"
+end

data/default_value_for.gemspec

@@ -0,0 +1,10 @@
+Gem::Specification.new do |s|
+  s.name = %q{dolzenko-default_value_for}
+  s.version = "1.0.1"
+  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}
+  s.homepage = %q{http://github.com/FooBarWidget/default_value_for}
+  s.authors = ["Hongli Lai"]
+  s.files = ['default_value_for.gemspec', 'init.rb', 'lib/default_value_for.rb', 'lib/default_value_for/railtie.rb', 'LICENSE.TXT', 'Rakefile', 'README.rdoc', 'test.rb']
+end

data/init.rb

@@ -0,0 +1,23 @@
+# Copyright (c) 2008 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
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+# Rails 2 initialization
+require "default_value_for"
+ActiveRecord::Base.extend(DefaultValueForPlugin::ClassMethods)

data/lib/default_value_for.rb

@@ -0,0 +1,79 @@
+require "default_value_for/railtie"
+
+module DefaultValueForPlugin
+	class NormalValueContainer
+		def initialize(value)
+			@value = value
+		end
+
+		def evaluate(instance)
+			if @value.duplicable?
+				return @value.dup
+			else
+				return @value
+			end
+		end
+	end
+
+	class BlockValueContainer
+		def initialize(block)
+			@block = block
+		end
+
+		def evaluate(instance)
+			return @block.call(instance)
+		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
+				class_inheritable_accessor :_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
+
+		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
+
+	module InstanceMethods
+		def initialize_with_defaults(attrs = nil)
+			initialize_without_defaults(attrs) do
+				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._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
+	end
+end

data/lib/default_value_for/railtie.rb

@@ -0,0 +1,13 @@
+# Rails 3 initialization
+module DefaultValueForPlugin
+  if defined? Rails::Railtie
+    require 'rails'
+    class Railtie < Rails::Railtie
+      initializer 'default_value_for.insert_into_active_record' do
+        ActiveSupport.on_load :active_record do
+          ActiveRecord::Base.extend(DefaultValueForPlugin::ClassMethods)
+        end
+      end
+    end
+  end
+end

data/test.rb

@@ -0,0 +1,293 @@
+# Copyright (c) 2008, 2009 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
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'rubygems'
+require 'active_record'
+require 'test/unit'
+require 'active_support/core_ext/logger'
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require File.dirname(__FILE__) + '/init'
+Dir.chdir(File.dirname(__FILE__))
+
+if RUBY_PLATFORM == "java"
+	database_adapter = "jdbcsqlite3"
+else
+	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'
+)
+ActiveRecord::Base.connection.create_table(:users, :force => true) do |t|
+	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
+end
+
+class User < ActiveRecord::Base
+	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_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 }
+		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
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: dolzenko-default_value_for
+version: !ruby/object:Gem::Version 
+  hash: 21
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 1
+  version: 1.0.1
+platform: ruby
+authors: 
+- Hongli Lai
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-15 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: The default_value_for plugin allows one to define default values for ActiveRecord models in a declarative manner
+email: info@phusion.nl
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- default_value_for.gemspec
+- init.rb
+- lib/default_value_for.rb
+- lib/default_value_for/railtie.rb
+- LICENSE.TXT
+- Rakefile
+- README.rdoc
+- test.rb
+has_rdoc: true
+homepage: http://github.com/FooBarWidget/default_value_for
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Provides a way to specify default values for ActiveRecord models
+test_files: []
+