activemodel 5.1.7 → 5.2.0.beta1

data/lib/active_model/attributes.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/deep_dup"
+require "active_model/attribute_set"
+require "active_model/attribute/user_provided_default"
+
+module ActiveModel
+  module Attributes #:nodoc:
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+
+    included do
+      attribute_method_suffix "="
+      class_attribute :attribute_types, :_default_attributes, instance_accessor: false
+      self.attribute_types = Hash.new(Type.default_value)
+      self._default_attributes = AttributeSet.new({})
+    end
+
+    module ClassMethods
+      def attribute(name, type = Type::Value.new, **options)
+        name = name.to_s
+        if type.is_a?(Symbol)
+          type = ActiveModel::Type.lookup(type, **options.except(:default))
+        end
+        self.attribute_types = attribute_types.merge(name => type)
+        define_default_attribute(name, options.fetch(:default, NO_DEFAULT_PROVIDED), type)
+        define_attribute_methods(name)
+      end
+
+      private
+
+        def define_method_attribute=(name)
+          safe_name = name.unpack("h*".freeze).first
+          ActiveModel::AttributeMethods::AttrNames.set_name_cache safe_name, name
+
+          generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            def __temp__#{safe_name}=(value)
+              name = ::ActiveModel::AttributeMethods::AttrNames::ATTR_#{safe_name}
+              write_attribute(name, value)
+            end
+            alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
+            undef_method :__temp__#{safe_name}=
+          STR
+        end
+
+        NO_DEFAULT_PROVIDED = Object.new # :nodoc:
+        private_constant :NO_DEFAULT_PROVIDED
+
+        def define_default_attribute(name, value, type)
+          self._default_attributes = _default_attributes.deep_dup
+          if value == NO_DEFAULT_PROVIDED
+            default_attribute = _default_attributes[name].with_type(type)
+          else
+            default_attribute = Attribute::UserProvidedDefault.new(
+              name,
+              value,
+              type,
+              _default_attributes.fetch(name.to_s) { nil },
+            )
+          end
+          _default_attributes[name] = default_attribute
+        end
+    end
+
+    def initialize(*)
+      @attributes = self.class._default_attributes.deep_dup
+      super
+    end
+
+    private
+
+      def write_attribute(attr_name, value)
+        name = if self.class.attribute_alias?(attr_name)
+          self.class.attribute_alias(attr_name).to_s
+        else
+          attr_name.to_s
+        end
+
+        @attributes.write_from_user(name, value)
+        value
+      end
+
+      def attribute(attr_name)
+        name = if self.class.attribute_alias?(attr_name)
+          self.class.attribute_alias(attr_name).to_s
+        else
+          attr_name.to_s
+        end
+        @attributes.fetch_value(name)
+      end
+
+      # Handle *= for method_missing.
+      def attribute=(attribute_name, value)
+        write_attribute(attribute_name, value)
+      end
+  end
+
+  module AttributeMethods #:nodoc:
+    AttrNames = Module.new {
+      def self.set_name_cache(name, value)
+        const_name = "ATTR_#{name}"
+        unless const_defined? const_name
+          const_set const_name, value.dup.freeze
+        end
+      end
+    }
+  end
+end

data/lib/active_model/callbacks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/array/extract_options"
 
 module ActiveModel
@@ -56,6 +58,9 @@ module ActiveModel
   #
   # Would only create the +after_create+ and +before_create+ callback methods in
   # your class.
+  #
+  # NOTE: Calling the same callback multiple times will overwrite previous callback definitions.
+  #
   module Callbacks
     def self.extended(base) #:nodoc:
       base.class_eval do
@@ -98,8 +103,8 @@ module ActiveModel
     #     end
     #   end
     #
