activeentity 0.0.1.beta14 → 6.1.0

data/lib/active_entity/associations/{embedded → embeds}/embeds_one_association.rb

@@ -2,10 +2,11 @@
 
 module ActiveEntity
   module Associations
-    module Embedded
+    module Embeds
       # = Active Entity Has One Association
       class EmbedsOneAssociation < SingularAssociation #:nodoc:
         private
+
           def replace(record)
             self.target =
               if record.is_a? reflection.klass

data/lib/active_entity/associations/{embedded → embeds}/singular_association.rb

@@ -2,7 +2,7 @@
 
 module ActiveEntity
   module Associations
-    module Embedded
+    module Embeds
       class SingularAssociation < Association #:nodoc:
         # Implements the reader method, e.g. foo.bar for Foo.has_one :bar
         def reader

data/lib/active_entity/attribute_assignment.rb

@@ -9,20 +9,22 @@ module ActiveEntity
     private
 
       def _assign_attributes(attributes)
-        multi_parameter_attributes  = {}
-        nested_parameter_attributes = {}
+        multi_parameter_attributes = nested_parameter_attributes = nil
 
         attributes.each do |k, v|
-          if k.to_s.include?("(")
-            multi_parameter_attributes[k] = attributes.delete(k)
+          key = k.to_s
+
+          if key.include?("(")
+            (multi_parameter_attributes ||= {})[key] = v
           elsif v.is_a?(Hash)
-            nested_parameter_attributes[k] = 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
@@ -16,6 +17,7 @@ module ActiveEntity
       include Query
       include PrimaryKey
       include TimeZoneConversion
+      include Dirty
       include Serialization
     end
 
@@ -25,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
@@ -32,7 +45,8 @@ module ActiveEntity
       end
 
       def initialize_generated_modules # :nodoc:
-        @generated_attribute_methods = GeneratedAttributeMethods.new
+        @generated_attribute_methods = const_set(:GeneratedAttributeMethods, GeneratedAttributeMethods.new)
+        private_constant :GeneratedAttributeMethods
         @attribute_methods_generated = false
         include @generated_attribute_methods
 
@@ -93,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:
@@ -111,13 +125,11 @@ module ActiveEntity
       # A class method is 'dangerous' if it is already (re)defined by Active Entity, but
       # not by any ancestors. (So 'puts' is not dangerous but 'new' is.)
       def dangerous_class_method?(method_name)
-        RESTRICTED_CLASS_METHODS.include?(method_name.to_s) || class_method_defined_within?(method_name, Base)
-      end
+        return true if RESTRICTED_CLASS_METHODS.include?(method_name.to_s)
 
-      def class_method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
-        if klass.respond_to?(name, true)
-          if superklass.respond_to?(name, true)
-            klass.method(name).owner != superklass.method(name).owner
+        if Base.respond_to?(method_name, true)
+          if Object.respond_to?(method_name, true)
+            Base.method(method_name).owner != Object.method(method_name).owner
           else
             true
           end
@@ -126,8 +138,8 @@ module ActiveEntity
         end
       end
 
-      # Returns an array of column names as strings if it's not an abstract class and
-      # table exists. Otherwise it returns an empty array.
+      # Returns an array of column names as strings if it's not an abstract class.
+      # Otherwise it returns an empty array.
       #
       #   class Person < ActiveEntity::Base
       #   end
@@ -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,51 +297,13 @@ 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)
         # We check defined? because Syck calls respond_to? before actually calling initialize.
         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
@@ -323,8 +314,8 @@ module ActiveEntity
         end
       end
 
-      def readonly_attribute?(name)
-        self.class.readonly_attributes.include?(name)
+      def pk_attribute?(name)
+        name == @primary_key
       end
   end
 end

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.
@@ -65,13 +65,13 @@ module ActiveEntity
 
       private
 
-        # Handle *_before_type_cast for method_missing.
-        def attribute_before_type_cast(attribute_name)
-          read_attribute_before_type_cast(attribute_name)
+        # Dispatch target for <tt>*_before_type_cast</tt> attribute methods.
+        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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/attribute_accessors"
+
+module ActiveEntity
+  module AttributeMethods
+    module Dirty
+      extend ActiveSupport::Concern
+
+      include ActiveModel::Dirty
+    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
@@ -90,7 +88,7 @@ module ActiveEntity
           #
           #   Project.primary_key # => "foo_id"
           def primary_key=(value)
-            @primary_key = value&.to_s
+            @primary_key = value && -value.to_s
           end
         end
     end

data/lib/active_entity/attribute_methods/query.rb

@@ -16,20 +16,23 @@ module ActiveEntity
         when true        then true
         when false, nil  then false
         else
-          if Numeric === value || value !~ /[^0-9]/
-            !value.to_i.zero?
+          if !type_for_attribute(attr_name) { false }
+            if Numeric === value || !value.match?(/[^0-9]/)
+              !value.to_i.zero?
+            else
+              return false if ActiveModel::Type::Boolean::FALSE_VALUES.include?(value)
+              !value.blank?
+            end
+          elsif value.respond_to?(:zero?)
+            !value.zero?
           else
-            return false if ActiveModel::Type::Boolean::FALSE_VALUES.include?(value)
             !value.blank?
           end
         end
       end
 
-      private
-        # Handle *? for method_missing.
-        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
@@ -27,17 +25,16 @@ module ActiveEntity
       # to a date object, like Date.new(2004, 12, 12)).
       def read_attribute(attr_name, &block)
         name = attr_name.to_s
-        if self.class.attribute_alias?(name)
-          name = self.class.attribute_alias(name)
-        end
+        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/time_zone_conversion.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/object/try"
+
 module ActiveEntity
   module AttributeMethods
     module TimeZoneConversion

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
@@ -31,32 +29,25 @@ module ActiveEntity
       # turned into +nil+.
       def write_attribute(attr_name, value)
         name = attr_name.to_s
-        if self.class.attribute_alias?(name)
-          name = self.class.attribute_alias(name)
-        end
+        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)
-          name = attr_name.to_s
-          @attributes.write_cast_value(name, value)
-          value
-        end
 
-        # Handle *= for method_missing.
-        def attribute=(attribute_name, value)
-          _write_attribute(attribute_name, value)
+        def write_attribute_without_type_cast(attr_name, value)
+          @attributes.write_cast_value(attr_name, value)
         end
     end
   end