activemodel 4.2.11.3 → 5.0.0.beta1

data/lib/active_model/forbidden_attributes_protection.rb

@@ -17,8 +17,9 @@ module ActiveModel
   module ForbiddenAttributesProtection # :nodoc:
     protected
       def sanitize_for_mass_assignment(attributes)
-        if attributes.respond_to?(:permitted?) && !attributes.permitted?
-          raise ActiveModel::ForbiddenAttributesError
+        if attributes.respond_to?(:permitted?)
+          raise ActiveModel::ForbiddenAttributesError if !attributes.permitted?
+          attributes.to_h
         else
           attributes
         end

data/lib/active_model/gem_version.rb

@@ -1,14 +1,14 @@
 module ActiveModel
-  # Returns the version of the currently loaded Active Model as a <tt>Gem::Version</tt>
+  # Returns the version of the currently loaded \Active \Model as a <tt>Gem::Version</tt>
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
-    MAJOR = 4
-    MINOR = 2
-    TINY  = 11
-    PRE   = "3"
+    MAJOR = 5
+    MINOR = 0
+    TINY  = 0
+    PRE   = "beta1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_model/lint.rb

@@ -21,28 +21,27 @@ module ActiveModel
     # +self+.
     module Tests
 
-      # == Responds to <tt>to_key</tt>
+      # Passes if the object's model responds to <tt>to_key</tt> and if calling
+      # this method returns +nil+ when the object is not persisted.
+      # Fails otherwise.
       #
-      # Returns an Enumerable of all (primary) key attributes
-      # or nil if <tt>model.persisted?</tt> is false. This is used by
-      # <tt>dom_id</tt> to generate unique ids for the object.
+      # <tt>to_key</tt> returns an Enumerable of all (primary) key attributes
+      # of the model, and is used to a generate unique DOM id for the object.
       def test_to_key
         assert model.respond_to?(:to_key), "The model should respond to to_key"
         def model.persisted?() false end
         assert model.to_key.nil?, "to_key should return nil when `persisted?` returns false"
       end
 
-      # == Responds to <tt>to_param</tt>
-      #
-      # Returns a string representing the object's key suitable for use in URLs
-      # or +nil+ if <tt>model.persisted?</tt> is +false+.
+      # Passes if the object's model responds to <tt>to_param</tt> and if
+      # calling this method returns +nil+ when the object is not persisted.
+      # Fails otherwise.
       #
+      # <tt>to_param</tt> is used to represent the object's key in URLs.
       # Implementers can decide to either raise an exception or provide a
       # default in case the record uses a composite primary key. There are no
       # tests for this behavior in lint because it doesn't make sense to force
       # any of the possible implementation strategies on the implementer.
-      # However, if the resource is not persisted?, then <tt>to_param</tt>
-      # should always return +nil+.
       def test_to_param
         assert model.respond_to?(:to_param), "The model should respond to to_param"
         def model.to_key() [1] end
@@ -50,32 +49,34 @@ module ActiveModel
         assert model.to_param.nil?, "to_param should return nil when `persisted?` returns false"
       end
 
-      # == Responds to <tt>to_partial_path</tt>
+      # Passes if the object's model responds to <tt>to_partial_path</tt> and if
+      # calling this method returns a string. Fails otherwise.
       #
-      # Returns a string giving a relative path. This is used for looking up
-      # partials. For example, a BlogPost model might return "blog_posts/blog_post"
+      # <tt>to_partial_path</tt> is used for looking up partials. For example,
+      # a BlogPost model might return "blog_posts/blog_post".
       def test_to_partial_path
         assert model.respond_to?(:to_partial_path), "The model should respond to to_partial_path"
         assert_kind_of String, model.to_partial_path
       end
 
-      # == Responds to <tt>persisted?</tt>
+      # Passes if the object's model responds to <tt>persisted?</tt> and if
+      # calling this method returns either +true+ or +false+. Fails otherwise.
       #
-      # Returns a boolean that specifies whether the object has been persisted
-      # yet. This is used when calculating the URL for an object. If the object
-      # is not persisted, a form for that object, for instance, will route to
-      # the create action. If it is persisted, a form for the object will routes
-      # to the update action.
+      # <tt>persisted?</tt> is used when calculating the URL for an object.
+      # If the object is not persisted, a form for that object, for instance,
+      # will route to the create action. If it is persisted, a form for the
+      # object will route to the update action.
       def test_persisted?
         assert model.respond_to?(:persisted?), "The model should respond to persisted?"
         assert_boolean model.persisted?, "persisted?"
       end
 
