omg-activemodel 8.0.0.alpha1

data/lib/active_model/attribute_mutation_tracker.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/object/duplicable"
+
+module ActiveModel
+  class AttributeMutationTracker # :nodoc:
+    OPTION_NOT_GIVEN = Object.new
+
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def changed_attribute_names
+      attr_names.select { |attr_name| changed?(attr_name) }
+    end
+
+    def changed_values
+      attr_names.each_with_object({}.with_indifferent_access) do |attr_name, result|
+        if changed?(attr_name)
+          result[attr_name] = original_value(attr_name)
+        end
+      end
+    end
+
+    def changes
+      attr_names.each_with_object({}.with_indifferent_access) do |attr_name, result|
+        if change = change_to_attribute(attr_name)
+          result.merge!(attr_name => change)
+        end
+      end
+    end
+
+    def change_to_attribute(attr_name)
+      if changed?(attr_name)
+        [original_value(attr_name), fetch_value(attr_name)]
+      end
+    end
+
+    def any_changes?
+      attr_names.any? { |attr| changed?(attr) }
+    end
+
+    def changed?(attr_name, from: OPTION_NOT_GIVEN, to: OPTION_NOT_GIVEN)
+      attribute_changed?(attr_name) &&
+        (OPTION_NOT_GIVEN == from || original_value(attr_name) == type_cast(attr_name, from)) &&
+        (OPTION_NOT_GIVEN == to || fetch_value(attr_name) == type_cast(attr_name, to))
+    end
+
+    def changed_in_place?(attr_name)
+      attributes[attr_name].changed_in_place?
+    end
+
+    def forget_change(attr_name)
+      attributes[attr_name] = attributes[attr_name].forgetting_assignment
+      forced_changes.delete(attr_name)
+    end
+
+    def original_value(attr_name)
+      attributes[attr_name].original_value
+    end
+
+    def force_change(attr_name)
+      forced_changes[attr_name] = fetch_value(attr_name)
+    end
+
+    private
+      attr_reader :attributes
+
+      def forced_changes
+        @forced_changes ||= {}
+      end
+
+      def attr_names
+        attributes.keys
+      end
+
+      def attribute_changed?(attr_name)
+        forced_changes.include?(attr_name) || !!attributes[attr_name].changed?
+      end
+
+      def fetch_value(attr_name)
+        attributes.fetch_value(attr_name)
+      end
+
+      def type_cast(attr_name, value)
+        attributes[attr_name].type_cast(value)
+      end
+  end
+
+  class ForcedMutationTracker < AttributeMutationTracker # :nodoc:
+    def initialize(attributes)
+      super
+      @finalized_changes = nil
+    end
+
+    def changed_in_place?(attr_name)
+      false
+    end
+
+    def change_to_attribute(attr_name)
+      if finalized_changes&.include?(attr_name)
+        finalized_changes[attr_name].dup
+      else
+        super
+      end
+    end
+
+    def forget_change(attr_name)
+      forced_changes.delete(attr_name)
+    end
+
+    def original_value(attr_name)
+      if changed?(attr_name)
+        forced_changes[attr_name]
+      else
+        fetch_value(attr_name)
+      end
+    end
+
+    def force_change(attr_name)
+      forced_changes[attr_name] = clone_value(attr_name) unless attribute_changed?(attr_name)
+    end
+
+    def finalize_changes
+      @finalized_changes = changes
+    end
+
+    private
+      attr_reader :finalized_changes
+
+      def attr_names
+        forced_changes.keys
+      end
+
+      def attribute_changed?(attr_name)
+        forced_changes.include?(attr_name)
+      end
+
+      def fetch_value(attr_name)
+        attributes.send(:_read_attribute, attr_name)
+      end
+
+      def clone_value(attr_name)
+        value = fetch_value(attr_name)
+        value.duplicable? ? value.clone : value
+      rescue TypeError, NoMethodError
+        value
+      end
+
+      def type_cast(attr_name, value)
+        value
+      end
+  end
+
+  class NullMutationTracker # :nodoc:
+    include Singleton
+
+    def changed_attribute_names
+      []
+    end
+
+    def changed_values
+      {}
+    end
+
+    def changes
+      {}
+    end
+
+    def change_to_attribute(attr_name)
+    end
+
+    def any_changes?
+      false
+    end
+
+    def changed?(attr_name, **)
+      false
+    end
+
+    def changed_in_place?(attr_name)
+      false
+    end
+
+    def original_value(attr_name)
+    end
+  end
+end

