activemodel 6.0.5.1 → 6.1.7.4

data/lib/active_model/attribute_methods.rb

@@ -207,10 +207,12 @@ module ActiveModel
       #   person.nickname_short? # => true
       def alias_attribute(new_name, old_name)
         self.attribute_aliases = attribute_aliases.merge(new_name.to_s => old_name.to_s)
-        attribute_method_matchers.each do |matcher|
-          matcher_new = matcher.method_name(new_name).to_s
-          matcher_old = matcher.method_name(old_name).to_s
-          define_proxy_call false, self, matcher_new, matcher_old
+        CodeGenerator.batch(self, __FILE__, __LINE__) do |owner|
+          attribute_method_matchers.each do |matcher|
+            matcher_new = matcher.method_name(new_name).to_s
+            matcher_old = matcher.method_name(old_name).to_s
+            define_proxy_call false, owner, matcher_new, matcher_old
+          end
         end
       end
 
@@ -249,7 +251,9 @@ module ActiveModel
       #     end
       #   end
       def define_attribute_methods(*attr_names)
-        attr_names.flatten.each { |attr_name| define_attribute_method(attr_name) }
+        CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |owner|
+          attr_names.flatten.each { |attr_name| define_attribute_method(attr_name, _owner: owner) }
+        end
       end
 
       # Declares an attribute that should be prefixed and suffixed by
@@ -281,21 +285,23 @@ module ActiveModel
       #   person.name = 'Bob'
       #   person.name        # => "Bob"
       #   person.name_short? # => true
-      def define_attribute_method(attr_name)
-        attribute_method_matchers.each do |matcher|
-          method_name = matcher.method_name(attr_name)
-
-          unless instance_method_already_implemented?(method_name)
-            generate_method = "define_method_#{matcher.target}"
-
-            if respond_to?(generate_method, true)
-              send(generate_method, attr_name.to_s)
-            else
-              define_proxy_call true, generated_attribute_methods, method_name, matcher.target, attr_name.to_s
+      def define_attribute_method(attr_name, _owner: generated_attribute_methods)
+        CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|
+          attribute_method_matchers.each do |matcher|
+            method_name = matcher.method_name(attr_name)
+
+            unless instance_method_already_implemented?(method_name)
+              generate_method = "define_method_#{matcher.target}"
+
+              if respond_to?(generate_method, true)
+                send(generate_method, attr_name.to_s, owner: owner)
+              else
+                define_proxy_call true, owner, method_name, matcher.target, attr_name.to_s
+              end
             end
           end
+          attribute_method_matchers_cache.clear
         end
-        attribute_method_matchers_cache.clear
       end
 
       # Removes all the previously dynamically defined methods from the class.
@@ -323,12 +329,52 @@ module ActiveModel
       #   person.name_short? # => NoMethodError
       def undefine_attribute_methods
         generated_attribute_methods.module_eval do
-          instance_methods.each { |m| undef_method(m) }
+          undef_method(*instance_methods)
         end
         attribute_method_matchers_cache.clear
       end
 
       private
+        class CodeGenerator
+          class << self
+            def batch(owner, path, line)
+              if owner.is_a?(CodeGenerator)
+                yield owner
+              else
+                instance = new(owner, path, line)
+                result = yield instance
+                instance.execute
+                result
+              end
+            end
+          end
+
+          def initialize(owner, path, line)
+            @owner = owner
+            @path = path
+            @line = line
+            @sources = ["# frozen_string_literal: true\n"]
+            @renames = {}
+          end
+
+          def <<(source_line)
+            @sources << source_line
+          end
+
+          def rename_method(old_name, new_name)
+            @renames[old_name] = new_name
+          end
+
+          def execute
+            @owner.module_eval(@sources.join(";"), @path, @line - 1)
+            @renames.each do |old_name, new_name|
+              @owner.alias_method new_name, old_name
+              @owner.undef_method old_name
+            end
+          end
+        end
+        private_constant :CodeGenerator
+
         def generated_attribute_methods
           @generated_attribute_methods ||= Module.new.tap { |mod| include mod }
         end
@@ -352,18 +398,14 @@ module ActiveModel
 
         def attribute_method_matchers_matching(method_name)
           attribute_method_matchers_cache.compute_if_absent(method_name) do
-            # Bump plain matcher to last place so that only methods that do not
-            # match any other pattern match the actual attribute name.
-            # This is currently only needed to support legacy usage.
-            matchers = attribute_method_matchers.partition(&:plain?).reverse.flatten(1)
-            matchers.map { |matcher| matcher.match(method_name) }.compact
+            attribute_method_matchers.map { |matcher| matcher.match(method_name) }.compact
           end
         end
 
         # Define a method `name` in `mod` that dispatches to `send`
         # using the given `extra` args. This falls back on `define_method`
         # and `send` if the given names cannot be compiled.