-      # == \Naming
+      # Passes if the object's model responds to <tt>model_name</tt> both as
+      # an instance method and as a class method, and if calling this method
+      # returns a string with some convenience methods: <tt>:human</tt>,
+      # <tt>:singular</tt> and <tt>:plural</tt>.
       #
-      # Model.model_name and Model#model_name must return a string with some
-      # convenience methods: # <tt>:human</tt>, <tt>:singular</tt> and
-      # <tt>:plural</tt>. Check ActiveModel::Naming for more information.
+      # Check ActiveModel::Naming for more information.
       def test_model_naming
         assert model.class.respond_to?(:model_name), "The model class should respond to model_name"
         model_name = model.class.model_name
@@ -88,12 +89,15 @@ module ActiveModel
         assert_equal model.model_name, model.class.model_name
       end
 
-      # == \Errors Testing
+      # Passes if the object's model responds to <tt>errors</tt> and if calling
+      # <tt>[](attribute)</tt> on the result of this method returns an array.
+      # Fails otherwise.
       #
-      # Returns an object that implements [](attribute) defined which returns an
-      # Array of Strings that are the errors for the attribute in question.
-      # If localization is used, the Strings should be localized for the current
-      # locale. If no error is present, this method should return an empty Array.
+      # <tt>errors[attribute]</tt> is used to retrieve the errors of a model
+      # for a given attribute. If errors are present, the method should return
+      # an array of strings that are the errors for the attribute in question.
+      # If localization is used, the strings should be localized for the current
+      # locale. If no error is present, the method should return an empty array.
       def test_errors_aref
         assert model.respond_to?(:errors), "The model should respond to errors"
         assert model.errors[:hello].is_a?(Array), "errors#[] should return an Array"

data/lib/active_model/locale/en.yml

@@ -6,6 +6,7 @@ en:
     # The values :model, :attribute and :value are always available for interpolation
     # The value :count is available when applicable. Can be used for pluralization.
     messages:
+      model_invalid: "Validation failed: %{errors}"
       inclusion: "is not included in the list"
       exclusion: "is reserved"
       invalid: "is invalid"
@@ -16,7 +17,7 @@ en:
       present: "must be blank"
       too_long:
         one: "is too long (maximum is 1 character)"
-        other: "is too long (maximum is %{count} characters)" 
+        other: "is too long (maximum is %{count} characters)"
       too_short:
         one: "is too short (minimum is 1 character)"
         other: "is too short (minimum is %{count} characters)"

data/lib/active_model/model.rb

@@ -57,6 +57,7 @@ module ActiveModel
   # (see below).
   module Model
     extend ActiveSupport::Concern
+    include ActiveModel::AttributeAssignment
     include ActiveModel::Validations
     include ActiveModel::Conversion
 
@@ -75,10 +76,8 @@ module ActiveModel
     #   person = Person.new(name: 'bob', age: '18')
     #   person.name # => "bob"
     #   person.age  # => "18"
-    def initialize(params={})
-      params.each do |attr, value|
-        self.public_send("#{attr}=", value)
-      end if params
+    def initialize(attributes={})
+      assign_attributes(attributes) if attributes
 
       super()
     end

data/lib/active_model/naming.rb

@@ -1,6 +1,7 @@
 require 'active_support/core_ext/hash/except'
 require 'active_support/core_ext/module/introspection'
 require 'active_support/core_ext/module/remove_method'
+require 'active_support/core_ext/module/delegation'
 
 module ActiveModel
   class Name
@@ -163,7 +164,7 @@ module ActiveModel
       @route_key << "_index" if @plural == @singular
     end
 
-    # Transform the model name into a more humane format, using I18n. By default,
+    # Transform the model name into a more human format, using I18n. By default,
     # it will underscore then humanize the class name.
     #
     #   class BlogPost
@@ -190,8 +191,8 @@ module ActiveModel
 
     private
 
-    def _singularize(string, replacement='_')
-      ActiveSupport::Inflector.underscore(string).tr('/', replacement)
+    def _singularize(string)
+      ActiveSupport::Inflector.underscore(string).tr('/'.freeze, '_'.freeze)
     end
   end
 
@@ -212,7 +213,7 @@ module ActiveModel
   #   BookModule::BookCover.model_name.i18n_key  # => :"book_module/book_cover"
   #
   # Providing the functionality that ActiveModel::Naming provides in your object