data/lib/active_model/attribute_registration.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/class/subclasses"
+require "active_model/attribute_set"
+require "active_model/attribute/user_provided_default"
+
+module ActiveModel
+  module AttributeRegistration # :nodoc:
+    extend ActiveSupport::Concern
+
+    module ClassMethods # :nodoc:
+      def attribute(name, type = nil, default: (no_default = true), **options)
+        name = resolve_attribute_name(name)
+        type = resolve_type_name(type, **options) if type.is_a?(Symbol)
+        type = hook_attribute_type(name, type) if type
+
+        pending_attribute_modifications << PendingType.new(name, type) if type || no_default
+        pending_attribute_modifications << PendingDefault.new(name, default) unless no_default
+
+        reset_default_attributes
+      end
+
+      def decorate_attributes(names = nil, &decorator) # :nodoc:
+        names = names&.map { |name| resolve_attribute_name(name) }
+
+        pending_attribute_modifications << PendingDecorator.new(names, decorator)
+
+        reset_default_attributes
+      end
+
+      def _default_attributes # :nodoc:
+        @default_attributes ||= AttributeSet.new({}).tap do |attribute_set|
+          apply_pending_attribute_modifications(attribute_set)
+        end
+      end
+
+      def attribute_types # :nodoc:
+        @attribute_types ||= _default_attributes.cast_types.tap do |hash|
+          hash.default = Type.default_value
+        end
+      end
+
+      def type_for_attribute(attribute_name, &block)
+        attribute_name = resolve_attribute_name(attribute_name)
+
+        if block
+          attribute_types.fetch(attribute_name, &block)
+        else
+          attribute_types[attribute_name]
+        end
+      end
+
+      private
+        PendingType = Struct.new(:name, :type) do # :nodoc:
+          def apply_to(attribute_set)
+            attribute = attribute_set[name]
+            attribute_set[name] = attribute.with_type(type || attribute.type)
+          end
+        end
+
+        PendingDefault = Struct.new(:name, :default) do # :nodoc:
+          def apply_to(attribute_set)
+            attribute_set[name] = attribute_set[name].with_user_default(default)
+          end
+        end
+
+        PendingDecorator = Struct.new(:names, :decorator) do # :nodoc:
+          def apply_to(attribute_set)
+            (names || attribute_set.keys).each do |name|
+              attribute = attribute_set[name]
+              type = decorator.call(name, attribute.type)
+              attribute_set[name] = attribute.with_type(type) if type
+            end
+          end
+        end
+
+        def pending_attribute_modifications
+          @pending_attribute_modifications ||= []
+        end
+
+        def apply_pending_attribute_modifications(attribute_set)
+          if superclass.respond_to?(:apply_pending_attribute_modifications, true)
+            superclass.send(:apply_pending_attribute_modifications, attribute_set)
+          end
+
+          pending_attribute_modifications.each do |modification|
+            modification.apply_to(attribute_set)
+          end
+        end
+
+        def reset_default_attributes
+          reset_default_attributes!
+          subclasses.each { |subclass| subclass.send(:reset_default_attributes) }
+        end
+
+        def reset_default_attributes!
+          @default_attributes = nil
+          @attribute_types = nil
+        end
+
+        def resolve_attribute_name(name)
+          name.to_s
+        end
+
+        def resolve_type_name(name, **options)
+          Type.lookup(name, **options)
+        end
+
+        # Hook for other modules to override. The attribute type is passed
+        # through this method immediately after it is resolved, before any type
+        # decorations are applied.
+        def hook_attribute_type(attribute, type)
+          type
+        end
+    end
+  end
+end

