activeentity 0.0.1.beta14 → 6.1.0

data/lib/active_entity/gem_version.rb

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

data/lib/active_entity/inheritance.rb

@@ -6,7 +6,7 @@ module ActiveEntity
   # == Single table inheritance
   #
   # Active Entity allows inheritance by storing the name of the class in a column that by
-  # default is named "type" (can be changed by overwriting <tt>Base.inheritance_attribute</tt>).
+  # default is named "type" (can be changed by overwriting <tt>Base.inheritance_column</tt>).
   # This means that an inheritance looking like this:
   #
   #   class Company < ActiveEntity::Base; end
@@ -37,12 +37,6 @@ module ActiveEntity
   module Inheritance
     extend ActiveSupport::Concern
 
-    included do
-      # Determines whether to store the full constant name including namespace when using STI.
-      # This is true, by default.
-      class_attribute :store_full_sti_class, instance_writer: false, default: true
-    end
-
     module ClassMethods
       # Determines if one of the attributes passed in is the inheritance column,
       # and if the inheritance column is attr accessible, it initializes an
@@ -52,19 +46,7 @@ module ActiveEntity
           raise NotImplementedError, "#{self} is an abstract class and cannot be instantiated."
         end
 
-        if has_attribute?(inheritance_attribute)
-          subclass = subclass_from_attributes(attributes)
-
-          if subclass.nil? && base_class?
-            subclass = subclass_from_attributes(_default_attributes)
-          end
-        end
-
-        if subclass && subclass != self
-          subclass.new(attributes, &block)
-        else
-          super
-        end
+        super
       end
 
       # Returns +true+ if this does not need STI type condition. Returns
@@ -75,15 +57,10 @@ module ActiveEntity
         elsif superclass.abstract_class?
           superclass.descends_from_active_entity?
         else
-          superclass == Base || !has_attribute?(inheritance_attribute)
+          superclass == Base
         end
       end
 
-      def finder_needs_type_condition? #:nodoc:
-        # This is like this because benchmarking justifies the strange :false stuff
-        :true == (@finder_needs_type_condition ||= descends_from_active_entity? ? :false : :true)
-      end
-
       # Returns the class descending directly from ActiveEntity::Base, or
       # an abstract class, if any, in the inheritance hierarchy.
       #
@@ -94,7 +71,7 @@ module ActiveEntity
       # and C.base_class would return B as the answer since A is an abstract_class.
       def base_class
         unless self < Base
-          raise ActiveEntityError, "#{name} doesn't belong in a hierarchy descending from Active Entity"
+          raise ActiveEntityError, "#{name} doesn't belong in a hierarchy descending from ActiveEntity"
         end
 
         if superclass == Base || superclass.abstract_class?
@@ -158,10 +135,6 @@ module ActiveEntity
         defined?(@abstract_class) && @abstract_class == true
       end
 
-      def sti_name
-        store_full_sti_class ? name : name.demodulize
-      end
-
       def inherited(subclass)
         subclass.instance_variable_set(:@_type_candidates_cache, Concurrent::Map.new)
         super
@@ -198,81 +171,6 @@ module ActiveEntity
             raise NameError.new("uninitialized constant #{candidates.first}", candidates.first)
           end
         end
-
-      private
-
-        # Called by +instantiate+ to decide which class to use for a new
-        # record instance. For single-table inheritance, we check the record
-        # for a +type+ column and return the corresponding class.
-        def discriminate_class_for_record(record)
-          if using_single_table_inheritance?(record)
-            find_sti_class(record[inheritance_attribute])
-          else
-            super
-          end
-        end
-
-        def using_single_table_inheritance?(record)
-          record[inheritance_attribute].present? && has_attribute?(inheritance_attribute)
-        end
-
-        def find_sti_class(type_name)
-          type_name = base_class.type_for_attribute(inheritance_attribute).cast(type_name)
-          subclass = begin
-            if store_full_sti_class
-              ActiveSupport::Dependencies.constantize(type_name)
-            else
-              compute_type(type_name)
-            end
-          rescue NameError
-            raise SubclassNotFound,
-                  "The single-table inheritance mechanism failed to locate the subclass: '#{type_name}'. " \
-                  "This error is raised because the attribute '#{inheritance_attribute}' is reserved for storing the class in case of inheritance. " \
-                  "Please rename this attribute if you didn't intend it to be used for storing the inheritance class " \
-                  "or overwrite #{name}.inheritance_attribute to use another attribute for that information."
-          end
-          unless subclass == self || descendants.include?(subclass)
-            raise SubclassNotFound, "Invalid single-table inheritance type: #{subclass.name} is not a subclass of #{name}"
-          end
-          subclass
-        end
-
-        # Detect the subclass from the inheritance column of attrs. If the inheritance column value
-        # is not self or a valid subclass, raises ActiveEntity::SubclassNotFound
-        def subclass_from_attributes(attrs)
-          attrs = attrs.to_h if attrs.respond_to?(:permitted?)
-          if attrs.is_a?(Hash)
-            subclass_name = attrs[inheritance_attribute] || attrs[inheritance_attribute.to_sym]
-
-            if subclass_name.present?
-              find_sti_class(subclass_name)
-            end
-          end
-        end
     end