-  # is required to pass the Active Model Lint test. So either extending the
+  # is required to pass the \Active \Model Lint test. So either extending the
   # provided method below, or rolling your own is required.
   module Naming
     def self.extended(base) #:nodoc:

data/lib/active_model/secure_password.rb

@@ -26,7 +26,7 @@ module ActiveModel
       # it). When this attribute has a +nil+ value, the validation will not be
       # triggered.
       #
-      # For further customizability, it is possible to supress the default
+      # For further customizability, it is possible to suppress the default
       # validations by passing <tt>validations: false</tt> as an argument.
       #
       # Add bcrypt (~> 3.1.7) to Gemfile to use #has_secure_password:
@@ -77,13 +77,6 @@ module ActiveModel
           validates_length_of :password, maximum: ActiveModel::SecurePassword::MAX_PASSWORD_LENGTH_ALLOWED
           validates_confirmation_of :password, allow_blank: true
         end
-
-        # This code is necessary as long as the protected_attributes gem is supported.
-        if respond_to?(:attributes_protected_by_default)
-          def self.attributes_protected_by_default #:nodoc:
-            super + ['password_digest']
-          end
-        end
       end
     end
 
@@ -99,7 +92,7 @@ module ActiveModel
       #   user.authenticate('notright')      # => false
       #   user.authenticate('mUc3m00RsqyRe') # => user
       def authenticate(unencrypted_password)
-        BCrypt::Password.new(password_digest) == unencrypted_password && self
+        BCrypt::Password.new(password_digest).is_password?(unencrypted_password) && self
       end
 
       attr_reader :password

data/lib/active_model/serialization.rb

@@ -31,16 +31,14 @@ module ActiveModel
   # of the attributes hash's keys. In order to override this behavior, take a look
   # at the private method +read_attribute_for_serialization+.
   #
-  # Most of the time though, either the JSON or XML serializations are needed.
-  # Both of these modules automatically include the
-  # <tt>ActiveModel::Serialization</tt> module, so there is no need to
-  # explicitly include it.
+  # ActiveModel::Serializers::JSON module automatically includes
+  # the <tt>ActiveModel::Serialization</tt> module, so there is no need to
+  # explicitly include <tt>ActiveModel::Serialization</tt>.
   #
-  # A minimal implementation including XML and JSON would be:
+  # A minimal implementation including JSON would be:
   #
   #   class Person
   #     include ActiveModel::Serializers::JSON
-  #     include ActiveModel::Serializers::Xml
   #
   #     attr_accessor :name
   #
@@ -55,13 +53,11 @@ module ActiveModel
   #   person.serializable_hash   # => {"name"=>nil}
   #   person.as_json             # => {"name"=>nil}
   #   person.to_json             # => "{\"name\":null}"
-  #   person.to_xml              # => "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<serial-person...
   #
   #   person.name = "Bob"
   #   person.serializable_hash   # => {"name"=>"Bob"}
   #   person.as_json             # => {"name"=>"Bob"}
   #   person.to_json             # => "{\"name\":\"Bob\"}"
-  #   person.to_xml              # => "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<serial-person...
   #
   # Valid options are <tt>:only</tt>, <tt>:except</tt>, <tt>:methods</tt> and
   # <tt>:include</tt>. The following are all valid examples:
@@ -94,6 +90,37 @@ module ActiveModel
     #   person.serializable_hash(except: :name) # => {"age"=>22}
     #   person.serializable_hash(methods: :capitalized_name)
     #   # => {"name"=>"bob", "age"=>22, "capitalized_name"=>"Bob"}
+    #
+    # Example with <tt>:include</tt> option
+    #
+    #   class User
+    #     include ActiveModel::Serializers::JSON
+    #     attr_accessor :name, :notes # Emulate has_many :notes
+    #     def attributes
+    #       {'name' => nil}
+    #     end
+    #   end
+    #
+    #   class Note
+    #     include ActiveModel::Serializers::JSON
+    #     attr_accessor :title, :text
+    #     def attributes
+    #       {'title' => nil, 'text' => nil}
+    #     end
+    #   end
+    #
+    #   note = Note.new
+    #   note.title = 'Battle of Austerlitz'
+    #   note.text = 'Some text here'
+    #
+    #   user = User.new
+    #   user.name = 'Napoleon'
+    #   user.notes = [note]
+    #
+    #   user.serializable_hash
+    #   # => {"name" => "Napoleon"}
+    #   user.serializable_hash(include: { notes: { only: 'title' }})
+    #   # => {"name" => "Napoleon", "notes" => [{"title"=>"Battle of Austerlitz"}]}
     def serializable_hash(options = nil)
       options ||= {}
 
