activeentity 0.0.1.beta14 → 6.1.0

data/lib/active_entity/serialization.rb

@@ -10,14 +10,17 @@ module ActiveEntity #:nodoc:
       self.include_root_in_json = false
     end
 
-    def serializable_hash(include_embedded: true, **options)
-      if include_embedded
-        include = Array.wrap(options[:include]).concat(self.class.embedded_association_names)
-        options[:include] = include
+    def serializable_hash(options = nil)
+      options = options ? options.dup : {}
+
+      include_embeds = options.delete :include_embeds
+      if include_embeds
+        includes = Array.wrap(options[:include]).concat(self.class.embeds_association_names)
+        options[:include] ||= []
+        options[:include].concat includes
       end
 
-      # options[:except] = Array(options[:except]).map(&:to_s)
-      # options[:except] |= Array(self.class.inheritance_attribute)
+      options[:except] = Array(options[:except]).map(&:to_s)
 
       super(options)
     end

data/lib/active_entity/store.rb

@@ -11,13 +11,19 @@ module ActiveEntity
   # of the model. This is very helpful for easily exposing store keys to a form or elsewhere that's
   # already built around just accessing attributes on the model.
   #
+  # Every accessor comes with dirty tracking methods (+key_changed?+, +key_was+ and +key_change+) and
+  # methods to access the changes made during the last save (+saved_change_to_key?+, +saved_change_to_key+ and
+  # +key_before_last_save+).
+  #
+  # NOTE: There is no +key_will_change!+ method for accessors, use +store_will_change!+ instead.
+  #
   # Make sure that you declare the database column used for the serialized store as a text, so there's
   # plenty of room.
   #
   # You can set custom coder to encode/decode your serialized attributes to/from different formats.
   # JSON, YAML, Marshal are supported out of the box. Generally it can be any wrapper that provides +load+ and +dump+.
   #
-  # NOTE: If you are using structured database data types (eg. PostgreSQL +hstore+/+json+, or MySQL 5.7+
+  # NOTE: If you are using structured database data types (e.g. PostgreSQL +hstore+/+json+, or MySQL 5.7+
   # +json+) there is no need for the serialization provided by {.store}[rdoc-ref:rdoc-ref:ClassMethods#store].
   # Simply use {.store_accessor}[rdoc-ref:ClassMethods#store_accessor] instead to generate
   # the accessor methods. Be aware that these columns use a string keyed hash and do not allow access
@@ -49,6 +55,12 @@ module ActiveEntity
   #   u.settings[:country]  # => 'Denmark'
   #   u.settings['country'] # => 'Denmark'
   #
+  #   # Dirty tracking
+  #   u.color = 'green'
+  #   u.color_changed? # => true
+  #   u.color_was # => 'black'
+  #   u.color_change # => ['black', 'red']
+  #
   #   # Add additional accessors to an existing store through store_accessor
   #   class SuperUser < User
   #     store_accessor :settings, :privileges, :servants
@@ -91,7 +103,7 @@ module ActiveEntity
     module ClassMethods
       def store(store_attribute, options = {})
         serialize store_attribute, IndifferentCoder.new(store_attribute, options[:coder])
-        store_accessor(store_attribute, options[:accessors], options.slice(:prefix, :suffix)) if options.has_key? :accessors
+        store_accessor(store_attribute, options[:accessors], **options.slice(:prefix, :suffix)) if options.has_key? :accessors
       end
 
       def store_accessor(store_attribute, *keys, prefix: nil, suffix: nil)
@@ -127,6 +139,42 @@ module ActiveEntity
             define_method(accessor_key) do
               read_store_attribute(store_attribute, key)
             end