-
-    def initialize_dup(other)
-      super
-      ensure_proper_type
-    end
-
-    private
-
-      def initialize_internals_callback
-        super
-        ensure_proper_type
-      end
-
-      # Sets the attribute used for single table inheritance to this class name if this is not the
-      # ActiveEntity::Base descendant.
-      # Considering the hierarchy Reply < Message < ActiveEntity::Base, this makes it possible to
-      # do Reply.new without having to set <tt>Reply[Reply.inheritance_attribute] = "Reply"</tt> yourself.
-      # No such attribute would be set for objects of the Message class in that example.
-      def ensure_proper_type
-        klass = self.class
-        if klass.finder_needs_type_condition?
-          _write_attribute(klass.inheritance_attribute, klass.sti_name)
-        end
-      end
   end
 end

data/lib/active_entity/integration.rb

@@ -30,7 +30,7 @@ module ActiveEntity
     #   user_path(user)  # => "/users/Phusion"
     def to_param
       # We can't use alias_method here, because method 'id' optimizes itself on the fly.
-      id && id.to_s # Be sure to stringify the id for routes
+      id&.to_s # Be sure to stringify the id for routes
     end
 
     module ClassMethods

data/lib/active_entity/model_schema.rb

@@ -9,22 +9,10 @@ module ActiveEntity
     included do
       delegate :type_for_attribute, to: :class
 
-      self.inheritance_attribute = "type"
-
       initialize_load_schema_monitor
     end
 
     module ClassMethods
-      def inheritance_attribute
-        (@inheritance_attribute ||= nil) || superclass.inheritance_attribute
-      end
-
-      # Sets the value of inheritance_attribute
-      def inheritance_attribute=(value)
-        @inheritance_attribute = value.to_s
-        @explicit_inheritance_attribute = true
-      end
-
       def attributes_builder # :nodoc:
         unless defined?(@attributes_builder) && @attributes_builder
           defaults = _default_attributes

data/lib/active_entity/nested_attributes.rb

@@ -2,7 +2,6 @@
 
 require "active_support/core_ext/hash/except"
 require "active_support/core_ext/module/redefine_method"
-require "active_support/core_ext/object/try"
 require "active_support/core_ext/hash/indifferent_access"
 
 module ActiveEntity
@@ -289,7 +288,7 @@ module ActiveEntity
       # [:allow_destroy]
       #   If true, destroys any members from the attributes hash with a
       #   <tt>_destroy</tt> key and a value that evaluates to +true+
-      #   (eg. 1, '1', true, or 'true'). This option is off by default.
+      #   (e.g. 1, '1', true, or 'true'). This option is off by default.
       # [:reject_if]
       #   Allows you to specify a Proc or a Symbol pointing to a method
       #   that checks whether a record should be built for a certain attribute
@@ -465,10 +464,10 @@ module ActiveEntity
         if attributes_collection.is_a? Hash
           keys = attributes_collection.keys
           attributes_collection = if keys.include?("id") || keys.include?(:id)
-                                    [attributes_collection]
-                                  else
-                                    attributes_collection.values
-                                  end
+            [attributes_collection]
+          else
+            attributes_collection.values
+          end
         end
 
         association = association(association_name)
@@ -551,11 +550,5 @@ module ActiveEntity
       def allow_destroy?(association_name)
         nested_attributes_options[association_name][:allow_destroy]
       end
-
-      def raise_nested_attributes_record_not_found!(association_name, record_id)
-        model = self.class._reflect_on_association(association_name).klass.name
-        raise RecordNotFound.new("Couldn't find #{model} with ID=#{record_id} for #{self.class.name} with ID=#{id}",
-                                 model, "id", record_id)
-      end
   end
 end

data/lib/active_entity/railtie.rb

@@ -2,15 +2,75 @@
 
 require "active_entity"
 require "rails"
+require "active_support/core_ext/object/try"
 require "active_model/railtie"
 
+# For now, action_controller must always be present with
+# Rails, so let's make sure that it gets required before
+# here. This is needed for correctly setting up the middleware.
+# In the future, this might become an optional require.
+require "action_controller/railtie"
+
 module ActiveEntity
   # = Active Entity Railtie
   class Railtie < Rails::Railtie # :nodoc:
+    config.active_entity = ActiveSupport::OrderedOptions.new
+
     config.eager_load_namespaces << ActiveEntity
 
+    # When loading console, force ActiveEntity::Base to be loaded
+    # to avoid cross references when loading a constant for the
+    # first time. Also, make it output to STDERR.
+    console do |_app|
+      require "active_entity/base"
+      unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDERR, STDOUT)
+        console = ActiveSupport::Logger.new(STDERR)
+        Rails.logger.extend ActiveSupport::Logger.broadcast console
+      end
+    end
+
     runner do