data/lib/active_model/attribute_set/builder.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "active_model/attribute"
+
+module ActiveModel
+  class AttributeSet # :nodoc:
+    class Builder # :nodoc:
+      attr_reader :types, :default_attributes
+
+      def initialize(types, default_attributes = {})
+        @types = types
+        @default_attributes = default_attributes
+      end
+
+      def build_from_database(values = {}, additional_types = {})
+        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_value, :fetch, :except, to: :materialize
+
+    def initialize(types, values, additional_types, default_attributes, delegate_hash = {})
+      @types = types
+      @values = values
+      @additional_types = additional_types
+      @materialized = false
+      @delegate_hash = delegate_hash
+      @default_attributes = default_attributes
+    end
+
+    def key?(key)
+      delegate_hash.key?(key) || values.key?(key) || types.key?(key)
+    end
+
+    def [](key)
+      delegate_hash[key] || assign_default_value(key)
+    end
+
+    def []=(key, value)
+      delegate_hash[key] = value
+    end
+
+    def deep_dup
+      dup.tap do |copy|
+        copy.instance_variable_set(:@delegate_hash, delegate_hash.transform_values(&:dup))
+      end
+    end
+
+    def initialize_dup(_)
+      @delegate_hash = Hash[delegate_hash]
+      super
+    end
+
+    def each_key(&block)
+      keys = types.keys | values.keys | delegate_hash.keys
+      keys.each(&block)
+    end
+
+    def ==(other)
+      if other.is_a?(LazyAttributeHash)
+        materialize == other.materialize
+      else
+        materialize == other
+      end
+    end
+
+    def marshal_dump
+      [@types, @values, @additional_types, @default_attributes, @delegate_hash]
+    end
+
+    def marshal_load(values)
+      initialize(*values)
+    end
+
+    protected
+      def materialize
+        unless @materialized
+          values.each_key { |key| self[key] }
+          types.each_key { |key| self[key] }
+          unless frozen?
+            @materialized = true
+          end
+        end
+        delegate_hash
+      end
+
+    private
+      attr_reader :types, :values, :additional_types, :delegate_hash, :default_attributes
+
+      def assign_default_value(name)
+        type = additional_types.fetch(name, types[name])
+        value_present = true
+        value = values.fetch(name) { value_present = false }
+
+        if value_present
+          delegate_hash[name] = Attribute.from_database(name, value, type)
+        elsif types.key?(name)
+          attr = default_attributes[name]
+          if attr
+            delegate_hash[name] = attr.dup
+          else
+            delegate_hash[name] = Attribute.uninitialized(name, type)
+          end
+        end
+      end
+  end
+end

data/lib/active_model/attribute_set/yaml_encoder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  class AttributeSet
+    # Attempts to do more intelligent YAML dumping of an
+    # ActiveModel::AttributeSet to reduce the size of the resulting string
+    class YAMLEncoder # :nodoc:
+      def initialize(default_types)
+        @default_types = default_types
+      end
+
+      def encode(attribute_set, coder)
+        coder["concise_attributes"] = attribute_set.each_value.map do |attr|
+          if attr.type.equal?(default_types[attr.name])
+            attr.with_type(nil)
+          else
+            attr
+          end
+        end
+      end
+
+      def decode(coder)
+        if coder["attributes"]
+          coder["attributes"]
+        else
+          attributes_hash = Hash[coder["concise_attributes"].map do |attr|
+            if attr.type.nil?
+              attr = attr.with_type(default_types[attr.name])
+            end
+            [attr.name, attr]
+          end]
+          AttributeSet.new(attributes_hash)
+        end
+      end
+
+      private
+        attr_reader :default_types
+    end
+  end
+end

data/lib/active_model/attribute_set.rb

@@ -0,0 +1,118 @@
+# 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"
+
+module ActiveModel
+  class AttributeSet # :nodoc:
+    delegate :each_value, :fetch, :except, to: :attributes
+
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def [](name)
+      @attributes[name] || default_attribute(name)
+    end
+
+    def []=(name, value)
+      @attributes[name] = value
+    end
+
+    def cast_types
+      attributes.transform_values(&:type)
+    end
+
+    def values_before_type_cast
+      attributes.transform_values(&:value_before_type_cast)
+    end
+
+    def values_for_database
+      attributes.transform_values(&:value_for_database)
+    end
+
+    def to_hash
+      keys.index_with { |name| self[name].value }
+    end
+    alias :to_h :to_hash
+
+    def key?(name)
+      attributes.key?(name) && self[name].initialized?
+    end
+    alias :include? :key?
+
+    def keys
+      attributes.each_key.select { |name| self[name].initialized? }
+    end
+
+    def fetch_value(name, &block)
+      self[name].value(&block)
+    end
+
+    def write_from_database(name, value)
+      @attributes[name] = self[name].with_value_from_database(value)
+    end
+
+    def write_from_user(name, 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)
+    end
+
+    def freeze
+      attributes.freeze
+      super
+    end
+
+    def deep_dup
+      AttributeSet.new(attributes.deep_dup)
+    end
+
+    def initialize_dup(_)
+      @attributes = @attributes.dup
+      super
+    end
+
+    def initialize_clone(_)
+      @attributes = @attributes.clone
+      super
+    end
+
+    def reset(key)
+      if key?(key)
+        write_from_database(key, nil)
+      end
+    end
+
+    def accessed
+      attributes.each_key.select { |name| self[name].has_been_read? }
+    end
+
+    def map(&block)
+      new_attributes = attributes.transform_values(&block)
+      AttributeSet.new(new_attributes)
+    end
+
+    def reverse_merge!(target_attributes)
+      attributes.reverse_merge!(target_attributes.attributes) && self
+    end
+
+    def ==(other)
+      other.is_a?(AttributeSet) && attributes == other.send(:attributes)
+    end
+
+    protected
+      attr_reader :attributes
+
+    private
+      def default_attribute(name)
+        Attribute.null(name)
+      end
+  end
+end