+
+            define_method("#{accessor_key}_changed?") do
+              return false unless attribute_changed?(store_attribute)
+              prev_store, new_store = changes[store_attribute]
+              prev_store&.dig(key) != new_store&.dig(key)
+            end
+
+            define_method("#{accessor_key}_change") do
+              return unless attribute_changed?(store_attribute)
+              prev_store, new_store = changes[store_attribute]
+              [prev_store&.dig(key), new_store&.dig(key)]
+            end
+
+            define_method("#{accessor_key}_was") do
+              return unless attribute_changed?(store_attribute)
+              prev_store, _new_store = changes[store_attribute]
+              prev_store&.dig(key)
+            end
+
+            define_method("saved_change_to_#{accessor_key}?") do
+              return false unless saved_change_to_attribute?(store_attribute)
+              prev_store, new_store = saved_change_to_attribute(store_attribute)
+              prev_store&.dig(key) != new_store&.dig(key)
+            end
+
+            define_method("saved_change_to_#{accessor_key}") do
+              return unless saved_change_to_attribute?(store_attribute)
+              prev_store, new_store = saved_change_to_attribute(store_attribute)
+              [prev_store&.dig(key), new_store&.dig(key)]
+            end
+
+            define_method("#{accessor_key}_before_last_save") do
+              return unless saved_change_to_attribute?(store_attribute)
+              prev_store, _new_store = saved_change_to_attribute(store_attribute)
+              prev_store&.dig(key)
+            end
           end
         end
 
@@ -155,6 +203,7 @@ module ActiveEntity
     end
 
     private
+
       def read_store_attribute(store_attribute, key) # :doc:
         accessor = store_accessor_for(store_attribute)
         accessor.read(self, store_attribute, key)

data/lib/active_entity/type.rb

@@ -6,7 +6,6 @@ require "active_entity/type/internal/timezone"
 
 require "active_entity/type/date"
 require "active_entity/type/date_time"
-require "active_entity/type/decimal_without_scale"
 require "active_entity/type/json"
 require "active_entity/type/time"
 require "active_entity/type/text"
@@ -18,12 +17,9 @@ require "active_entity/type/modifiers/array_without_blank"
 require "active_entity/type/serialized"
 require "active_entity/type/registry"
 
-require "active_entity/type/type_map"
-require "active_entity/type/hash_lookup_type_map"
-
 module ActiveEntity
   module Type
-    @registry = ActiveEntity::Type::Registry.new
+    @registry = Registry.new
 
     class << self
       attr_accessor :registry # :nodoc:
@@ -31,8 +27,12 @@ module ActiveEntity
 
       # Add a new type to the registry, allowing it to be referenced as a
       # symbol by {ActiveEntity::Base.attribute}[rdoc-ref:Attributes::ClassMethods#attribute].
-      # <tt>override: true</tt> will cause your type to be used instead of the native type.
-      # <tt>override: false</tt> will cause the native type to be used over yours if one exists.
+      # If your type is only meant to be used with a specific database adapter, you can
+      # do so by passing <tt>adapter: :postgresql</tt>. If your type has the same
+      # name as a native type for the current adapter, an exception will be
+      # raised unless you specify an +:override+ option. <tt>override: true</tt> will
+      # cause your type to be used instead of the native type. <tt>override:
+      # false</tt> will cause the native type to be used over yours if one exists.
       def register(type_name, klass = nil, **options, &block)
         registry.register(type_name, klass, **options, &block)
       end
@@ -46,7 +46,6 @@ module ActiveEntity
       end
     end
 
-    Helpers = ActiveModel::Type::Helpers
     BigInteger = ActiveModel::Type::BigInteger
     Binary = ActiveModel::Type::Binary
     Boolean = ActiveModel::Type::Boolean
@@ -67,6 +66,7 @@ module ActiveEntity
     register(:decimal, Type::Decimal, override: false)
     register(:float, Type::Float, override: false)
     register(:integer, Type::Integer, override: false)
+    register(:unsigned_integer, Type::UnsignedInteger, override: false)
     register(:json, Type::Json, override: false)
     register(:string, Type::String, override: false)
     register(:text, Type::Text, override: false)

data/lib/active_entity/type/registry.rb

@@ -6,8 +6,8 @@ module ActiveEntity
   # :stopdoc:
   module Type
     class Registry < ActiveModel::Type::Registry