-      require "active_record/base"
+      require "active_entity/base"
+    end
+
+    initializer "active_entity.initialize_timezone" do
+      ActiveSupport.on_load(:active_entity) do
+        self.time_zone_aware_attributes = true
+        self.default_timezone = :utc
+      end
+    end
+
+    initializer "active_entity.logger" do
+      ActiveSupport.on_load(:active_entity) { self.logger ||= ::Rails.logger }
+    end
+
+
+    initializer "active_entity.define_attribute_methods" do |app|
+      config.after_initialize do
+        ActiveSupport.on_load(:active_entity) do
+          if app.config.eager_load
+            descendants.each do |model|
+              model.define_attribute_methods
+            end
+          end
+        end
+      end
+    end
+
+    initializer "active_entity.set_configs" do |app|
+      ActiveSupport.on_load(:active_entity) do
+        configs = app.config.active_entity
+
+        configs.each do |k, v|
+          send "#{k}=", v
+        end
+      end
+    end
+
+    initializer "active_entity.set_filter_attributes" do
+      ActiveSupport.on_load(:active_entity) do
+        self.filter_attributes += Rails.application.config.filter_parameters
+      end
     end
   end
 end

data/lib/active_entity/readonly_attributes.rb

@@ -16,7 +16,7 @@ module ActiveEntity
       @_attr_readonly_enabled = true
     end
 
-    def enable_attr_readonly
+    def without_attr_readonly
       return unless block_given?
 
       disable_attr_readonly!
@@ -31,6 +31,10 @@ module ActiveEntity
     end
     alias attr_readonly_enabled? _attr_readonly_enabled
 
+    def readonly_attribute?(name)
+      self.class.readonly_attribute?(name)
+    end
+
     module ClassMethods
       # Attributes listed as readonly will be used to create a new record but update operations will
       # ignore these fields.
@@ -42,6 +46,10 @@ module ActiveEntity
       def readonly_attributes
         _attr_readonly
       end
+
+      def readonly_attribute?(name) # :nodoc:
+        _attr_readonly.include?(name)
+      end
     end
   end
 end

data/lib/active_entity/reflection.rb

@@ -17,7 +17,7 @@ module ActiveEntity
       def create(macro, name, scope, options, ar_or_ae)
         reflection_class_for(macro).new(name, scope, options, ar_or_ae)
 
-        # TODO: Support bridge to Active Record
+        # TODO: Support bridge to Active Entity
         # reflection = reflection_class_for(macro).new(name, scope, options, ar_or_ae)
         # options[:through] ? ActiveRecord::ThroughReflection.new(reflection) : reflection
       end
@@ -33,6 +33,7 @@ module ActiveEntity
       end
 
       private
+
         def reflection_class_for(macro)
           case macro
           when :composed_of
@@ -77,21 +78,21 @@ module ActiveEntity
       #
       def reflections
         @__reflections ||= begin
-          ref = {}
+                             ref = {}
 
-          _reflections.each do |name, reflection|
-            parent_reflection = reflection.parent_reflection
+                             _reflections.each do |name, reflection|
+                               parent_reflection = reflection.parent_reflection
 
-            if parent_reflection
-              parent_name = parent_reflection.name
-              ref[parent_name.to_s] = parent_reflection
-            else
-              ref[name] = reflection
-            end
-          end
+                               if parent_reflection
+                                 parent_name = parent_reflection.name
+                                 ref[parent_name.to_s] = parent_reflection
+                               else
+                                 ref[name] = reflection
+                               end
+                             end
 
-          ref
-        end
+                             ref
+                           end
       end
 
       # Returns an array of AssociationReflection objects for all the
@@ -184,6 +185,7 @@ module ActiveEntity
       end
 
       protected
+
         def actual_source_reflection # FIXME: this is a horrible name
           self
         end
@@ -242,12 +244,13 @@ module ActiveEntity
       def ==(other_aggregation)
         super ||
           other_aggregation.kind_of?(self.class) &&
-          name == other_aggregation.name &&
-          !other_aggregation.options.nil? &&
-          active_entity == other_aggregation.active_entity
+            name == other_aggregation.name &&
+            !other_aggregation.options.nil? &&
+            active_entity == other_aggregation.active_entity
       end
 
       private
+
         def derive_class_name
           name.to_s.camelize
         end
@@ -417,7 +420,7 @@ module ActiveEntity
       def collection?; true; end
 
       def association_class
-        Associations::Embedded::EmbedsManyAssociation
+        Associations::Embeds::EmbedsManyAssociation
       end
     end
 
@@ -427,7 +430,7 @@ module ActiveEntity
       def embeds_one?; true; end
 
       def association_class
-        Associations::Embedded::EmbedsOneAssociation
+        Associations::Embeds::EmbedsOneAssociation
       end
     end
 
@@ -437,7 +440,7 @@ module ActiveEntity
       def embedded_in?; true; end
 
       def association_class
-        Associations::Embedded::EmbeddedInAssociation
+        Associations::Embeds::EmbeddedInAssociation
       end
     end
   end