-        def define_proxy_call(include_private, mod, name, target, *extra)
+        def define_proxy_call(include_private, code_generator, name, target, *extra)
           defn = if NAME_COMPILABLE_REGEXP.match?(name)
             "def #{name}(*args)"
           else
@@ -378,12 +420,11 @@ module ActiveModel
             "send(:'#{target}', #{extra})"
           end
 
-          mod.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-            #{defn}
-              #{body}
-            end
-            ruby2_keywords(:'#{name}') if respond_to?(:ruby2_keywords, true)
-          RUBY
+          code_generator <<
+            defn <<
+            body <<
+            "end" <<
+            "ruby2_keywords(:'#{name}') if respond_to?(:ruby2_keywords, true)"
         end
 
         class AttributeMethodMatcher #:nodoc:
@@ -407,10 +448,6 @@ module ActiveModel
           def method_name(attr_name)
             @method_name % attr_name
           end
-
-          def plain?
-            prefix.empty? && suffix.empty?
-          end
         end
     end
 
@@ -499,10 +536,10 @@ module ActiveModel
         # to allocate an object on each call to the attribute method.
         # Making it frozen means that it doesn't get duped when used to
         # key the @attributes in read_attribute.
-        def self.define_attribute_accessor_method(mod, attr_name, writer: false)
+        def self.define_attribute_accessor_method(owner, attr_name, writer: false)
           method_name = "#{attr_name}#{'=' if writer}"
           if attr_name.ascii_only? && DEF_SAFE_NAME.match?(attr_name)
-            yield method_name, "'#{attr_name}'.freeze"
+            yield method_name, "'#{attr_name}'"
           else
             safe_name = attr_name.unpack1("h*")
             const_name = "ATTR_#{safe_name}"
@@ -510,8 +547,7 @@ module ActiveModel
             temp_method_name = "__temp__#{safe_name}#{'=' if writer}"
             attr_name_expr = "::ActiveModel::AttributeMethods::AttrNames::#{const_name}"
             yield temp_method_name, attr_name_expr
-            mod.alias_method method_name, temp_method_name
-            mod.undef_method temp_method_name
+            owner.rename_method(temp_method_name, method_name)
           end
         end
       end

data/lib/active_model/attribute_mutation_tracker.rb

@@ -7,9 +7,8 @@ module ActiveModel
   class AttributeMutationTracker # :nodoc:
     OPTION_NOT_GIVEN = Object.new
 
-    def initialize(attributes, forced_changes = Set.new)
+    def initialize(attributes)
       @attributes = attributes
-      @forced_changes = forced_changes
     end
 
     def changed_attribute_names
@@ -62,11 +61,15 @@ module ActiveModel
     end
 
     def force_change(attr_name)
-      forced_changes << attr_name
+      forced_changes[attr_name] = fetch_value(attr_name)
     end
 
     private
-      attr_reader :attributes, :forced_changes
+      attr_reader :attributes
+
+      def forced_changes
+        @forced_changes ||= {}
+      end
 
       def attr_names
         attributes.keys
@@ -82,7 +85,7 @@ module ActiveModel
   end
 
   class ForcedMutationTracker < AttributeMutationTracker # :nodoc:
-    def initialize(attributes, forced_changes = {})
+    def initialize(attributes)
       super
       @finalized_changes = nil
     end

data/lib/active_model/attribute_set/builder.rb

@@ -13,14 +13,86 @@ module ActiveModel
       end
 
       def build_from_database(values = {}, additional_types = {})
-        attributes = LazyAttributeHash.new(types, values, additional_types, default_attributes)
-        AttributeSet.new(attributes)
+        LazyAttributeSet.new(values, types, additional_types, default_attributes)
       end
     end
   end
 
+  class LazyAttributeSet < AttributeSet # :nodoc:
+    def initialize(values, types, additional_types, default_attributes, attributes = {})
+      super(attributes)
+      @values = values
+      @types = types
+      @additional_types = additional_types
+      @default_attributes = default_attributes
+      @casted_values = {}
+      @materialized = false
+    end
+
+    def key?(name)
+      (values.key?(name) || types.key?(name) || @attributes.key?(name)) && self[name].initialized?
+    end
+
+    def keys
+      keys = values.keys | types.keys | @attributes.keys
+      keys.keep_if { |name| self[name].initialized? }
+    end
+
+    def fetch_value(name, &block)
+      if attr = @attributes[name]
+        return attr.value(&block)
+      end
+
+      @casted_values.fetch(name) do
+        value_present = true
+        value = values.fetch(name) { value_present = false }
+
+        if value_present
+          type = additional_types.fetch(name, types[name])
+          @casted_values[name] = type.deserialize(value)
+        else
+          attr = default_attribute(name, value_present, value)
+          attr.value(&block)
+        end
+      end
+    end
+
+    protected
+      def attributes
+        unless @materialized
+          values.each_key { |key| self[key] }
+          types.each_key { |key| self[key] }
+          @materialized = true
+        end
+        @attributes
+      end
+
+    private
+      attr_reader :values, :types, :additional_types, :default_attributes
+
+      def default_attribute(
+        name,
+        value_present = true,
+        value = values.fetch(name) { value_present = false }
+      )
+        type = additional_types.fetch(name, types[name])
+
+        if value_present
+          @attributes[name] = Attribute.from_database(name, value, type, @casted_values[name])
+        elsif types.key?(name)
+          if attr = default_attributes[name]
+            @attributes[name] = attr.dup
+          else
+            @attributes[name] = Attribute.uninitialized(name, type)
+          end
+        else
+          Attribute.null(name)
+        end
+      end
+  end
+
   class LazyAttributeHash # :nodoc:
