activeentity 0.0.1.beta15 → 6.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f4a4f6e30f287b1ae750d510743b3cbb3c3ac40f00bcb56e9c5c634de23ce64
-  data.tar.gz: 91a3be9d2223600c26ff56e025ddd37ec3d520951cc033587d196599a8b10e72
+  metadata.gz: a48deda3be4192f640dfdf3feebc0152f65cd41eb7483e9c0d082a1565071227
+  data.tar.gz: 79b7877eee5cf2c3f9ae976533f15a0651b2cc0257174b2f7ea8a93034123212
 SHA512:
-  metadata.gz: 924b81ffdd2d8835492f7566dc70d11486932ff913a3bea4569294545a9f3037b009e147e6bf77c222686a82596bda207620dd2cb07ec8334af9937ab03b7df6
-  data.tar.gz: da1b359c2ae9d9e0a1033bce6934c5fde0a18c96a78a8b63eaab4d5a83f71f75b241a59c5867cecaaff8033113d4c0bc0bdd094d04b3d0f057d113ad7a94c4b5
+  metadata.gz: 718bced85e2be2eb42ad37daca8ba3a9d1a1c63f3e91f6fedcea297c57abce9c596ab2bad681ecaad2d13b001edb7d695872021ebab5a57a954a9b63a409ebb5
+  data.tar.gz: 37eafc74002e3a8b5e4af2c017f070ba782c6b347dd40d92dcf25f867cf9be79b72fd4dba6e378766422741325e9e9df9c09dad43a35deb5e9ab1e496cdfb1f3

data/README.md

@@ -65,7 +65,7 @@ Supported Active Record validations:
 
 #### `subset` validation
 
-Because Active Entity supports array attribute, for some reason, we may want to test values of an array attribute are all included in a given set.
+Because Active Entity supports array attribute, for some reason, you may want to test values of an array attribute are all included in a given set.
 
 Active Entity provides `subset` validation to achieve that, it usage similar to `inclusion` or `exclusion`
 
@@ -76,9 +76,9 @@ class Steak < ActiveEntity::Base
 end
 ```
 
-#### `uniqueness_in_embedding` validation
+#### `uniqueness_in_embeds` validation
 
-Active Entity provides `uniqueness_in_embedding` validation to test duplicate nesting virtual record.
+Active Entity provides `uniqueness_in_embeds` validation to test duplicate nesting virtual record.
 
 Argument `key` is attribute name of nested model, it also supports multiple attributes by given an array.
 
@@ -101,6 +101,23 @@ class Book < ActiveEntity::Base
 end
 ```
 
