activeentity 0.0.1.beta14 → 0.0.1.beta15

data/lib/active_entity/define_callbacks.rb

@@ -1,6 +1,10 @@
 # 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
     extend ActiveSupport::Concern
 

data/lib/active_entity/enum.rb

@@ -27,6 +27,32 @@ module ActiveEntity
   #   conversation.status.nil? # => true
   #   conversation.status      # => nil
   #
+  # Scopes based on the allowed values of the enum field will be provided
+  # as well. With the above example:
+  #
+  #   Conversation.active
+  #   Conversation.not_active
+  #   Conversation.archived
+  #   Conversation.not_archived
+  #
+  # Of course, you can also query them directly if the scopes don't fit your
+  # needs:
+  #
+  #   Conversation.where(status: [:active, :archived])
+  #   Conversation.where.not(status: :active)
+  #
+  # Defining scopes can be disabled by setting +:_scopes+ to +false+.
+  #
+  #   class Conversation < ActiveEntity::Base
+  #     enum status: [ :active, :archived ], _scopes: false
+  #   end
+  #
+  # You can set the default value from the database declaration, like:
+  #
+  #   create_table :conversations do |t|
+  #     t.column :status, :integer, default: 0
+  #   end
+  #
   # Good practice is to let the first declared status be the default.
   #
   # Finally, it's also possible to explicitly map the relation between attribute and
@@ -97,12 +123,12 @@ module ActiveEntity
       end
 
       def cast(value)
-        return if value.blank?
-
         if mapping.has_key?(value)
           value.to_s
         elsif mapping.has_value?(value)
           mapping.key(value)
+        elsif value.blank?
+          nil
         else
           assert_valid_value(value)
         end
@@ -124,6 +150,7 @@ module ActiveEntity
       end
 
       private
+
         attr_reader :name, :mapping, :subtype
     end
 
@@ -182,6 +209,7 @@ module ActiveEntity
     end
 
     private
+
       def _enum_methods_module
         @_enum_methods_module ||= begin
           mod = Module.new
@@ -212,8 +240,6 @@ module ActiveEntity
       def detect_enum_conflict!(enum_name, method_name, klass_method = false)
         if klass_method && dangerous_class_method?(method_name)
           raise_conflict_error(enum_name, method_name, type: "class")
-        # elsif klass_method && method_defined_within?(method_name, Relation)
-        #   raise_conflict_error(enum_name, method_name, type: "class", source: Relation.name)
         elsif !klass_method && dangerous_attribute_method?(method_name)
           raise_conflict_error(enum_name, method_name)
         elsif !klass_method && method_defined_within?(method_name, _enum_methods_module, Module)

data/lib/active_entity/errors.rb

@@ -7,13 +7,6 @@ module ActiveEntity
   class ActiveEntityError < StandardError
   end
 
-  # Raised when the single-table inheritance mechanism fails to locate the subclass
-  # (for example due to improper usage of column that
-  # {ActiveEntity::Base.inheritance_attribute}[rdoc-ref:ModelSchema::ClassMethods#inheritance_attribute]
-  # points to).
-  class SubclassNotFound < ActiveEntityError
-  end
-
   # Raised when an object assigned to an association has an incorrect type.
   #
   #   class Ticket < ActiveEntity::Base
@@ -41,10 +34,6 @@ module ActiveEntity
   class ConfigurationError < ActiveEntityError
   end
 
-  # Raised on attempt to update record that is instantiated as read only.
-  class ReadOnlyRecord < ActiveEntityError
-  end
-
   # Raised when attribute has a name reserved by Active Entity (when attribute
   # has name of one of Active Entity instance methods).
   class DangerousAttributeError < ActiveEntityError

data/lib/active_entity/gem_version.rb

@@ -10,7 +10,7 @@ module ActiveEntity
     MAJOR = 0
     MINOR = 0
     TINY  = 1
-    PRE   = "beta14"
+    PRE   = "beta15"
 
     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