ta_default_value_for 3.4.0

data/lib/default_value_for/railtie.rb

@@ -0,0 +1,37 @@
+# Copyright (c) 2008, 2009, 2010, 2011 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.
+
+module DefaultValueFor
+  def self.initialize_railtie
+    ActiveSupport.on_load :active_record do
+      DefaultValueFor.initialize_active_record_extensions
+    end
+  end
+
+  def self.initialize_active_record_extensions
+    ActiveRecord::Base.extend(DefaultValueFor::ClassMethods)
+  end
+
+  class Railtie < Rails::Railtie
+    initializer 'default_value_for.insert_into_active_record' do
+      DefaultValueFor.initialize_railtie
+    end
+  end
+end

data/lib/default_value_for.rb

@@ -0,0 +1,201 @@
+# 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
+# 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.
+
+module DefaultValueFor
+  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)
+      if @block.arity == 0
+        return @block.call
+      else
+        return @block.call(instance)
+      end
+    end
+  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
+      allows_nil = true
+
+      if options.is_a?(Hash)
+        opts       = options.stringify_keys
+        value      = opts.fetch('value', options)
+        allows_nil = opts.fetch('allows_nil', true)
+      end
+
+      if !method_defined?(:set_default_values)
+        include(InstanceMethods)
+
+        after_initialize :set_default_values
+
+        class_attribute :_default_attribute_values
+        class_attribute :_default_attribute_values_not_allowing_nil
+
+        extend(DelayedClassMethods)
+        init_hash = true
+      else
+        init_hash = !singleton_methods(false).include?(:_default_attribute_values)
+      end
+
+      if init_hash
+        self._default_attribute_values = {}
+        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
+
+    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 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)
+      result = superclass._all_default_attribute_values_not_allowing_nil + _default_attribute_values_not_allowing_nil
+      result.uniq!
+      result
+    end
+  end
+
+  module InstanceMethods
+    def initialize(attributes = nil, options = {})
+      attributes = attributes.to_h if attributes.respond_to?(:to_h)
+      @initialization_attributes = attributes.is_a?(Hash) ? attributes.stringify_keys : {}
+
+      unless options[:without_protection]
+        if respond_to?(:mass_assignment_options, true) && options.has_key?(:as)
+          @initialization_attributes = sanitize_for_mass_assignment(@initialization_attributes, options[:as])
+        elsif respond_to?(:sanitize_for_mass_assignment, true)
+          @initialization_attributes = sanitize_for_mass_assignment(@initialization_attributes)
+        else
+          @initialization_attributes = remove_attributes_protected_from_mass_assignment(@initialization_attributes)
+        end
+      end
+
+      if self.class.respond_to? :protected_attributes
+        super(attributes, options)
+      else
+        super(attributes)
+      end
+    end
+
+    def attributes_for_create(attribute_names)
+      attribute_names += self.class._all_default_attribute_values.keys.map(&:to_s).find_all { |name|
+        self.class.columns_hash.key?(name)
+      }
+      super
+    end
+
+    def set_default_values
+      self.class._all_default_attribute_values.each do |attribute, container|
+        next unless 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?")
+
+        attribute_blank = if attributes.has_key?(attribute)
+                            column = self.class.columns_hash[attribute]
+                            if column && column.type == :boolean
+                              attributes[attribute].nil?
+                            else
+                              attributes[attribute].blank?
+                            end
+                          elsif respond_to?(attribute)
+                            send(attribute).nil?
+                          else
+                            instance_variable_get("@#{attribute}").nil?
+                          end
+        next unless connection_default_value_defined || attribute_blank
+
+        # allow explicitly setting nil through allow nil option
+        next if @initialization_attributes.is_a?(Hash) &&
+                (
+                  @initialization_attributes.has_key?(attribute) ||
+                  (
+                    @initialization_attributes.has_key?("#{attribute}_attributes") &&
+                    nested_attributes_options.stringify_keys[attribute]
+                  )
+                ) &&
+                !self.class._all_default_attribute_values_not_allowing_nil.include?(attribute)
+
+        __send__("#{attribute}=", container.evaluate(self))
+        if respond_to?(:clear_attribute_changes, true)
+          clear_attribute_changes [attribute] if has_attribute?(attribute)
+        else
+          changed_attributes.delete(attribute)
+        end
+      end
+    end
+  end
+end
+
+if defined?(Rails::Railtie)
+  require 'default_value_for/railtie'
+else
+  # For anybody is using AS and AR without Railties, i.e. Padrino.
+  ActiveRecord::Base.extend(DefaultValueFor::ClassMethods)
+end

data/test.rb