-    # NOTE: +method_name+ passed to `define_model_callbacks` must not end with
-    # `!`, `?` or `=`.
+    # NOTE: +method_name+ passed to define_model_callbacks must not end with
+    # <tt>!</tt>, <tt>?</tt> or <tt>=</tt>.
     def define_model_callbacks(*callbacks)
       options = callbacks.extract_options!
       options = {

data/lib/active_model/conversion.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveModel
   # == Active \Model \Conversion
   #

data/lib/active_model/dirty.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require "active_support/hash_with_indifferent_access"
 require "active_support/core_ext/object/duplicable"
+require "active_model/attribute_mutation_tracker"
 
 module ActiveModel
   # == Active \Model \Dirty
@@ -128,6 +131,24 @@ module ActiveModel
       attribute_method_affix prefix: "restore_", suffix: "!"
     end
 
+    def initialize_dup(other) # :nodoc:
+      super
+      if self.class.respond_to?(:_default_attributes)
+        @attributes = self.class._default_attributes.map do |attr|
+          attr.with_value_from_user(@attributes.fetch_value(attr.name))
+        end
+      end
+      @mutations_from_database = nil
+    end
+
+    def changes_applied # :nodoc:
+      @previously_changed = changes
+      @mutations_before_last_save = mutations_from_database
+      @attributes_changed_by_setter = ActiveSupport::HashWithIndifferentAccess.new
+      forget_attribute_assignments
+      @mutations_from_database = nil
+    end
+
     # Returns +true+ if any of the attributes have unsaved changes, +false+ otherwise.
     #
     #   person.changed? # => false
@@ -146,6 +167,60 @@ module ActiveModel
       changed_attributes.keys
     end
 
+    # Handles <tt>*_changed?</tt> for +method_missing+.
+    def attribute_changed?(attr, from: OPTION_NOT_GIVEN, to: OPTION_NOT_GIVEN) # :nodoc:
+      !!changes_include?(attr) &&
+        (to == OPTION_NOT_GIVEN || to == _read_attribute(attr)) &&
+        (from == OPTION_NOT_GIVEN || from == changed_attributes[attr])
+    end
+
+    # Handles <tt>*_was</tt> for +method_missing+.
+    def attribute_was(attr) # :nodoc:
+      attribute_changed?(attr) ? changed_attributes[attr] : _read_attribute(attr)
+    end
+
+    # Handles <tt>*_previously_changed?</tt> for +method_missing+.
+    def attribute_previously_changed?(attr) #:nodoc:
+      previous_changes_include?(attr)
+    end
+
+    # Restore all previous data of the provided attributes.
+    def restore_attributes(attributes = changed)
+      attributes.each { |attr| restore_attribute! attr }
+    end
+
+    # Clears all dirty data: current changes and previous changes.
+    def clear_changes_information
+      @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
+      @mutations_before_last_save = nil
+      @attributes_changed_by_setter = ActiveSupport::HashWithIndifferentAccess.new
+      forget_attribute_assignments
+      @mutations_from_database = nil
+    end
+
+    def clear_attribute_changes(attr_names)
+      attributes_changed_by_setter.except!(*attr_names)
+      attr_names.each do |attr_name|
+        clear_attribute_change(attr_name)
+      end
+    end
+
+    # Returns a hash of the attributes with unsaved changes indicating their original
+    # values like <tt>attr => original value</tt>.
+    #
+    #   person.name # => "bob"
+    #   person.name = 'robert'
+    #   person.changed_attributes # => {"name" => "bob"}
+    def changed_attributes
+      # This should only be set by methods which will call changed_attributes
+      # multiple times when it is known that the computed value cannot change.
+      if defined?(@cached_changed_attributes)
+        @cached_changed_attributes
+      else
+        attributes_changed_by_setter.reverse_merge(mutations_from_database.changed_values).freeze
+      end
+    end
+
     # Returns a hash of changed attributes indicating their original
     # and new values like <tt>attr => [original value, new value]</tt>.
     #
@@ -153,7 +228,9 @@ module ActiveModel
     #   person.name = 'bob'
     #   person.changes # => { "name" => ["bill", "bob"] }
     def changes
-      ActiveSupport::HashWithIndifferentAccess[changed.map { |attr| [attr, attribute_change(attr)] }]
+      cache_changed_attributes do
+        ActiveSupport::HashWithIndifferentAccess[changed.map { |attr| [attr, attribute_change(attr)] }]
+      end
     end
 
     # Returns a hash of attributes that were changed before the model was saved.
@@ -164,45 +241,51 @@ module ActiveModel
     #   person.previous_changes # => {"name" => ["bob", "robert"]}
     def previous_changes
       @previously_changed ||= ActiveSupport::HashWithIndifferentAccess.new
+      @previously_changed.merge(mutations_before_last_save.changes)
     end
 
-    # Returns a hash of the attributes with unsaved changes indicating their original
-    # values like <tt>attr => original value</tt>.
-    #
-    #   person.name # => "bob"
-    #   person.name = 'robert'
-    #   person.changed_attributes # => {"name" => "bob"}
-    def changed_attributes
-      @changed_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
+    def attribute_changed_in_place?(attr_name) # :nodoc:
+      mutations_from_database.changed_in_place?(attr_name)
     end
 
-    # Handles <tt>*_changed?</tt> for +method_missing+.
-    def attribute_changed?(attr, from: OPTION_NOT_GIVEN, to: OPTION_NOT_GIVEN) # :nodoc:
-      !!changes_include?(attr) &&
-        (to == OPTION_NOT_GIVEN || to == __send__(attr)) &&
-        (from == OPTION_NOT_GIVEN || from == changed_attributes[attr])
-    end
+    private
+      def clear_attribute_change(attr_name)
+        mutations_from_database.forget_change(attr_name)
+      end
 
-    # Handles <tt>*_was</tt> for +method_missing+.
-    def attribute_was(attr) # :nodoc:
-      attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
-    end
+      def mutations_from_database
+        unless defined?(@mutations_from_database)
+          @mutations_from_database = nil
+        end
+        @mutations_from_database ||= if defined?(@attributes)
+          ActiveModel::AttributeMutationTracker.new(@attributes)
+        else
+          NullMutationTracker.instance
+        end
+      end
 
-    # Handles <tt>*_previously_changed?</tt> for +method_missing+.
-    def attribute_previously_changed?(attr) #:nodoc:
-      previous_changes_include?(attr)
-    end
+      def forget_attribute_assignments
+        @attributes = @attributes.map(&:forgetting_assignment) if defined?(@attributes)
+      end
 
-    # Restore all previous data of the provided attributes.
-    def restore_attributes(attributes = changed)
-      attributes.each { |attr| restore_attribute! attr }
-    end
+      def mutations_before_last_save
+        @mutations_before_last_save ||= ActiveModel::NullMutationTracker.instance
+      end
 
-    private
+      def cache_changed_attributes
+        @cached_changed_attributes = changed_attributes
+        yield
+      ensure
+        clear_changed_attributes_cache
+      end
+
+      def clear_changed_attributes_cache
+        remove_instance_variable(:@cached_changed_attributes) if defined?(@cached_changed_attributes)
+      end
 
       # Returns +true+ if attr_name is changed, +false+ otherwise.
       def changes_include?(attr_name)
-        attributes_changed_by_setter.include?(attr_name)
+        attributes_changed_by_setter.include?(attr_name) || mutations_from_database.changed?(attr_name)
       end
       alias attribute_changed_by_setter? changes_include?
 
@@ -212,21 +295,9 @@ module ActiveModel
         previous_changes.include?(attr_name)
       end
 
-      # Removes current changes and makes them accessible through +previous_changes+.
-      def changes_applied # :doc:
-        @previously_changed = changes
-        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
-      end
-
-      # Clears all dirty data: current changes and previous changes.
-      def clear_changes_information # :doc:
-        @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
-        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
-      end
-
       # Handles <tt>*_change</tt> for +method_missing+.
       def attribute_change(attr)
-        [changed_attributes[attr], __send__(attr)] if attribute_changed?(attr)
+        [changed_attributes[attr], _read_attribute(attr)] if attribute_changed?(attr)
       end
 
       # Handles <tt>*_previous_change</tt> for +method_missing+.
@@ -236,15 +307,16 @@ module ActiveModel
 
       # Handles <tt>*_will_change!</tt> for +method_missing+.
       def attribute_will_change!(attr)
-        return if attribute_changed?(attr)
+        unless attribute_changed?(attr)
+          begin
+            value = _read_attribute(attr)
+            value = value.duplicable? ? value.clone : value
+          rescue TypeError, NoMethodError
+          end
 
-        begin
-          value = __send__(attr)
-          value = value.duplicable? ? value.clone : value
-        rescue TypeError, NoMethodError
+          set_attribute_was(attr, value)
         end
-
-        set_attribute_was(attr, value)
+        mutations_from_database.force_change(attr)
       end
 
       # Handles <tt>restore_*!</tt> for +method_missing+.
@@ -255,18 +327,13 @@ module ActiveModel
         end
       end
 
-      # This is necessary because `changed_attributes` might be overridden in
-      # other implementations (e.g. in `ActiveRecord`)
-      alias_method :attributes_changed_by_setter, :changed_attributes # :nodoc:
+      def attributes_changed_by_setter
+        @attributes_changed_by_setter ||= ActiveSupport::HashWithIndifferentAccess.new
+      end
 
       # Force an attribute to have a particular "before" value
       def set_attribute_was(attr, old_value)
         attributes_changed_by_setter[attr] = old_value
       end
-
-      # Remove changes information for the provided attributes.
-      def clear_attribute_changes(attributes) # :doc:
-        attributes_changed_by_setter.except!(*attributes)
-      end
   end
 end

data/lib/active_model/errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/array/conversions"
 require "active_support/core_ext/string/inflections"
 require "active_support/core_ext/object/deep_dup"
@@ -93,6 +95,18 @@ module ActiveModel
       @details  = other.details.dup
     end
 
+    # Merges the errors from <tt>other</tt>.
+    #
+    # other - The ActiveModel::Errors instance.
+    #
+    # Examples
+    #
+    #   person.errors.merge!(other)
+    def merge!(other)
+      @messages.merge!(other.messages) { |_, ary1, ary2| ary1 + ary2 }
+      @details.merge!(other.details) { |_, ary1, ary2| ary1 + ary2 }
+    end
+
     # Clear the error messages.
     #
     #   person.errors.full_messages # => ["name cannot be nil"]
@@ -132,15 +146,6 @@ module ActiveModel
     #
     #   person.errors[:name]  # => ["cannot be nil"]
     #   person.errors['name'] # => ["cannot be nil"]
-    #
-    # Note that, if you try to get errors of an attribute which has
-    # no errors associated with it, this method will instantiate
-    # an empty error list for it and +keys+ will return an array
-    # of error keys which includes this attribute.
-    #
-    #   person.errors.keys    # => []
-    #   person.errors[:name]  # => []
-    #   person.errors.keys    # => [:name]
     def [](attribute)
       messages[attribute.to_sym]
     end
@@ -181,7 +186,9 @@ module ActiveModel
     #   person.errors.messages # => {:name=>["cannot be nil", "must be specified"]}
     #   person.errors.values   # => [["cannot be nil", "must be specified"]]
     def values
-      messages.values
+      messages.select do |key, value|
+        !value.empty?
+      end.values
     end
 
     # Returns all message keys.
@@ -189,7 +196,9 @@ module ActiveModel
     #   person.errors.messages # => {:name=>["cannot be nil", "must be specified"]}
     #   person.errors.keys     # => [:name]
     def keys
-      messages.keys
+      messages.select do |key, value|
+        !value.empty?
+      end.keys
     end
 
     # Returns +true+ if no errors are found, +false+ otherwise.
@@ -313,9 +322,13 @@ module ActiveModel
     #  person.errors.added? :name, :too_long                                # => false
     #  person.errors.added? :name, "is too long"                            # => false
     def added?(attribute, message = :invalid, options = {})
-      message = message.call if message.respond_to?(:call)
-      message = normalize_message(attribute, message, options)
-      self[attribute].include? message
+      if message.is_a? Symbol
+        self.details[attribute].map { |e| e[:error] }.include? message
+      else
+        message = message.call if message.respond_to?(:call)
+        message = normalize_message(attribute, message, options)
+        self[attribute].include? message
+      end
     end
 
     # Returns all the full error messages in an array.
@@ -389,21 +402,19 @@ module ActiveModel
       type = options.delete(:message) if options[:message].is_a?(Symbol)
 
       if @base.class.respond_to?(:i18n_scope)
-        defaults = @base.class.lookup_ancestors.map do |klass|
-          [ :"#{@base.class.i18n_scope}.errors.models.#{klass.model_name.i18n_key}.attributes.#{attribute}.#{type}",
-            :"#{@base.class.i18n_scope}.errors.models.#{klass.model_name.i18n_key}.#{type}" ]
+        i18n_scope = @base.class.i18n_scope.to_s
+        defaults = @base.class.lookup_ancestors.flat_map do |klass|
+          [ :"#{i18n_scope}.errors.models.#{klass.model_name.i18n_key}.attributes.#{attribute}.#{type}",
+            :"#{i18n_scope}.errors.models.#{klass.model_name.i18n_key}.#{type}" ]
         end
+        defaults << :"#{i18n_scope}.errors.messages.#{type}"
       else
         defaults = []
       end
 
-      defaults << :"#{@base.class.i18n_scope}.errors.messages.#{type}" if @base.class.respond_to?(:i18n_scope)
       defaults << :"errors.attributes.#{attribute}.#{type}"
       defaults << :"errors.messages.#{type}"
 
-      defaults.compact!
-      defaults.flatten!
-
       key = defaults.shift
       defaults = options.delete(:message) if options[:message]
       value = (attribute != :base ? @base.send(:read_attribute_for_validation, attribute) : nil)