activeentity 6.1.1 → 6.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a48deda3be4192f640dfdf3feebc0152f65cd41eb7483e9c0d082a1565071227
-  data.tar.gz: 79b7877eee5cf2c3f9ae976533f15a0651b2cc0257174b2f7ea8a93034123212
+  metadata.gz: e3b04bbfb0b0a237a4aeae8c4009182ec920bd76eec58aa377493c872fcf2e13
+  data.tar.gz: 48395a80ea845a7b5fd7892fc9176df4beebebe0b0c82fe801a3dbfd200e11c4
 SHA512:
-  metadata.gz: 718bced85e2be2eb42ad37daca8ba3a9d1a1c63f3e91f6fedcea297c57abce9c596ab2bad681ecaad2d13b001edb7d695872021ebab5a57a954a9b63a409ebb5
-  data.tar.gz: 37eafc74002e3a8b5e4af2c017f070ba782c6b347dd40d92dcf25f867cf9be79b72fd4dba6e378766422741325e9e9df9c09dad43a35deb5e9ab1e496cdfb1f3
+  metadata.gz: da361c64ae3c545bf011bdf2c14f4ca975644547739a28a5c492146c08c61c39179b7a34eedf82b75b39af6d079d2ff7724eedd2743cf2830b0f152cf15cfb63
+  data.tar.gz: fd4a9c90772398ea9ba37d86c030a77908e2f17eaeb7afebf1a4d9e5713f1aa74f527a41c78d1dbf1dce070ee7daeeaa4705ed45b9cb79fee3a10f2a9e8c3d7c

data/README.md

@@ -93,11 +93,11 @@ class Reviewer < ActiveEntity::Base
 end
 
 class Book < ActiveEntity::Base
-  embeds_many :categories
+  embeds_many :categories, index_errors: true
   validates :categories, uniqueness_in_embeds: {key: :name}
 
   embeds_many :reviewers