-    delegate :transform_values, :each_key, :each_value, :fetch, :except, to: :materialize
+    delegate :transform_values, :each_value, :fetch, :except, to: :materialize
 
     def initialize(types, values, additional_types, default_attributes, delegate_hash = {})
       @types = types
@@ -40,9 +112,6 @@ module ActiveModel
     end
 
     def []=(key, value)
-      if frozen?
-        raise RuntimeError, "Can't modify frozen hash"
-      end
       delegate_hash[key] = value
     end
 
@@ -57,14 +126,9 @@ module ActiveModel
       super
     end
 
-    def select
+    def each_key(&block)
       keys = types.keys | values.keys | delegate_hash.keys
-      keys.each_with_object({}) do |key, hash|
-        attribute = self[key]
-        if yield(key, attribute)
-          hash[key] = attribute
-        end
-      end
+      keys.each(&block)
     end
 
     def ==(other)
@@ -81,6 +145,9 @@ module ActiveModel
 
     def marshal_load(values)
       if values.is_a?(Hash)
+        ActiveSupport::Deprecation.warn(<<~MSG)
+          Marshalling load from legacy attributes format is deprecated and will be removed in Rails 7.0.
+        MSG
         empty_hash = {}.freeze
         initialize(empty_hash, empty_hash, empty_hash, empty_hash, values)
         @materialized = true

data/lib/active_model/attribute_set.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/enumerable"
 require "active_support/core_ext/object/deep_dup"
 require "active_model/attribute_set/builder"
 require "active_model/attribute_set/yaml_encoder"
@@ -13,11 +14,11 @@ module ActiveModel
     end
 
     def [](name)
-      attributes[name] || Attribute.null(name)
+      @attributes[name] || default_attribute(name)
     end
 
     def []=(name, value)
-      attributes[name] = value
+      @attributes[name] = value
     end
 
     def values_before_type_cast
@@ -25,9 +26,9 @@ module ActiveModel
     end
 
     def to_hash
-      initialized_attributes.transform_values(&:value)
+      keys.index_with { |name| self[name].value }
     end
-    alias_method :to_h, :to_hash
+    alias :to_h :to_hash
 
     def key?(name)
       attributes.key?(name) && self[name].initialized?
@@ -42,35 +43,36 @@ module ActiveModel
     end
 
     def write_from_database(name, value)
-      attributes[name] = self[name].with_value_from_database(value)
+      @attributes[name] = self[name].with_value_from_database(value)
     end
 
     def write_from_user(name, value)
-      attributes[name] = self[name].with_value_from_user(value)
+      raise FrozenError, "can't modify frozen attributes" if frozen?
+      @attributes[name] = self[name].with_value_from_user(value)
+      value
     end
 
     def write_cast_value(name, value)
-      attributes[name] = self[name].with_cast_value(value)
+      @attributes[name] = self[name].with_cast_value(value)
+      value
     end
 
     def freeze
-      @attributes.freeze
+      attributes.freeze
       super
     end
 
     def deep_dup
-      self.class.allocate.tap do |copy|
-        copy.instance_variable_set(:@attributes, attributes.deep_dup)
-      end
+      AttributeSet.new(attributes.deep_dup)
     end
 
     def initialize_dup(_)
-      @attributes = attributes.dup
+      @attributes = @attributes.dup
       super
     end
 
     def initialize_clone(_)
-      @attributes = attributes.clone
+      @attributes = @attributes.clone
       super
     end
 
@@ -81,7 +83,7 @@ module ActiveModel
     end
 
     def accessed
-      attributes.select { |_, attr| attr.has_been_read? }.keys
+      attributes.each_key.select { |name| self[name].has_been_read? }
     end
 
     def map(&block)
@@ -97,8 +99,8 @@ module ActiveModel
       attr_reader :attributes
 
     private