-      def add_modifier(options, klass)
-        registrations << DecorationRegistration.new(options, klass)
+      def add_modifier(options, klass, **args)
+        registrations << DecorationRegistration.new(options, klass, **args)
       end
 
       private
@@ -16,9 +16,9 @@ module ActiveEntity
           Registration
         end
 
-        def find_registration(symbol, *args)
+        def find_registration(symbol, *args, **kwargs)
           registrations
-            .select { |registration| registration.matches?(symbol, *args) }
+            .select { |registration| registration.matches?(symbol, *args, **kwargs) }
             .max
         end
     end
@@ -56,7 +56,7 @@ module ActiveEntity
     end
 
     class DecorationRegistration < Registration
-      def initialize(options, klass)
+      def initialize(options, klass, **)
         @options = options
         @klass = klass
       end

data/lib/active_entity/{validate_embedded_association.rb → validate_embeds_association.rb}

@@ -127,12 +127,12 @@ module ActiveEntity
   # Now it _is_ removed from the database:
   #
   #   Comment.find_by(id: id).nil? # => true
-  module ValidateEmbeddedAssociation
+  module ValidateEmbedsAssociation
     extend ActiveSupport::Concern
 
     module AssociationBuilderExtension #:nodoc:
       def self.build(model, reflection)
-        model.send(:add_embedded_associations_validation_callbacks, reflection)
+        model.send(:add_embeds_associations_validation_callbacks, reflection)
       end
 
       def self.valid_options
@@ -141,7 +141,7 @@ module ActiveEntity
     end
 
     included do
-      Associations::Embedded::Builder::Association.extensions << AssociationBuilderExtension
+      Associations::Embeds::Builder::Association.extensions << AssociationBuilderExtension
 
       unless respond_to?(:index_nested_attribute_errors)
         mattr_accessor :index_nested_attribute_errors, instance_writer: false, default: false
@@ -180,11 +180,11 @@ module ActiveEntity
         # the callbacks to get defined multiple times, there are guards that
         # check if the save or validation methods have already been defined
         # before actually defining them.
-        def add_embedded_associations_validation_callbacks(reflection)
-          define_embedded_associations_validation_callbacks(reflection)
+        def add_embeds_associations_validation_callbacks(reflection)
+          define_embeds_associations_validation_callbacks(reflection)
         end
 
-        def define_embedded_associations_validation_callbacks(reflection)
+        def define_embeds_associations_validation_callbacks(reflection)
           validation_method = :"validate_associated_records_for_#{reflection.name}"
           if reflection.validate? && !method_defined?(validation_method)
             if reflection.collection?

data/lib/active_entity/validations.rb

@@ -23,7 +23,7 @@ module ActiveEntity
     # \Validations with no <tt>:on</tt> option will run no matter the context. \Validations with
     # some <tt>:on</tt> option will only run in the specified context.
     def valid?(context = nil)
-      context ||= default_validation_context
+      context ||= :default
       output = super(context)
       errors.empty? && output
     end
@@ -32,10 +32,6 @@ module ActiveEntity
 
   private
 
-    def default_validation_context
-      :default
-    end
-
     def perform_validations(options = {})
       options[:validate] == false || valid?(options[:context])
     end
@@ -47,5 +43,5 @@ require "active_entity/validations/presence"
 require "active_entity/validations/absence"
 require "active_entity/validations/length"
 require "active_entity/validations/subset"
-require "active_entity/validations/uniqueness_in_embedding"
+require "active_entity/validations/uniqueness_in_embeds"
 require "active_entity/validations/uniqueness_on_active_record"

data/lib/active_entity/validations/associated.rb

@@ -5,7 +5,7 @@ module ActiveEntity
     class AssociatedValidator < ActiveModel::EachValidator #:nodoc:
       def validate_each(record, attribute, value)
         if Array(value).reject { |r| valid_object?(r) }.any?
-          record.errors.add(attribute, :invalid, options.merge(value: value))
+          record.errors.add(attribute, :invalid, **options.merge(value: value))
         end
       end
 

data/lib/active_entity/validations/{uniqueness_in_embedding.rb → uniqueness_in_embeds.rb}