+#### `uniqueness_in_active_record` validation
+
+Active Entity provides `uniqueness_in_active_record` validation to test given `scope` doesn't present in ActiveRecord model.
+
+The usage same as [uniqueness](https://guides.rubyonrails.org/active_record_validations.html#uniqueness) in addition you must give a AR model `class_name`
+
+```ruby
+class Candidate < ActiveEntity::Base
+  attribute :name, :string
+
+  validates :name,
+            uniqueness_on_active_record: {
+              class_name: "Staff"
+            }
+end
+```
+
 ### Others
 
 These Active Record feature also available in Active Entity

data/lib/active_entity.rb

@@ -38,6 +38,7 @@ module ActiveEntity
   extend ActiveSupport::Autoload
 
   autoload :Base
+  autoload :Callbacks
   autoload :Core
   autoload :Enum
   autoload :Inheritance

data/lib/active_entity/attribute_assignment.rb

@@ -6,29 +6,25 @@ module ActiveEntity
   module AttributeAssignment
     include ActiveModel::AttributeAssignment
 
-    def assign_attributes(attributes)
-      super(attributes.dup)
-    end
-
     private
 
       def _assign_attributes(attributes)
-        multi_parameter_attributes  = {}
-        nested_parameter_attributes = {}
+        multi_parameter_attributes = nested_parameter_attributes = nil
 
         attributes.each do |k, v|
           key = k.to_s
 
           if key.include?("(")
-            multi_parameter_attributes[key] = attributes.delete(k)
+            (multi_parameter_attributes ||= {})[key] = v
           elsif v.is_a?(Hash)
-            nested_parameter_attributes[key] = attributes.delete(k)
+            (nested_parameter_attributes ||= {})[key] = v
+          else
+            _assign_attribute(key, v)
           end
         end
-        super(attributes)
 
-        assign_nested_parameter_attributes(nested_parameter_attributes) unless nested_parameter_attributes.empty?
-        assign_multiparameter_attributes(multi_parameter_attributes) unless multi_parameter_attributes.empty?
+        assign_nested_parameter_attributes(nested_parameter_attributes) if nested_parameter_attributes
+        assign_multiparameter_attributes(multi_parameter_attributes) if multi_parameter_attributes
       end
 
       # Assign any deferred nested attributes after the base attributes have been set.

data/lib/active_entity/attribute_methods.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "mutex_m"
+require "active_support/core_ext/enumerable"
 
 module ActiveEntity
   # = Active Entity Attribute Methods
@@ -26,6 +27,17 @@ module ActiveEntity
       include Mutex_m
     end
 
+    class << self
+      def dangerous_attribute_methods # :nodoc:
+        @dangerous_attribute_methods ||= (
+        Base.instance_methods +
+          Base.private_instance_methods -
+          Base.superclass.instance_methods -
+          Base.superclass.private_instance_methods
+        ).map { |m| -m.to_s }.to_set.freeze
+      end
+    end
+
     module ClassMethods
       def inherited(child_class) #:nodoc:
         child_class.initialize_generated_modules
@@ -95,7 +107,7 @@ module ActiveEntity
       # A method name is 'dangerous' if it is already (re)defined by Active Entity, but
       # not by any ancestors. (So 'puts' is not dangerous but 'save' is.)
       def dangerous_attribute_method?(name) # :nodoc:
-        method_defined_within?(name, Base)
+        ::ActiveEntity::AttributeMethods.dangerous_attribute_methods.include?(name.to_s)
       end
 
       def method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
@@ -147,25 +159,40 @@ module ActiveEntity
       #   class Person < ActiveEntity::Base
       #   end
       #
-      #   Person.has_attribute?('name')   # => true
-      #   Person.has_attribute?(:age)     # => true
-      #   Person.has_attribute?(:nothing) # => false
+      #   Person.has_attribute?('name')     # => true
+      #   Person.has_attribute?('new_name') # => true
+      #   Person.has_attribute?(:age)       # => true
+      #   Person.has_attribute?(:nothing)   # => false
       def has_attribute?(attr_name)
-        attribute_types.key?(attr_name.to_s)
+        attr_name = attr_name.to_s
+        attr_name = attribute_aliases[attr_name] || attr_name
+        attribute_types.key?(attr_name)
+      end
+
+      def _has_attribute?(attr_name) # :nodoc:
+        attribute_types.key?(attr_name)
       end
     end
 
     # Returns +true+ if the given attribute is in the attributes hash, otherwise +false+.
     #
     #   class Person < ActiveEntity::Base
+    #     alias_attribute :new_name, :name
     #   end
     #
     #   person = Person.new
-    #   person.has_attribute?(:name)    # => true
-    #   person.has_attribute?('age')    # => true
-    #   person.has_attribute?(:nothing) # => false
+    #   person.has_attribute?(:name)     # => true
+    #   person.has_attribute?(:new_name) # => true
+    #   person.has_attribute?('age')     # => true
+    #   person.has_attribute?(:nothing)  # => false
     def has_attribute?(attr_name)
-      @attributes.key?(attr_name.to_s)
+      attr_name = attr_name.to_s
+      attr_name = self.class.attribute_aliases[attr_name] || attr_name
+      @attributes.key?(attr_name)
+    end
+
+    def _has_attribute?(attr_name) # :nodoc:
+      @attributes.key?(attr_name)
     end
 
     # Returns an array of names for the attributes available on this object.
@@ -209,6 +236,7 @@ module ActiveEntity
     #   person.attribute_for_inspect(:tag_ids)
     #   # => "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]"
     def attribute_for_inspect(attr_name)
+      attr_name = attr_name.to_s
       value = _read_attribute(attr_name)
       format_for_inspect(value)
     end
@@ -228,8 +256,9 @@ module ActiveEntity
     #   task.is_done = true
     #   task.attribute_present?(:title)   # => true
     #   task.attribute_present?(:is_done) # => true
-    def attribute_present?(attribute)
-      value = _read_attribute(attribute)
+    def attribute_present?(attr_name)
+      attr_name = attr_name.to_s
+      value = _read_attribute(attr_name)
       !value.nil? && !(value.respond_to?(:empty?) && value.empty?)
     end
 
@@ -268,39 +297,6 @@ module ActiveEntity
       write_attribute(attr_name, value)
     end
 
-    # Returns the name of all database fields which have been read from this
-    # model. This can be useful in development mode to determine which fields
-    # need to be selected. For performance critical pages, selecting only the
-    # required fields can be an easy performance win (assuming you aren't using
-    # all of the fields on the model).
-    #
-    # For example:
-    #
-    #   class PostsController < ActionController::Base
-    #     after_action :print_accessed_fields, only: :index
-    #
-    #     def index
-    #       @posts = Post.all
-    #     end
-    #
-    #     private
-    #
-    #     def print_accessed_fields
-    #       p @posts.first.accessed_fields
-    #     end
-    #   end
-    #
-    # Which allows you to quickly change your code to:
-    #
-    #   class PostsController < ActionController::Base
-    #     def index
-    #       @posts = Post.select(:id, :title, :author_id, :updated_at)
-    #     end
-    #   end
-    def accessed_fields
-      @attributes.accessed
-    end
-
     private
 
       def attribute_method?(attr_name)
@@ -308,12 +304,6 @@ module ActiveEntity
         defined?(@attributes) && @attributes.key?(attr_name)
       end
 
-      def attributes_with_values(attribute_names)
-        attribute_names.each_with_object({}) do |name, attrs|
-          attrs[name] = _read_attribute(name)
-        end
-      end
-
       def format_for_inspect(value)
         if value.is_a?(String) && value.length > 50
           "#{value[0, 50]}...".inspect

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/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,16 +8,14 @@ module ActiveEntity
       module ClassMethods # :nodoc:
         private
 
-          def define_method_attribute(name)
+          def define_method_attribute(name, owner:)
             ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
-              generated_attribute_methods, name
+              owner, name
             ) do |temp_method_name, attr_name_expr|
