gitlab-default_value_for 3.1.1

data/Rakefile

@@ -0,0 +1,28 @@
+require "bundler/gem_tasks"
+
+task :default => :test
+
+desc "Run unit tests."
+task :test do
+  ruby "test.rb"
+end
+
+['3.2', '4.0', '4.1', '4.2', '5.0', '5.1', '5.2'].each do |version|
+  dotless = version.delete('.')
+
+  namespace :bundle do
+    desc "Bundle with Rails #{version}.x"
+    task :"rails#{dotless}" do
+      ENV['BUNDLE_GEMFILE'] = "gemfiles/rails_#{dotless}.gemfile"
+      sh "bundle"
+    end
+  end
+
+  namespace :test do
+    desc "Test with Rails #{version}.x"
+    task :"rails#{dotless}" do
+      ENV['BUNDLE_GEMFILE'] = "gemfiles/rails_#{dotless}.gemfile"
+      ruby "test.rb"
+    end
+  end
+end

data/default_value_for.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |s|
+  s.name                  = %q{gitlab-default_value_for}
+  s.version               = "3.1.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{software-signing@phusion.nl}
+  s.homepage              = %q{https://github.com/gitlabhq/default_value_for}
+  s.authors               = ["Hongli Lai"]
+  s.license               = 'MIT'
+  s.required_ruby_version = '>= 1.9.3'
+  s.files                 = ['default_value_for.gemspec',
+    'LICENSE.TXT', 'Rakefile', 'README.md', 'test.rb',
+    'init.rb',
+    'lib/default_value_for.rb',
+    'lib/default_value_for/railtie.rb'
+  ]
+  s.add_dependency 'activerecord', '>= 3.2.0', '< 6.0'
+  s.add_development_dependency 'railties', '>= 3.2.0', '< 6.0'
+  s.add_development_dependency 'minitest', '>= 4.2'
+  s.add_development_dependency 'minitest-around'
+  s.add_development_dependency 'appraisal'
+end

data/init.rb

@@ -0,0 +1,21 @@
+# Copyright (c) 2008, 2009, 2010 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 'default_value_for'

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.is_a?(ActionController::Parameters)
+      @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/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/test.rb

@@ -0,0 +1,395 @@
+# 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'
+
+if ActiveSupport::VERSION::MAJOR == 3
+  require 'active_support/core_ext/logger'
+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}\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
+  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 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