@@ -2,7 +2,7 @@
 
 module ActiveEntity
   module Validations
-    class UniquenessInEmbeddingValidator < ActiveModel::EachValidator # :nodoc:
+    class UniquenessInEmbedsValidator < ActiveModel::EachValidator # :nodoc:
       ERROR_MESSAGE = "`key` option of the configuration hash must be symbol or array of symbols."
 
       def check_validity!

data/lib/active_entity/validations/uniqueness_on_active_record.rb

@@ -12,62 +12,61 @@ module ActiveEntity
           raise ArgumentError, "#{options[:scope]} is not supported format for :scope option. " \
             "Pass a symbol or an array of symbols instead: `scope: :user_id`"
         end
-
         super
 
-        @finder_class =
-          if options[:ar_class_name].present?
-            options[:ar_class_name].safe_constantize
-          elsif options[:ar_class].present? && options[:ar_class].is_a?(Class)
-            options[:ar_class]
+        @klass =
+          if options[:class].present?
+            options[:class]
+          elsif options[:class_name].present?
+            options[:class_name].safe_constantize
           else
             nil
           end
 
-        unless @finder_class
+        unless @klass
           raise ArgumentError, "Must provide one of option :class_name or :class."
         end
-        unless @finder_class < ActiveRecord::Base
-          raise ArgumentError, "Class must be an Active Record model, but got #{@finder_class}."
+        unless @klass < ActiveRecord::Base
+          raise ArgumentError, "Class must be an Active Entity model, but got #{@klass}."
         end
-        if @finder_class.abstract_class?
+        if @klass.abstract_class?
           raise ArgumentError, "Class can't be an abstract class."
         end
-
-        @primary_key_attribute_name = options[:primary_key_attribute_name]
-        @present_only = options[:present_only]
       end
 
       def validate_each(record, attribute, value)
-        value = map_enum_attribute(@finder_class, attribute, value)
-        if @present_only && value.blank?
-          return
-        end
+        finder_class = find_finder_class_for(record)
+        value = map_enum_attribute(finder_class, attribute, value)
 
-        relation = build_relation(@finder_class, attribute, value)
-        if @primary_key_attribute_name.present?
-          primary_key_attribute = record.read_attribute(@primary_key_attribute_name)
-          if primary_key_attribute.present?
-            if @finder_class.primary_key
-              relation = relation.where.not(@finder_class.primary_key => primary_key_attribute)
-            else
-              raise ActiveRecord::UnknownPrimaryKey.new(@finder_class, "Can not validate uniqueness for persisted record without primary key.")
-            end
-          end
-        end
+        relation = build_relation(finder_class, attribute, value)
         relation = scope_relation(record, relation)
         relation = relation.merge(options[:conditions]) if options[:conditions]
 
         if relation.exists?
-          error_options = options.except(:case_sensitive, :scope, :conditions, :ar_class, :ar_class_name, :primary_key_attribute_name)
+          error_options = options.except(:case_sensitive, :scope, :conditions)
           error_options[:value] = value
 
-          record.errors.add(attribute, :taken, error_options)
+          record.errors.add(attribute, :taken, **error_options)
         end
       end
 
     private
 
+      # The check for an existing value should be run from a class that
+      # isn't abstract. This means working down from the current class
+      # (self), to the first non-abstract class. Since classes don't know
+      # their subclasses, we have to build the hierarchy between self and
+      # the record's class.
+      def find_finder_class_for(record)
+        class_hierarchy = [record.class]
+
+        while class_hierarchy.first != @klass
+          class_hierarchy.unshift(class_hierarchy.first.superclass)
+        end
+
+        class_hierarchy.detect { |klass| !klass.abstract_class? }
+      end
+
       def build_relation(klass, attribute, value)
         relation = klass.unscoped
         comparison = relation.bind_attribute(attribute, value) do |attr, bind|
@@ -88,11 +87,7 @@ module ActiveEntity
 
       def scope_relation(record, relation)
         Array(options[:scope]).each do |scope_item|