-      def initialized_attributes
-        attributes.select { |_, attr| attr.initialized? }
+      def default_attribute(name)
+        Attribute.null(name)
       end
   end
 end

data/lib/active_model/attributes.rb

@@ -42,16 +42,14 @@ module ActiveModel
       end
 
       private
-        def define_method_attribute=(name)
+        def define_method_attribute=(name, owner:)
           ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
-            generated_attribute_methods, name, writer: true,
+            owner, name, writer: true,
           ) do |temp_method_name, attr_name_expr|
-            generated_attribute_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{temp_method_name}(value)
-                name = #{attr_name_expr}
-                write_attribute(name, value)
-              end
-            RUBY
+            owner <<
+              "def #{temp_method_name}(value)" <<
+              "  _write_attribute(#{attr_name_expr}, value)" <<
+              "end"
           end
         end
 
@@ -79,10 +77,14 @@ module ActiveModel
       super
     end
 
+    def initialize_dup(other) # :nodoc:
+      @attributes = @attributes.deep_dup
+      super
+    end
+
     # Returns a hash of all the attributes with their names as keys and the values of the attributes as values.
     #
     #   class Person
-    #     include ActiveModel::Model
     #     include ActiveModel::Attributes
     #
     #     attribute :name, :string
@@ -112,25 +114,19 @@ module ActiveModel
       @attributes.keys
     end
 
-    private
-      def write_attribute(attr_name, value)
-        name = attr_name.to_s
-        name = self.class.attribute_aliases[name] || name
+    def freeze
+      @attributes = @attributes.clone.freeze unless frozen?
+      super
+    end
 
-        @attributes.write_from_user(name, value)
-        value
+    private
+      def _write_attribute(attr_name, value)
+        @attributes.write_from_user(attr_name, value)
       end
+      alias :attribute= :_write_attribute
 
       def attribute(attr_name)
-        name = attr_name.to_s
-        name = self.class.attribute_aliases[name] || name
-
-        @attributes.fetch_value(name)
-      end
-
-      # Dispatch target for <tt>*=</tt> attribute methods.
-      def attribute=(attribute_name, value)
-        write_attribute(attribute_name, value)
+        @attributes.fetch_value(attr_name)
       end
   end
 end

data/lib/active_model/callbacks.rb

@@ -147,7 +147,7 @@ module ActiveModel
           conditional = ActiveSupport::Callbacks::Conditionals::Value.new { |v|
             v != false
           }
-          options[:if] = Array(options[:if]) << conditional
+          options[:if] = Array(options[:if]) + [conditional]
           set_callback(:"#{callback}", :after, *args, options, &block)
         end
       end

data/lib/active_model/dirty.rb

@@ -83,7 +83,9 @@ module ActiveModel
   #
   #   person.previous_changes         # => {"name" => [nil, "Bill"]}
   #   person.name_previously_changed? # => true
+  #   person.name_previously_changed?(from: nil, to: "Bill") # => true
   #   person.name_previous_change     # => [nil, "Bill"]
+  #   person.name_previously_was      # => nil
   #   person.reload!
   #   person.previous_changes         # => {}
   #
@@ -122,8 +124,9 @@ module ActiveModel
 
     included do
       attribute_method_suffix "_changed?", "_change", "_will_change!", "_was"
-      attribute_method_suffix "_previously_changed?", "_previous_change"
+      attribute_method_suffix "_previously_changed?", "_previous_change", "_previously_was"
       attribute_method_affix prefix: "restore_", suffix: "!"
+      attribute_method_affix prefix: "clear_", suffix: "_change"
     end
 
     def initialize_dup(other) # :nodoc:
@@ -136,7 +139,12 @@ module ActiveModel
       @mutations_from_database = nil
     end
 
-    # Clears dirty data and moves +changes+ to +previously_changed+ and
+    def as_json(options = {}) # :nodoc:
+      options[:except] = [*options[:except], "mutations_from_database", "mutations_before_last_save"]
+      super(options)
+    end
+
+    # Clears dirty data and moves +changes+ to +previous_changes+ and
     # +mutations_from_database+ to +mutations_before_last_save+ respectively.
     def changes_applied
       unless defined?(@attributes)
@@ -176,8 +184,13 @@ module ActiveModel
     end
 
     # Dispatch target for <tt>*_previously_changed?</tt> attribute methods.
-    def attribute_previously_changed?(attr_name) # :nodoc:
-      mutations_before_last_save.changed?(attr_name.to_s)
+    def attribute_previously_changed?(attr_name, **options) # :nodoc:
+      mutations_before_last_save.changed?(attr_name.to_s, **options)
+    end
+
+    # Dispatch target for <tt>*_previously_was</tt> attribute methods.
+    def attribute_previously_was(attr_name) # :nodoc:
+      mutations_before_last_save.original_value(attr_name.to_s)
     end
 
     # Restore all previous data of the provided attributes.