@@ -107,7 +134,7 @@ module ActiveModel
       hash = {}
       attribute_names.each { |n| hash[n] = read_attribute_for_serialization(n) }
 
-      Array(options[:methods]).each { |m| hash[m.to_s] = send(m) if respond_to?(m) }
+      Array(options[:methods]).each { |m| hash[m.to_s] = send(m) }
 
       serializable_add_includes(options) do |association, records, opts|
         hash[association.to_s] = if records.respond_to?(:to_ary)

data/lib/active_model/serializers/json.rb

@@ -10,7 +10,7 @@ module ActiveModel
       included do
         extend ActiveModel::Naming
 
-        class_attribute :include_root_in_json, instance_writer: false
+        class_attribute :include_root_in_json
         self.include_root_in_json = false
       end
 

data/lib/active_model/type.rb

@@ -0,0 +1,59 @@
+require 'active_model/type/helpers'
+require 'active_model/type/value'
+
+require 'active_model/type/big_integer'
+require 'active_model/type/binary'
+require 'active_model/type/boolean'
+require 'active_model/type/date'
+require 'active_model/type/date_time'
+require 'active_model/type/decimal'
+require 'active_model/type/decimal_without_scale'
+require 'active_model/type/float'
+require 'active_model/type/immutable_string'
+require 'active_model/type/integer'
+require 'active_model/type/string'
+require 'active_model/type/text'
+require 'active_model/type/time'
+require 'active_model/type/unsigned_integer'
+
+require 'active_model/type/registry'
+
+module ActiveModel
+  module Type
+    @registry = Registry.new
+
+    class << self
+      attr_accessor :registry # :nodoc:
+      delegate :add_modifier, to: :registry
+
+      # Add a new type to the registry, allowing it to be referenced as a
+      # symbol by ActiveModel::Attributes::ClassMethods#attribute.  If your
+      # type is only meant to be used with a specific database adapter, you can
+      # do so by passing +adapter: :postgresql+. If your type has the same
+      # name as a native type for the current adapter, an exception will be
+      # raised unless you specify an +:override+ option. +override: true+ will
+      # cause your type to be used instead of the native type. +override:
+      # false+ will cause the native type to be used over yours if one exists.
+      def register(type_name, klass = nil, **options, &block)
+        registry.register(type_name, klass, **options, &block)
+      end
+
+      def lookup(*args, **kwargs) # :nodoc:
+        registry.lookup(*args, **kwargs)
+      end
+    end
+
+    register(:big_integer, Type::BigInteger)
+    register(:binary, Type::Binary)
+    register(:boolean, Type::Boolean)
+    register(:date, Type::Date)
+    register(:date_time, Type::DateTime)
+    register(:decimal, Type::Decimal)
+    register(:float, Type::Float)
+    register(:immutable_string, Type::ImmutableString)
+    register(:integer, Type::Integer)
+    register(:string, Type::String)
+    register(:text, Type::Text)
+    register(:time, Type::Time)
+  end
+end

data/lib/active_model/type/big_integer.rb

@@ -0,0 +1,13 @@
+require 'active_model/type/integer'
+
+module ActiveModel
+  module Type
+    class BigInteger < Integer # :nodoc:
+      private
+
+      def max_value
+        ::Float::INFINITY
+      end
+    end
+  end
+end

data/lib/active_model/type/binary.rb

@@ -0,0 +1,50 @@
+module ActiveModel
+  module Type
+    class Binary < Value # :nodoc:
+      def type
+        :binary
+      end
+
+      def binary?
+        true
+      end
+
+      def cast(value)
+        if value.is_a?(Data)
+          value.to_s
+        else
+          super
+        end
+      end
+
+      def serialize(value)
+        return if value.nil?
+        Data.new(super)
+      end
+
+      def changed_in_place?(raw_old_value, value)
+        old_value = deserialize(raw_old_value)
+        old_value != value
+      end
+
+      class Data # :nodoc:
+        def initialize(value)
+          @value = value.to_s
+        end
+
+        def to_s
+          @value
+        end
+        alias_method :to_str, :to_s
+
+        def hex
+          @value.unpack('H*')[0]
+        end
+
+        def ==(other)
+          other == to_s || super
+        end
+      end
+    end
+  end
+end