-          scope_value = if record.class._reflect_on_association(scope_item)
-            record.association(scope_item).reader
-          else
-            record._read_attribute(scope_item)
-          end
+          scope_value = record._read_attribute(scope_item)
           relation = relation.where(scope_item => scope_value)
         end
 
@@ -111,14 +106,14 @@ module ActiveEntity
       # across the system. Useful for making sure that only one user
       # can be named "davidhh".
       #
-      #   class Person < ActiveRecord::Base
+      #   class Person < ActiveEntity::Base
       #     validates_uniqueness_of :user_name
       #   end
       #
       # It can also validate whether the value of the specified attributes are
       # unique based on a <tt>:scope</tt> parameter:
       #
-      #   class Person < ActiveRecord::Base
+      #   class Person < ActiveEntity::Base
       #     validates_uniqueness_of :user_name, scope: :account_id
       #   end
       #
@@ -126,7 +121,7 @@ module ActiveEntity
       # teacher can only be on the schedule once per semester for a particular
       # class.
       #
-      #   class TeacherSchedule < ActiveRecord::Base
+      #   class TeacherSchedule < ActiveEntity::Base
       #     validates_uniqueness_of :teacher_id, scope: [:semester_id, :class_id]
       #   end
       #
@@ -135,7 +130,7 @@ module ActiveEntity
       # are not being taken into consideration when validating uniqueness
       # of the title attribute:
       #
-      #   class Article < ActiveRecord::Base
+      #   class Article < ActiveEntity::Base
       #     validates_uniqueness_of :title, conditions: -> { where.not(status: 'archived') }
       #   end
       #
@@ -172,7 +167,7 @@ module ActiveEntity
       # === Concurrency and integrity
       #
       # Using this validation method in conjunction with
-      # {ActiveRecord::Base#save}[rdoc-ref:Persistence#save]
+      # {ActiveEntity::Base#save}[rdoc-ref:Persistence#save]
       # does not guarantee the absence of duplicate record insertions, because
       # uniqueness checks on the application level are inherently prone to race
       # conditions. For example, suppose that two users try to post a Comment at
@@ -212,7 +207,7 @@ module ActiveEntity
       # the field's uniqueness.
       #
       # When the database catches such a duplicate insertion,
-      # {ActiveRecord::Base#save}[rdoc-ref:Persistence#save] will raise an ActiveRecord::StatementInvalid
+      # {ActiveEntity::Base#save}[rdoc-ref:Persistence#save] will raise an ActiveEntity::StatementInvalid
       # exception. You can either choose to let this error propagate (which
       # will result in the default Rails exception page being shown), or you
       # can catch it and restart the transaction (e.g. by telling the user
@@ -220,17 +215,17 @@ module ActiveEntity
       # This technique is also known as
       # {optimistic concurrency control}[https://en.wikipedia.org/wiki/Optimistic_concurrency_control].
       #
-      # The bundled ActiveRecord::ConnectionAdapters distinguish unique index
+      # The bundled ActiveEntity::ConnectionAdapters distinguish unique index
       # constraint errors from other types of database errors by throwing an
-      # ActiveRecord::RecordNotUnique exception. For other adapters you will
+      # ActiveEntity::RecordNotUnique exception. For other adapters you will
       # have to parse the (database-specific) exception message to detect such
       # a case.
       #
-      # The following bundled adapters throw the ActiveRecord::RecordNotUnique exception:
+      # The following bundled adapters throw the ActiveEntity::RecordNotUnique exception:
       #
-      # * ActiveRecord::ConnectionAdapters::Mysql2Adapter.
-      # * ActiveRecord::ConnectionAdapters::SQLite3Adapter.
-      # * ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.
+      # * ActiveEntity::ConnectionAdapters::Mysql2Adapter.
+      # * ActiveEntity::ConnectionAdapters::SQLite3Adapter.
+      # * ActiveEntity::ConnectionAdapters::PostgreSQLAdapter.
       def validates_uniqueness_on_active_record_of(*attr_names)
         validates_with UniquenessOnActiveRecordValidator, _merge_attributes(attr_names)
       end