@@ -0,0 +1,461 @@
+# 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
+# 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 'bundler/setup'
+require 'minitest/autorun'
+require 'minitest/around/unit'
+require 'active_record'
+require 'action_pack'
+
+if ActiveSupport::VERSION::MAJOR == 3
+  require 'active_support/core_ext/logger'
+end
+
+if ActionPack::VERSION::MAJOR > 3
+  require 'action_controller'
+end
+
+# Handle an edge-case when using Arel 5 (i.e. Rails <= 4.1) with Ruby >= 2.4:
+# See: https://github.com/rails/arel/commit/dc85a6e9c74942945ad696f5da4d82490a85b865
+# See: https://stackoverflow.com/a/51481088
+rails_match_data = RUBY_VERSION.match(/\A(?<major>\d+).(?<minor>\d+)/)
+rails_2_4_or_newer = rails_match_data[:major].to_i > 2 || (rails_match_data[:major].to_i == 2 && rails_match_data[:minor].to_i >= 4)
+arel_match_data = Arel::VERSION.match(/\A(?<major>\d+).(?<minor>\d+)/)
+arel_older_than_7_1 = arel_match_data[:major].to_i < 7 || (arel_match_data[:major].to_i == 7 && arel_match_data[:minor].to_i < 1)
+
+if rails_2_4_or_newer && arel_older_than_7_1
+  module Arel
+    module Visitors
+      class DepthFirst < Arel::Visitors::Visitor
+        alias :visit_Integer :terminal
+      end
+
+      class Dot < Arel::Visitors::Visitor
+        alias :visit_Integer :visit_String
+      end
+
+      # The super class for ToSql changed with Arel 6
+      # See: https://github.com/rails/arel/commit/a6a7c75ff486657909e20e2f48764136caa5e87e#diff-3538aead5b80677372eea0e903ff728eR7
+      class ToSql < (Arel::VERSION[/\A\d+/].to_i >= 6 ? Arel::Visitors::Reduce : Arel::Visitors::Visitor)
+        alias :visit_Integer :literal
+      end
+    end
+  end
+end
+
+begin
+  TestCaseClass = MiniTest::Test
+rescue NameError
+  TestCaseClass = MiniTest::Unit::TestCase
+end
+
+require 'default_value_for'
+
+puts "\nTesting with Active Record version #{ActiveRecord::VERSION::STRING}"
+puts "\nTesting with Action Pack version #{ActionPack::VERSION::STRING}\n\n"
+
+ActiveRecord::Base.default_timezone = :local
+ActiveRecord::Base.logger           = Logger.new(STDERR)
+ActiveRecord::Base.logger.level     = Logger::WARN
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => RUBY_PLATFORM == 'java' ? 'jdbcsqlite3' : 'sqlite3',
+  :database => ':memory:'
+)
+
+ActiveRecord::Base.connection.create_table(:users, :force => true) do |t|
+  t.string :username
+  t.integer :default_number
+  t.text :settings
+end
+
+ActiveRecord::Base.connection.create_table(:books, :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.text :stuff
+  t.boolean :flag
+end
+
+if defined?(Rails::Railtie)
+  DefaultValueFor.initialize_railtie
+  DefaultValueFor.initialize_active_record_extensions
+end
+
+class DefaultValuePluginTest < TestCaseClass
+  def around
+    Object.const_set(:User, Class.new(ActiveRecord::Base))
+    Object.const_set(:Book, Class.new(ActiveRecord::Base))
+    Object.const_set(:Novel, Class.new(Book))
+    User.has_many :books
+    Book.belongs_to :user
+
+    ActiveRecord::Base.transaction do
+      yield
+      raise ActiveRecord::Rollback
+    end
+  ensure
+    Object.send(:remove_const, :User)
+    Object.send(:remove_const, :Book)
+    Object.send(:remove_const, :Novel)
+    ActiveSupport::Dependencies.clear unless ActiveSupport::VERSION::MAJOR > 6
+  end
+
+  def test_default_value_on_attribute_methods
+    Book.class_eval do
+      serialize :stuff
+      default_value_for :color, :green
+      def color; (self.stuff || {})[:color]; end
+      def color=(val)
+        self.stuff ||= {}
+        self.stuff[:color] = val
+      end
+    end
+    assert_equal :green, Book.create.color
+  end
+
+  def test_default_value_can_be_passed_as_argument
+    Book.default_value_for(:number, 1234)
+    assert_equal 1234, Book.new.number
+  end
+
+  def test_default_value_can_be_passed_as_block
+    Book.default_value_for(:number) { 1234 }
+    assert_equal 1234, Book.new.number
+  end
+
+  def test_works_with_create
+    Book.default_value_for :number, 1234
+
+    object = Book.create
+    refute_nil Book.find_by_number(1234)
+
+    # allows nil for existing records
+    object.update_attribute(:number, nil)
+    assert_nil Book.find_by_number(1234)
+    assert_nil Book.find(object.id).number
+  end
+
+  def test_does_not_allow_nil_sets_default_value_on_existing_nils
+    Book.default_value_for(:number, :allows_nil => false) { 1234 }
+    object = Book.create
+    object.update_attribute(:number, nil)
+    assert_nil Book.find_by_number(1234)
+    assert_equal 1234, Book.find(object.id).number
+  end
+
+  def test_overwrites_db_default
+    Book.default_value_for :count, 1234
+    assert_equal 1234, Book.new.count
+  end
+
+  def test_doesnt_overwrite_values_provided_by_mass_assignment
+    Book.default_value_for :number, 1234
+    assert_equal 1, Book.new(:number => 1, :count => 2).number
+  end
+
+  def test_doesnt_overwrite_values_provided_by_multiparameter_assignment
+    Book.default_value_for :timestamp, Time.mktime(2000, 1, 1)
+    timestamp = Time.mktime(2009, 1, 1)
+    object = Book.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
+    Book.default_value_for :number, 1234
+    object = Book.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
+    Book.default_value_for :number, 1234
+    assert_nil Book.new(:number => nil).number
+  end
+
+  def test_overwrites_explicitly_provided_nil_values_in_mass_assignment
+    Book.default_value_for :number, :value => 1234, :allows_nil => false
+    assert_equal 1234, Book.new(:number => nil).number
+  end
+
+  def test_default_values_are_inherited
+    Book.default_value_for :number, 1234
+    assert_equal 1234, Novel.new.number
+  end
+
+  def test_default_values_in_superclass_are_saved_in_subclass
+    Book.default_value_for :number, 1234
+    Novel.default_value_for :flag, true
+    object = Novel.create!
+    assert_equal object.id, Novel.find_by_number(1234).id
+    assert_equal object.id, Novel.find_by_flag(true).id
+  end
+
+  def test_default_values_in_subclass
+    Novel.default_value_for :number, 5678
+    assert_equal 5678, Novel.new.number
+    assert_nil Book.new.number
+  end
+
+  def test_multiple_default_values_in_subclass_with_default_values_in_parent_class
+    Book.class_eval do
+      default_value_for :other_number, nil
+      attr_accessor :other_number
+    end
+    Novel.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.
+    Novel.default_value_for :user_id, 9999
+
+    object = Novel.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
+    Book.default_value_for :number, 1234
+    Novel.default_value_for :number, 5678
+    assert_equal 5678, Novel.new.number
+    assert_equal 1234, Book.new.number
+  end
+
+  def test_default_values_in_subclass_do_not_affect_parent_class
+    Book.default_value_for :number, 1234
+    Novel.class_eval do
+      default_value_for :hello, "hi"
+      attr_accessor :hello
+    end
+
+    assert Book.new
+    assert !Book._default_attribute_values.include?(:hello)
+  end
+
+  def test_doesnt_set_default_on_saved_records
+    Book.create(:number => 9876)
+    Book.default_value_for :number, 1234
+    assert_equal 9876, Book.first.number
+  end
+
+  def test_also_works_on_attributes_that_arent_database_columns
+    Book.class_eval do
+      default_value_for :hello, "hi"
+      attr_accessor :hello
+    end
+    assert_equal 'hi', Book.new.hello
+  end
+
+  def test_works_on_attributes_that_only_have_writers
+    Book.class_eval do
+      default_value_for :hello, "hi"
+      attr_writer :hello
+    end
+    assert_equal 'hi', Book.new.instance_variable_get('@hello')
+  end
+
+  def test_doesnt_conflict_with_overrided_initialize_method_in_model_class
+    Book.class_eval do
+      def initialize(attrs = {})
+        @initialized = true
+        super(:count => 5678)
+      end
+
+      default_value_for :number, 1234
+    end
+    object = Book.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
+    Book.default_value_for :number do |n|
+      instance = n
+    end
+    object = Book.new
+    assert_same object.object_id, instance.object_id
+  end
+
+  def test_can_specify_default_value_via_association
+    user = User.create(:username => 'Kanako', :default_number => 123)
+    Book.default_value_for :number do |n|
+      n.user.default_number
+    end
+    assert_equal 123, user.books.create!.number
+  end
+
+  def test_default_values
+    Book.default_values({
+      :type      => "normal",
+      :number    => lambda { 10 + 5 },
+      :timestamp => lambda {|_| Time.now }
+    })
+
+    object = Book.new
+    assert_equal("normal", object.type)
+    assert_equal(15, object.number)
+  end
+
+  def test_default_value_order
+    Book.default_value_for :count, 5
+    Book.default_value_for :number do |this|
+      this.count * 2
+    end
+    object = Book.new
+    assert_equal(5, object.count)
+    assert_equal(10, object.number)
+  end
+
+  def test_attributes_with_default_values_are_not_marked_as_changed
+    Book.default_value_for :count, 5
+    Book.default_value_for :number, 2
+
+    object = Book.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
+    User.default_value_for :username, "hello"
+    user1 = User.new
+    user1.username << " world"
+    user2 = User.new
+    assert_equal("hello", user2.username)
+  end
+
+  def test_default_values_are_shallow_copied
+    User.class_eval do
+      attr_accessor :hash
+      default_value_for :hash, { 1 => [] }
+    end
+    user1 = User.new
+    user1.hash[1] << 1
+    user2 = User.new
+    assert_equal([1], user2.hash[1])
+  end
+
+  def test_constructor_does_not_affect_the_hash_passed_to_it
+    Book.default_value_for :count, 5
+    options = { :count => 5, :user_id => 1 }
+    options_dup = options.dup
+    Book.new(options)
+    assert_equal(options_dup, options)
+  end
+
+  def test_subclass_find
+    Book.default_value_for :number, 5678
+    n = Novel.create
+    assert Novel.find(n.id)
+  end
+
+  def test_does_not_see_false_as_blank_at_boolean_columns_for_existing_records
+    Book.default_value_for(:flag, :allows_nil => false) { true }
+
+    object = Book.create
+
+    # allows nil for existing records
+    object.update_attribute(:flag, false)
+    assert_equal false, Book.find(object.id).flag
+  end
+
+  def test_works_with_nested_attributes
+    User.accepts_nested_attributes_for :books
+    User.default_value_for :books do
+      [Book.create!(:number => 0)]
+    end
+
+    user = User.create! :books_attributes => [{:number => 1}]
+    assert_equal 1, Book.all.first.number
+  end
+
+  def test_works_with_stored_attribute_accessors_when_initializing_value_that_does_not_allow_nil
+    User.store :settings, :accessors => :bio
+    User.default_value_for :bio, :value => 'None given', :allows_nil => false
+
+    user = User.create!(:bio => 'This is a bio')
+    assert_equal 'This is a bio', user.bio
+  end
+
+  if ActionPack::VERSION::MAJOR > 3
+    def test_doesnt_overwrite_explicitly_provided_nil_values_in_mass_assignment_with_action_controller_parameters
+      Book.default_value_for :number, 1234
+
+      assert_nil Book.new(ActionController::Parameters.new(:number => nil).permit!).number
+    end
+
+    def test_overwrites_explicitly_provided_nil_values_in_mass_assignment_with_action_controller_parameters
+      Book.default_value_for :number, :value => 1234, :allows_nil => false
+
+      assert_equal 1234, Book.new(ActionController::Parameters.new(:number => nil).permit!).number
+    end
+
+    def test_works_with_nested_attributes_with_action_controller_parameters
+      User.accepts_nested_attributes_for :books
+      User.default_value_for :books do
+        [Book.create!(:number => 0)]
+      end
+
+      user = User.create!(ActionController::Parameters.new(:books_attributes => [{:number => 1}]).permit!)
+      assert_equal 1, Book.all.first.number
+    end
+
+    def test_works_with_stored_attribute_accessors_when_initializing_value_that_does_not_allow_nil_with_action_controller_parameters
+      User.store :settings, :accessors => :bio
+      User.default_value_for :bio, :value => 'None given', :allows_nil => false
+
+      user = User.create!(ActionController::Parameters.new(:bio => 'This is a bio').permit!)
+      assert_equal 'This is a bio', user.bio
+    end
+  end
+
+  if ActiveRecord::VERSION::MAJOR == 3
+    def test_constructor_ignores_forbidden_mass_assignment_attributes
+      Book.class_eval do
+        default_value_for :number, 1234
+        attr_protected :number
+      end
+      object = Book.new(:number => 5678, :count => 987)
+      assert_equal 1234, object.number
+      assert_equal 987, object.count
+    end
+
+    def test_constructor_respects_without_protection_option
+      Book.class_eval do
+        default_value_for :number, 1234
+        attr_protected :number
+      end
+
+      object = Book.create!({:number => 5678, :count => 987}, :without_protection => true)
+      assert_equal 5678, object.number
+      assert_equal 987, object.count
+    end
+  end
+end