-  validates :categories, uniqueness_in_embeds: {key: [:first_name, :last_name]}
+  validates :reviewers, uniqueness_in_embeds: {key: [:first_name, :last_name]}
 end
 ```
 
@@ -123,7 +123,6 @@ end
 These Active Record feature also available in Active Entity
 
 - [`composed_of`](https://api.rubyonrails.org/classes/ActiveRecord/Aggregations/ClassMethods.html)
-- [`enum`](https://api.rubyonrails.org/v5.2.2/classes/ActiveRecord/Enum.html) (You must declare the attribute before using `enum`)
 - [`serializable_hash`](https://api.rubyonrails.org/classes/ActiveModel/Serialization.html#method-i-serializable_hash)
 - [`serialize`](https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/Serialization/ClassMethods.html#method-i-serialize)
 - [`store`](https://api.rubyonrails.org/classes/ActiveRecord/Store.html)
@@ -132,6 +131,69 @@ These Active Record feature also available in Active Entity
 
 Same to [Active Record I18n](https://guides.rubyonrails.org/i18n.html#translations-for-active-record-models), the only different is the root of locale YAML is `active_entity` instead of `activerecord`
 
+#### Enum
+
+You can use the `enum` class method to define a set of possible values for an attribute. It is similar to the `enum` functionality in Active Model, but has significant enough quirks that you should think of them as distinct.
+
+```rb
+class Example < ActiveEntity::Base
+  attribute :steve, :integer
+  enum steve: [:martin, :carell, :buscemi]
+end
+
+example = Example.new
+example.attributes # => {"steve"=>nil}
+example.steve = :carell
+example.carell? # => true
+example.attributes # => {"steve"=>"carell"}
+example.steve = 2
+example.attributes # => {"steve"=>"buscemi"}
+
+# IMPORTANT: the next line will only work if you implement an update! method
+example.martin! # => {"steve"=>"martin"}
+
+example.steve = :bannon # ArgumentError ('bannon' is not a valid steve)
+```
+
+The first thing you'll notice about the `:steve` attribute is that it is an "Integer", even though it might seem logical to define it as a String... TL;DR: don't do this. Internally enum tracks the possible values based on their index position in the array.
+
+It's also possible to provide a Hash of possible values:
+
+```rb
+class Example < ActiveEntity::Base
+  attribute :steve, :integer, default: 9
+  enum steve: {martin: 5, carell: 12, buscemi: 9}
+end
+
+example = Example.new
+example.attributes # => {"steve"=>"buscemi"}
+```
+
+The other quirk of this implementation is that you must create your attribute before you call enum.
+enum does not create the search scopes that might be familar to Active Model users, since there is no search or where concept in Active Entity. You can, however, access the mapping directly to obtain the index number for a given value:
+
+```rb
+Example.steves[:buscemi] # => 9
+```
+
+You can define prefixes and suffixes for your `enum` attributes. Note the underscores:
+
+```rb
+class Conversation < ActiveEntity::Base
+  attribute :status, :integer
+  attribute :comments_status, :integer
+  enum status: [ :active, :archived ], _suffix: true
+  enum comments_status: [ :active, :inactive ], _prefix: :comments
+end
+
+conversation = Conversation.new
+conversation.active_status! # only if you have an update! method
+conversation.archived_status? # => false
+
+conversation.comments_inactive! # only if you have an update! method
+conversation.comments_active? # => false
+```
+
 #### Read-only attributes
 
 You can use `attr_readonly :title, :author` to prevent assign value to attribute after initialized.

data/lib/active_entity/attribute_methods/dirty.rb

@@ -6,8 +6,175 @@ module ActiveEntity
   module AttributeMethods
     module Dirty
       extend ActiveSupport::Concern
+      include ActiveEntity::AMAttributeMethods
 
-      include ActiveModel::Dirty
+      included do
+        attribute_method_suffix "_changed?", "_change", "_will_change!", "_was"
+        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:
+        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 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)
+          mutations_from_database.finalize_changes
+        end
+        @mutations_before_last_save = mutations_from_database
+        forget_attribute_assignments
+        @mutations_from_database = nil
+      end
+
+      # Returns +true+ if any of the attributes has unsaved changes, +false+ otherwise.
+      #
+      #   person.changed? # => false
+      #   person.name = 'bob'
+      #   person.changed? # => true
+      def changed?
+        mutations_from_database.any_changes?
+      end
+
+      # Returns an array with the name of the attributes with unsaved changes.
+      #
+      #   person.changed # => []
+      #   person.name = 'bob'
+      #   person.changed # => ["name"]
+      def changed
+        mutations_from_database.changed_attribute_names
+      end
+
+      # Dispatch target for <tt>*_changed?</tt> attribute methods.
+      def attribute_changed?(attr_name, **options) # :nodoc:
+        mutations_from_database.changed?(attr_name.to_s, **options)
+      end
+
+      # Dispatch target for <tt>*_was</tt> attribute methods.
+      def attribute_was(attr_name) # :nodoc:
+        mutations_from_database.original_value(attr_name.to_s)
+      end
+
+      # Dispatch target for <tt>*_previously_changed?</tt> attribute methods.
+      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.
+      def restore_attributes(attr_names = changed)
+        attr_names.each { |attr_name| restore_attribute!(attr_name) }
+      end
+
+      # Clears all dirty data: current changes and previous changes.
+      def clear_changes_information
+        @mutations_before_last_save = nil
+        forget_attribute_assignments
+        @mutations_from_database = nil
+      end
+
+      def clear_attribute_changes(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
+        mutations_from_database.changed_values
+      end
+
+      # Returns a hash of changed attributes indicating their original
+      # and new values like <tt>attr => [original value, new value]</tt>.
+      #
+      #   person.changes # => {}
+      #   person.name = 'bob'
+      #   person.changes # => { "name" => ["bill", "bob"] }
+      def changes
+        mutations_from_database.changes
+      end
+
+      # Returns a hash of attributes that were changed before the model was saved.
+      #
+      #   person.name # => "bob"
+      #   person.name = 'robert'
+      #   person.save
+      #   person.previous_changes # => {"name" => ["bob", "robert"]}
+      def previous_changes
+        mutations_before_last_save.changes
+      end
+
+      def attribute_changed_in_place?(attr_name) # :nodoc:
+        mutations_from_database.changed_in_place?(attr_name.to_s)
+      end
+
+      private
+        def clear_attribute_change(attr_name)
+          mutations_from_database.forget_change(attr_name.to_s)
+        end
+
+        def mutations_from_database
+          @mutations_from_database ||= if defined?(@attributes)
+                                         ActiveModel::AttributeMutationTracker.new(@attributes)
+                                       else
+                                         ActiveModel::ForcedMutationTracker.new(self)
+                                       end
+        end
+
+        def forget_attribute_assignments
+          @attributes = @attributes.map(&:forgetting_assignment) if defined?(@attributes)
+        end
+
+        def mutations_before_last_save
+          @mutations_before_last_save ||= ActiveModel::NullMutationTracker.instance
+        end
+
+        # Dispatch target for <tt>*_change</tt> attribute methods.
+        def attribute_change(attr_name)
+          mutations_from_database.change_to_attribute(attr_name.to_s)
+        end
+
+        # Dispatch target for <tt>*_previous_change</tt> attribute methods.
+        def attribute_previous_change(attr_name)
+          mutations_before_last_save.change_to_attribute(attr_name.to_s)
+        end
+
+        # Dispatch target for <tt>*_will_change!</tt> attribute methods.
+        def attribute_will_change!(attr_name)
+          mutations_from_database.force_change(attr_name.to_s)
+        end
+
+        # Dispatch target for <tt>restore_*!</tt> attribute methods.
+        def restore_attribute!(attr_name)
+          attr_name = attr_name.to_s
+          if attribute_changed?(attr_name)
+            __send__("#{attr_name}=", attribute_was(attr_name))
+            clear_attribute_change(attr_name)
+          end
+        end
     end
   end
 end

data/lib/active_entity/attribute_methods/read.rb

@@ -9,7 +9,7 @@ module ActiveEntity
         private
 
           def define_method_attribute(name, owner:)
-            ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
+            ActiveEntity::AMAttributeMethods::AttrNames.define_attribute_accessor_method(
               owner, name
             ) do |temp_method_name, attr_name_expr|
               owner <<

data/lib/active_entity/attribute_methods/write.rb

@@ -13,7 +13,7 @@ module ActiveEntity
         private
 
           def define_method_attribute=(name, owner:)
-            ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
+            ActiveEntity::AMAttributeMethods::AttrNames.define_attribute_accessor_method(
               owner, name, writer: true,
               ) do |temp_method_name, attr_name_expr|
               owner <<

data/lib/active_entity/attribute_methods.rb

@@ -1,13 +1,505 @@
 # frozen_string_literal: true
 
+require "concurrent/map"
 require "mutex_m"
 require "active_support/core_ext/enumerable"
 
 module ActiveEntity
+  module AMAttributeMethods
+    extend ActiveSupport::Concern
+
+    NAME_COMPILABLE_REGEXP = /\A[a-zA-Z_]\w*[!?=]?\z/
+    CALL_COMPILABLE_REGEXP = /\A[a-zA-Z_]\w*[!?]?\z/
+
+    included do
+      class_attribute :attribute_aliases, instance_writer: false, default: {}
+      class_attribute :attribute_method_matchers, instance_writer: false, default: [ ClassMethods::AttributeMethodMatcher.new ]
+    end
+
+    module ClassMethods
+      # Declares a method available for all attributes with the given prefix.
+      # Uses +method_missing+ and <tt>respond_to?</tt> to rewrite the method.
+      #
+      #   #{prefix}#{attr}(*args, &block)
+      #
+      # to
+      #
+      #   #{prefix}attribute(#{attr}, *args, &block)
+      #
+      # An instance method <tt>#{prefix}attribute</tt> must exist and accept
+      # at least the +attr+ argument.
+      #
+      #   class Person
+      #     include ActiveModel::AttributeMethods
+      #
+      #     attr_accessor :name
+      #     attribute_method_prefix 'clear_'
+      #     define_attribute_methods :name
+      #
+      #     private
+      #
+      #     def clear_attribute(attr)
+      #       send("#{attr}=", nil)
+      #     end
+      #   end
+      #
+      #   person = Person.new
+      #   person.name = 'Bob'
+      #   person.name          # => "Bob"
+      #   person.clear_name
+      #   person.name          # => nil
+      def attribute_method_prefix(*prefixes)
+        self.attribute_method_matchers += prefixes.map! { |prefix| AttributeMethodMatcher.new prefix: prefix }
+        undefine_attribute_methods
+      end
+
+      # Declares a method available for all attributes with the given suffix.
+      # Uses +method_missing+ and <tt>respond_to?</tt> to rewrite the method.
+      #
+      #   #{attr}#{suffix}(*args, &block)
+      #
+      # to
+      #
+      #   attribute#{suffix}(#{attr}, *args, &block)
+      #
+      # An <tt>attribute#{suffix}</tt> instance method must exist and accept at
+      # least the +attr+ argument.
+      #
+      #   class Person
+      #     include ActiveModel::AttributeMethods
+      #
+      #     attr_accessor :name
+      #     attribute_method_suffix '_short?'
+      #     define_attribute_methods :name
+      #
+      #     private
+      #
+      #     def attribute_short?(attr)
+      #       send(attr).length < 5
+      #     end
+      #   end
+      #
+      #   person = Person.new
+      #   person.name = 'Bob'
+      #   person.name          # => "Bob"
+      #   person.name_short?   # => true
+      def attribute_method_suffix(*suffixes)
+        self.attribute_method_matchers += suffixes.map! { |suffix| AttributeMethodMatcher.new suffix: suffix }
+        undefine_attribute_methods
+      end
+
+      # Declares a method available for all attributes with the given prefix
+      # and suffix. Uses +method_missing+ and <tt>respond_to?</tt> to rewrite
+      # the method.
+      #
+      #   #{prefix}#{attr}#{suffix}(*args, &block)
+      #
+      # to
+      #
+      #   #{prefix}attribute#{suffix}(#{attr}, *args, &block)
+      #
+      # An <tt>#{prefix}attribute#{suffix}</tt> instance method must exist and
+      # accept at least the +attr+ argument.
+      #
+      #   class Person
+      #     include ActiveModel::AttributeMethods
+      #
+      #     attr_accessor :name
+      #     attribute_method_affix prefix: 'reset_', suffix: '_to_default!'
+      #     define_attribute_methods :name
+      #
+      #     private
+      #
+      #     def reset_attribute_to_default!(attr)
+      #       send("#{attr}=", 'Default Name')
+      #     end
+      #   end
+      #
+      #   person = Person.new
+      #   person.name                         # => 'Gem'
+      #   person.reset_name_to_default!
+      #   person.name                         # => 'Default Name'
+      def attribute_method_affix(*affixes)
+        self.attribute_method_matchers += affixes.map! { |affix| AttributeMethodMatcher.new prefix: affix[:prefix], suffix: affix[:suffix] }
+        undefine_attribute_methods
+      end
+
+      # Allows you to make aliases for attributes.
+      #
+      #   class Person
+      #     include ActiveModel::AttributeMethods
+      #
+      #     attr_accessor :name
+      #     attribute_method_suffix '_short?'
+      #     define_attribute_methods :name
+      #
+      #     alias_attribute :nickname, :name
+      #
+      #     private
+      #
+      #     def attribute_short?(attr)
+      #       send(attr).length < 5
+      #     end
+      #   end
+      #
+      #   person = Person.new
+      #   person.name = 'Bob'
+      #   person.name            # => "Bob"
+      #   person.nickname        # => "Bob"
+      #   person.name_short?     # => true
+      #   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)
+        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
+
+      # Is +new_name+ an alias?
+      def attribute_alias?(new_name)
+        attribute_aliases.key? new_name.to_s
+      end
+
+      # Returns the original name for the alias +name+
+      def attribute_alias(name)
+        attribute_aliases[name.to_s]
+      end
+
+      # Declares the attributes that should be prefixed and suffixed by
+      # <tt>ActiveModel::AttributeMethods</tt>.
+      #
+      # To use, pass attribute names (as strings or symbols). Be sure to declare
+      # +define_attribute_methods+ after you define any prefix, suffix or affix
+      # methods, or they will not hook in.
+      #
+      #   class Person
+      #     include ActiveModel::AttributeMethods
+      #
+      #     attr_accessor :name, :age, :address
+      #     attribute_method_prefix 'clear_'
+      #
+      #     # Call to define_attribute_methods must appear after the
+      #     # attribute_method_prefix, attribute_method_suffix or
+      #     # attribute_method_affix declarations.
+      #     define_attribute_methods :name, :age, :address
+      #
+      #     private
+      #
+      #     def clear_attribute(attr)
+      #       send("#{attr}=", nil)
+      #     end
+      #   end
+      def define_attribute_methods(*attr_names)
+        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
+      # <tt>ActiveModel::AttributeMethods</tt>.
+      #
+      # To use, pass an attribute name (as string or symbol). Be sure to declare
+      # +define_attribute_method+ after you define any prefix, suffix or affix
+      # method, or they will not hook in.
+      #
+      #   class Person
+      #     include ActiveModel::AttributeMethods
+      #
+      #     attr_accessor :name
+      #     attribute_method_suffix '_short?'
+      #
+      #     # Call to define_attribute_method must appear after the
+      #     # attribute_method_prefix, attribute_method_suffix or
+      #     # attribute_method_affix declarations.
+      #     define_attribute_method :name
+      #
+      #     private
+      #
+      #     def attribute_short?(attr)
+      #       send(attr).length < 5
+      #     end
+      #   end
+      #
+      #   person = Person.new
+      #   person.name = 'Bob'
+      #   person.name        # => "Bob"
+      #   person.name_short? # => true
+      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
+      end
+
+      # Removes all the previously dynamically defined methods from the class.
+      #
+      #   class Person
+      #     include ActiveModel::AttributeMethods
+      #
+      #     attr_accessor :name
+      #     attribute_method_suffix '_short?'
+      #     define_attribute_method :name
+      #
+      #     private
+      #
+      #     def attribute_short?(attr)
+      #       send(attr).length < 5
+      #     end
+      #   end
+      #
+      #   person = Person.new
+      #   person.name = 'Bob'
+      #   person.name_short? # => true
+      #
+      #   Person.undefine_attribute_methods
+      #
+      #   person.name_short? # => NoMethodError
+      def undefine_attribute_methods
+        generated_attribute_methods.module_eval do
+          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
+
+        def instance_method_already_implemented?(method_name)
+          generated_attribute_methods.method_defined?(method_name)
+        end
+
+        # The methods +method_missing+ and +respond_to?+ of this module are
+        # invoked often in a typical rails, both of which invoke the method
+        # +matched_attribute_method+. The latter method iterates through an
+        # array doing regular expression matches, which results in a lot of
+        # object creations. Most of the time it returns a +nil+ match. As the
+        # match result is always the same given a +method_name+, this cache is
+        # used to alleviate the GC, which ultimately also speeds up the app
+        # significantly (in our case our test suite finishes 10% faster with
+        # this cache).
+        def attribute_method_matchers_cache
+          @attribute_method_matchers_cache ||= Concurrent::Map.new(initial_capacity: 4)
+        end
+
+        def attribute_method_matchers_matching(method_name)
+          attribute_method_matchers_cache.compute_if_absent(method_name) do
+            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, code_generator, name, target, *extra)
+          defn = if NAME_COMPILABLE_REGEXP.match?(name)
+                   "def #{name}(*args)"
+                 else
+                   "define_method(:'#{name}') do |*args|"
+                 end
+
+          extra = (extra.map!(&:inspect) << "*args").join(", ")
+
+          body = if CALL_COMPILABLE_REGEXP.match?(target)
+                   "#{"self." unless include_private}#{target}(#{extra})"
+                 else
+                   "send(:'#{target}', #{extra})"
+                 end
+
+          code_generator <<
+            defn <<
+            body <<
+            "end" <<
+            "ruby2_keywords(:'#{name}') if respond_to?(:ruby2_keywords, true)"
+        end
+
+        class AttributeMethodMatcher #:nodoc:
+          attr_reader :prefix, :suffix, :target
+
+          AttributeMethodMatch = Struct.new(:target, :attr_name)
+
+          def initialize(options = {})
+            @prefix, @suffix = options.fetch(:prefix, ""), options.fetch(:suffix, "")
+            @regex = /^(?:#{Regexp.escape(@prefix)})(.*)(?:#{Regexp.escape(@suffix)})$/
+            @target = "#{@prefix}attribute#{@suffix}"
+            @method_name = "#{prefix}%s#{suffix}"
+          end
+
+          def match(method_name)
+            if @regex =~ method_name
+              AttributeMethodMatch.new(target, $1)
+            end
+          end
+
+          def method_name(attr_name)
+            @method_name % attr_name
+          end
+        end
+    end
+
+    # Allows access to the object attributes, which are held in the hash
+    # returned by <tt>attributes</tt>, as though they were first-class
+    # methods. So a +Person+ class with a +name+ attribute can for example use
+    # <tt>Person#name</tt> and <tt>Person#name=</tt> and never directly use
+    # the attributes hash -- except for multiple assignments with
+    # <tt>ActiveRecord::Base#attributes=</tt>.
+    #
+    # It's also possible to instantiate related objects, so a <tt>Client</tt>
+    # class belonging to the +clients+ table with a +master_id+ foreign key
+    # can instantiate master through <tt>Client#master</tt>.
+    def method_missing(method, *args, &block)
+      if respond_to_without_attributes?(method, true)
+        super
+      else
+        match = matched_attribute_method(method.to_s)
+        match ? attribute_missing(match, *args, &block) : super
+      end
+    end
+    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+
+    # +attribute_missing+ is like +method_missing+, but for attributes. When
+    # +method_missing+ is called we check to see if there is a matching
+    # attribute method. If so, we tell +attribute_missing+ to dispatch the
+    # attribute. This method can be overloaded to customize the behavior.
+    def attribute_missing(match, *args, &block)
+      __send__(match.target, match.attr_name, *args, &block)
+    end
+
+    # A +Person+ instance with a +name+ attribute can ask
+    # <tt>person.respond_to?(:name)</tt>, <tt>person.respond_to?(:name=)</tt>,
+    # and <tt>person.respond_to?(:name?)</tt> which will all return +true+.
+    alias :respond_to_without_attributes? :respond_to?
+    def respond_to?(method, include_private_methods = false)
+      if super
+        true
+      elsif !include_private_methods && super(method, true)
+        # If we're here then we haven't found among non-private methods
+        # but found among all methods. Which means that the given method is private.
+        false
+      else
+        !matched_attribute_method(method.to_s).nil?
+      end
+    end
+
+    private
+      def attribute_method?(attr_name)
+        respond_to_without_attributes?(:attributes) && attributes.include?(attr_name)
+      end
+
+      # Returns a struct representing the matching attribute method.
+      # The struct's attributes are prefix, base and suffix.
+      def matched_attribute_method(method_name)
+        matches = self.class.send(:attribute_method_matchers_matching, method_name)
+        matches.detect { |match| attribute_method?(match.attr_name) }
+      end
+
+      def missing_attribute(attr_name, stack)
+        raise ActiveModel::MissingAttributeError, "missing attribute: #{attr_name}", stack
+      end
+
+      def _read_attribute(attr)
+        __send__(attr)
+      end
+
+      module AttrNames # :nodoc:
+        DEF_SAFE_NAME = /\A[a-zA-Z_]\w*\z/
+
+        # We want to generate the methods via module_eval rather than
+        # define_method, because define_method is slower on dispatch.
+        # Evaluating many similar methods may use more memory as the instruction
+        # sequences are duplicated and cached (in MRI).  define_method may
+        # be slower on dispatch, but if you're careful about the closure
+        # created, then define_method will consume much less memory.
+        #
+        # But sometimes the database might return columns with
+        # characters that are not allowed in normal method names (like
+        # 'my_column(omg)'. So to work around this we first define with
+        # the __temp__ identifier, and then use alias method to rename
+        # it to what we want.
+        #
+        # We are also defining a constant to hold the frozen string of
+        # the attribute name. Using a constant means that we do not have
+        # 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(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}'"
+          else
+            safe_name = attr_name.unpack1("h*")
+            const_name = "ATTR_#{safe_name}"
+            const_set(const_name, attr_name) unless const_defined?(const_name)
+            temp_method_name = "__temp__#{safe_name}#{'=' if writer}"
+            attr_name_expr = "::ActiveEntity::AMAttributeMethods::AttrNames::#{const_name}"
+            yield temp_method_name, attr_name_expr
+            owner.rename_method(temp_method_name, method_name)
+          end
+        end
+      end
+  end
+
   # = Active Entity Attribute Methods
   module AttributeMethods
     extend ActiveSupport::Concern
-    include ActiveModel::AttributeMethods
+    include AMAttributeMethods # Some AM modules will include AM::AttributeMethods, we want override it
 
     included do
       initialize_generated_modules
@@ -172,6 +664,18 @@ module ActiveEntity
       def _has_attribute?(attr_name) # :nodoc:
         attribute_types.key?(attr_name)
       end
+
+      # https://github.com/rails/rails/blob/df475877efdcf74d7524f734ab8ad1d4704fd187/activemodel/lib/active_model/attribute_methods.rb#L208-L217
+      def alias_attribute(new_name, old_name)
+        self.attribute_aliases = attribute_aliases.merge(new_name.to_s => old_name.to_s)
+        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
     end
 
     # Returns +true+ if the given attribute is in the attributes hash, otherwise +false+.

data/lib/active_entity/attributes.rb

@@ -201,6 +201,7 @@ module ActiveEntity
       )
         attribute_types[name] = cast_type
         define_default_attribute(name, default, cast_type)
+        define_attribute_method(name)
       end
 
       def load_schema! # :nodoc:

data/lib/active_entity/gem_version.rb

@@ -8,8 +8,8 @@ module ActiveEntity
 
   module VERSION
     MAJOR = 6
-    MINOR = 1
-    TINY  = 1
+    MINOR = 3
+    TINY  = 0
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

data/lib/active_entity/inheritance.rb

@@ -151,7 +151,7 @@ module ActiveEntity
             ActiveSupport::Dependencies.constantize(type_name)
           else
             type_candidate = @_type_candidates_cache[type_name]
-            if type_candidate && type_constant = ActiveSupport::Dependencies.safe_constantize(type_candidate)
+            if type_candidate && type_constant = type_candidate.safe_constantize
               return type_constant
             end
 
@@ -161,7 +161,7 @@ module ActiveEntity
             candidates << type_name
 
             candidates.each do |candidate|
-              constant = ActiveSupport::Dependencies.safe_constantize(candidate)
+              constant = candidate.safe_constantize
               if candidate == constant.to_s
                 @_type_candidates_cache[type_name] = candidate
                 return constant

data/lib/active_entity/model_schema.rb

@@ -86,16 +86,31 @@ module ActiveEntity
           @load_schema_invoked = true
         end
 
-        def reload_schema_from_cache
-          @attribute_types = nil
-          @default_attributes = nil
-          @attributes_builder = nil
-          @schema_loaded = false
-          @load_schema_invoked = false
-          @attribute_names = nil
-          @yaml_encoder = nil
-          direct_descendants.each do |descendant|
-            descendant.send(:reload_schema_from_cache)
+        if ActiveSupport::VERSION::MAJOR >= 7
+          def reload_schema_from_cache
+            @attribute_types = nil
+            @default_attributes = nil
+            @attributes_builder = nil
+            @schema_loaded = false
+            @load_schema_invoked = false
+            @attribute_names = nil
+            @yaml_encoder = nil
+            subclasses.each do |descendant|
+              descendant.send(:reload_schema_from_cache)
+            end
+          end
+        else
+          def reload_schema_from_cache
+            @attribute_types = nil
+            @default_attributes = nil
+            @attributes_builder = nil
+            @schema_loaded = false
+            @load_schema_invoked = false
+            @attribute_names = nil
+            @yaml_encoder = nil
+            direct_descendants.each do |descendant|
+              descendant.send(:reload_schema_from_cache)
+            end
           end
         end
     end

data/lib/active_entity/type/registry.rb

@@ -1,20 +1,42 @@
 # frozen_string_literal: true
 
-require "active_model/type/registry"
-
 module ActiveEntity
   # :stopdoc:
   module Type
-    class Registry < ActiveModel::Type::Registry
-      def add_modifier(options, klass, **args)
-        registrations << DecorationRegistration.new(options, klass, **args)
+    class Registry # :nodoc:
+      def initialize
+        @registrations = []
       end
 
-      private
+      def initialize_copy(_other)
+        @registrations = @registrations.dup
+      end
+
+      def add_modifier(options, klass, **_args)
+        registrations << DecorationRegistration.new(options, klass)
+      end
 
-        def registration_klass
-          Registration
+      def register(type_name, klass = nil, **options, &block)
+        unless block_given?
+          block = proc { |_, *args| klass.new(*args) }
+          block.ruby2_keywords if block.respond_to?(:ruby2_keywords)
         end
+        registrations << Registration.new(type_name, block, **options)
+      end
+
+      def lookup(symbol, *args, **kwargs)
+        registration = find_registration(symbol, *args, **kwargs)
+
+        if registration
+          registration.call(self, symbol, *args, **kwargs)
+        else
+          raise ArgumentError, "Unknown type #{symbol.inspect}"
+        end
+      end
+
+      private
+
+        attr_reader :registrations
 
         def find_registration(symbol, *args, **kwargs)
           registrations
@@ -23,7 +45,7 @@ module ActiveEntity
         end
     end
 
-    class Registration
+    class Registration # :nodoc:
       def initialize(name, block, override: nil)
         @name = name
         @block = block
@@ -55,7 +77,7 @@ module ActiveEntity
         end
     end
 
-    class DecorationRegistration < Registration
+    class DecorationRegistration < Registration # :nodoc:
       def initialize(options, klass, **)
         @options = options
         @klass = klass
@@ -86,7 +108,5 @@ module ActiveEntity
     end
   end
 
-  class TypeConflictError < StandardError
-  end
   # :startdoc:
 end

data/lib/active_entity/validate_embeds_association.rb

@@ -268,21 +268,16 @@ module ActiveEntity
         unless valid = record.valid?(context)
           indexed_attribute = !index.nil? && (reflection.options[:index_errors] || ActiveEntity::Base.index_nested_attribute_errors)
 
-          record.errors.each do |attribute, message|
+          record.errors.group_by_attribute.each { |attribute, errors|
             attribute = normalize_reflection_attribute(indexed_attribute, reflection, index, attribute)
-            errors[attribute] << message
-            errors[attribute].uniq!
-          end
-
-          record.errors.details.each_key do |attribute|
-            reflection_attribute =
-              normalize_reflection_attribute(indexed_attribute, reflection, index, attribute).to_sym
 
-            record.errors.details[attribute].each do |error|
-              errors.details[reflection_attribute] << error
-              errors.details[reflection_attribute].uniq!
-            end
-          end
+            errors.each { |error|
+              self.errors.import(
+                error,
+                attribute: attribute
+              )
+            }
+          }
         end
 
         valid

data/lib/active_entity/validations/subset.rb

@@ -18,7 +18,7 @@ module ActiveEntity
         end
 
         unless subset?(record, value)
-          record.errors.add(attribute, :non_subset, options.except(:in, :within).merge!(value: value))
+          record.errors.add(attribute, :non_subset, **options.except(:in, :within).merge(value: value))
         end
       end
 

data/lib/active_entity/validations/uniqueness_in_embeds.rb

@@ -48,26 +48,18 @@ module ActiveEntity
 
         duplicate_records.each do |r|
           if key.is_a? Symbol
-            r.errors.add(key, :duplicated, options)
+            r.errors.add(key, :duplicated, **options)
 
             # Hack the record
             normalized_attribute = normalize_attribute(attribute, indexed_attribute, association_or_value.index(r), key)
-            record.errors[normalized_attribute].concat r.errors.messages[key]
-            record.errors[normalized_attribute].uniq!
-
-            record.errors.details[normalized_attribute.to_sym].concat r.errors.details[key]
-            record.errors.details[normalized_attribute.to_sym].uniq!
+            record.errors.import r.errors.where(key).first, attribute: normalized_attribute
           elsif key.is_a? Array
             key.each do |attr|
-              r.errors.add(attr, :duplicated, options)
+              r.errors.add(attr, :duplicated, **options)
 
               # Hack the record
               normalized_attribute = normalize_attribute(attribute, indexed_attribute, association_or_value.index(r), attr)
-              record.errors[normalized_attribute].concat r.errors.messages[attr]
-              record.errors[normalized_attribute].uniq!
-
-              record.errors.details[normalized_attribute.to_sym].concat r.errors.details[attr]
-              record.errors.details[normalized_attribute.to_sym].uniq!
+              record.errors.import r.errors.where(key).first, attribute: normalized_attribute
             end
           end
         end

metadata

@@ -1,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: activeentity
 version: !ruby/object:Gem::Version
-  version: 6.1.1
+  version: 6.3.0
 platform: ruby
 authors:
 - jasl
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-12 00:00:00.000000000 Z
+date: 2022-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '6.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '6.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '8'
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '6.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '6.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '8'
 description: Rails virtual model solution based on ActiveModel design for Rails 6+.
 email:
 - jasl9187@hotmail.com
@@ -150,7 +150,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.3.4
 signing_key:
 specification_version: 4
 summary: Rails virtual model solution based on ActiveModel.