-              generated_attribute_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-                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
@@ -29,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,16 +12,14 @@ module ActiveEntity
       module ClassMethods # :nodoc:
         private
 
-          def define_method_attribute=(name)
+          def define_method_attribute=(name, owner:)
             ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
-              generated_attribute_methods, name, writer: true,
-            ) do |temp_method_name, attr_name_expr|
-              generated_attribute_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-                def #{temp_method_name}(value)
-                  name = #{attr_name_expr}
-                  _write_attribute(name, value)
-                end
-              RUBY
+              owner, name, writer: true,
+              ) do |temp_method_name, attr_name_expr|
+              owner <<
+                "def #{temp_method_name}(value)" <<
+                "  _write_attribute(#{attr_name_expr}, value)" <<
+                "end"
             end
           end
       end
@@ -33,28 +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:
-        return if readonly_attribute?(attr_name) && attr_readonly_enabled?
-
-        @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

data/lib/active_entity/base.rb

@@ -6,7 +6,6 @@ require "active_support/descendants_tracker"
 require "active_support/time"
 require "active_support/core_ext/class/subclasses"
 require "active_entity/attribute_decorators"
-require "active_entity/define_callbacks"
 require "active_entity/attributes"
 
 module ActiveEntity #:nodoc:
@@ -280,7 +279,6 @@ module ActiveEntity #:nodoc:
     include Validations
     include Attributes
     include AttributeDecorators
-    include DefineCallbacks
     include AttributeMethods
     include Callbacks
     include Associations

data/lib/active_entity/{define_callbacks.rb → callbacks.rb}

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 module ActiveEntity
-  # This module exists because ActiveEntity::AttributeMethods::Dirty needs to
-  # define callbacks, but continue to have its version of +save+ be the super
-  # method of ActiveEntity::Callbacks. This will be removed when the removal
-  # of deprecated code removes this need.
-  module DefineCallbacks
+  module Callbacks
     extend ActiveSupport::Concern
 
+    CALLBACKS = [
+      :after_initialize, :before_validation, :after_validation
+    ]
+
     module ClassMethods # :nodoc:
       include ActiveModel::Callbacks
     end

data/lib/active_entity/core.rb

@@ -317,6 +317,7 @@ module ActiveEntity
       end
 
       def init_internals
+        @primary_key              = self.class.primary_key
         @readonly                 = false
         @marked_for_destruction   = false
 

data/lib/active_entity/gem_version.rb

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

data/lib/active_entity/validations/uniqueness_on_active_record.rb

@@ -27,7 +27,7 @@ module ActiveEntity
           raise ArgumentError, "Must provide one of option :class_name or :class."
         end
         unless @klass < ActiveRecord::Base
-          raise ArgumentError, "Class must be an Active Entity model, but got #{@finder_class}."
+          raise ArgumentError, "Class must be an Active Entity model, but got #{@klass}."
         end
         if @klass.abstract_class?
           raise ArgumentError, "Class can't be an abstract class."
@@ -39,13 +39,6 @@ module ActiveEntity
         value = map_enum_attribute(finder_class, attribute, value)
 
         relation = build_relation(finder_class, attribute, value)
-        if record.persisted?
-          if finder_class.primary_key
-            relation = relation.where.not(finder_class.primary_key => record.id_in_database)
-          else
-            raise UnknownPrimaryKey.new(finder_class, "Cannot validate uniqueness for persisted record without primary key.")
-          end
-        end
         relation = scope_relation(record, relation)
         relation = relation.merge(options[:conditions]) if options[:conditions]
 
@@ -94,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
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activeentity
 version: !ruby/object:Gem::Version
-  version: 0.0.1.beta15
+  version: 6.1.1
 platform: ruby
 authors:
 - jasl
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-02-14 00:00:00.000000000 Z
+date: 2021-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -89,10 +89,10 @@ files:
 - lib/active_entity/attribute_methods/write.rb
 - lib/active_entity/attributes.rb
 - lib/active_entity/base.rb
+- lib/active_entity/callbacks.rb
 - lib/active_entity/coders/json.rb
 - lib/active_entity/coders/yaml_column.rb
 - lib/active_entity/core.rb
-- lib/active_entity/define_callbacks.rb
 - lib/active_entity/enum.rb
 - lib/active_entity/errors.rb
 - lib/active_entity/gem_version.rb
@@ -135,7 +135,7 @@ homepage: https://github.com/jasl/activeentity
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -146,12 +146,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Rails virtual model solution based on ActiveModel.
 test_files: []