activeentity 0.0.1.beta17 → 6.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66d3aead74bfd3d5a8162e8da72f63337a598842e7aaabf5d3ddc8bcf03ccba7
-  data.tar.gz: 4a5bde329a590399e6c890279b9d702463bec7da3cd9df0fae84eb188949b6a8
+  metadata.gz: e3b04bbfb0b0a237a4aeae8c4009182ec920bd76eec58aa377493c872fcf2e13
+  data.tar.gz: 48395a80ea845a7b5fd7892fc9176df4beebebe0b0c82fe801a3dbfd200e11c4
 SHA512:
-  metadata.gz: 5e268f4ff1d308b223e767a5836c9eb158ff4d8648dfdd960426434da4caff1a7ff278923a79d4f1f73f97e4bbeabfdac9e69dbf437f893c59dfac91ab80b868
-  data.tar.gz: '049773f1db811952efeec0f186c6c7306937783b38c719f466f2c3ffc93c353da1b9f8be16f445223b4582e08e731fefe2217689bccb2ea9c1a3bf597561bbc8'
+  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/before_type_cast.rb

@@ -46,7 +46,7 @@ module ActiveEntity
       #   task.read_attribute_before_type_cast('completed_on') # => "2012-10-21"
       #   task.read_attribute_before_type_cast(:completed_on)  # => "2012-10-21"
       def read_attribute_before_type_cast(attr_name)
-        @attributes[attr_name.to_s].value_before_type_cast
+        attribute_before_type_cast(attr_name.to_s)
       end
 
       # Returns a hash of attributes before typecasting and deserialization.
@@ -66,12 +66,12 @@ module ActiveEntity
       private
 
         # Dispatch target for <tt>*_before_type_cast</tt> attribute methods.
-        def attribute_before_type_cast(attribute_name)
-          read_attribute_before_type_cast(attribute_name)
+        def attribute_before_type_cast(attr_name)
+          @attributes[attr_name].value_before_type_cast
         end
 
-        def attribute_came_from_user?(attribute_name)
-          @attributes[attribute_name].came_from_user?
+        def attribute_came_from_user?(attr_name)
+          @attributes[attr_name].came_from_user?
         end
     end
   end

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/primary_key.rb

@@ -16,29 +16,27 @@ module ActiveEntity
 
       # Returns the primary key column's value.
       def id
-        primary_key = self.class.primary_key
-        _read_attribute(primary_key) if primary_key
+        _read_attribute(@primary_key)
       end
 
       # Sets the primary key column's value.
       def id=(value)
-        primary_key = self.class.primary_key
-        _write_attribute(primary_key, value) if primary_key
+        _write_attribute(@primary_key, value)
       end
 
       # Queries the primary key column's value.
       def id?
-        query_attribute(self.class.primary_key)
+        query_attribute(@primary_key)
       end
 
       # Returns the primary key column's value before type cast.
       def id_before_type_cast
-        read_attribute_before_type_cast(self.class.primary_key)
+        read_attribute_before_type_cast(@primary_key)
       end
 
       # Returns the primary key column's previous value.
       def id_was
-        attribute_was(self.class.primary_key)
+        attribute_was(@primary_key)
       end
 
       private
@@ -48,7 +46,7 @@ module ActiveEntity
         end
 
         module ClassMethods
-          ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast id_was id_in_database).to_set
+          ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast id_was).to_set
 
           def instance_method_already_implemented?(method_name)
             super || primary_key && ID_ATTRIBUTE_METHODS.include?(method_name)

data/lib/active_entity/attribute_methods/query.rb

@@ -31,12 +31,8 @@ module ActiveEntity
         end
       end
 
-      private
-
-        # Dispatch target for <tt>*?</tt> attribute methods.
-        def attribute?(attribute_name)
-          query_attribute(attribute_name)
-        end
+      alias :attribute? :query_attribute
+      private :attribute?
     end
   end
 end

data/lib/active_entity/attribute_methods/read.rb

@@ -8,17 +8,14 @@ module ActiveEntity
       module ClassMethods # :nodoc:
         private
 
-          def define_method_attribute(name)
-            ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
-              generated_attribute_methods, name
+          def define_method_attribute(name, owner:)
+            ActiveEntity::AMAttributeMethods::AttrNames.define_attribute_accessor_method(
+              owner, name
             ) do |temp_method_name, attr_name_expr|
-              generated_attribute_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-                # frozen_string_literal: true
-                def #{temp_method_name}
-                  name = #{attr_name_expr}
-                  _read_attribute(name) { |n| missing_attribute(n, caller) }
-                end
-              RUBY
+              owner <<
+                "def #{temp_method_name}" <<
+                "  _read_attribute(#{attr_name_expr}) { |n| missing_attribute(n, caller) }" <<
+                "end"
             end
           end
       end
@@ -30,13 +27,14 @@ module ActiveEntity
         name = attr_name.to_s
         name = self.class.attribute_aliases[name] || name
 
-        _read_attribute(name, &block)
+        name = @primary_key if name == "id" && @primary_key
+        @attributes.fetch_value(name, &block)
       end
 
       # This method exists to avoid the expensive primary_key check internally, without
       # breaking compatibility with the read_attribute API
       def _read_attribute(attr_name, &block) # :nodoc
-        @attributes.fetch_value(attr_name.to_s, &block)
+        @attributes.fetch_value(attr_name, &block)
       end
 
       alias :attribute :_read_attribute

data/lib/active_entity/attribute_methods/write.rb

@@ -12,17 +12,14 @@ module ActiveEntity
       module ClassMethods # :nodoc:
         private
 
-          def define_method_attribute=(name)
-            ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
-              generated_attribute_methods, name, writer: true,
+          def define_method_attribute=(name, owner:)
+            ActiveEntity::AMAttributeMethods::AttrNames.define_attribute_accessor_method(
+              owner, name, writer: true,
               ) do |temp_method_name, attr_name_expr|
-              generated_attribute_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-                # frozen_string_literal: true
-                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
       end
@@ -34,26 +31,23 @@ module ActiveEntity
         name = attr_name.to_s
         name = self.class.attribute_aliases[name] || name
 
-        _write_attribute(name, value)
+        name = @primary_key if name == "id" && @primary_key
+        @attributes.write_from_user(name, value)
       end
 
       # This method exists to avoid the expensive primary_key check internally, without
       # breaking compatibility with the write_attribute API
       def _write_attribute(attr_name, value) # :nodoc:
-        @attributes.write_from_user(attr_name.to_s, value)
-        value
+        @attributes.write_from_user(attr_name, value)
       end
 
+      alias :attribute= :_write_attribute
+      private :attribute=
+
       private
 
         def write_attribute_without_type_cast(attr_name, value)
-          @attributes.write_cast_value(attr_name.to_s, value)
-          value
-        end
-
-        # Dispatch target for <tt>*=</tt> attribute methods.
-        def attribute=(attribute_name, value)
-          _write_attribute(attribute_name, value)
+          @attributes.write_cast_value(attr_name, value)
         end
     end
   end