activeentity 0.0.1.beta1

data/lib/active_entity/associations.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/string/conversions"
+require "active_support/core_ext/module/remove_method"
+require "active_entity/errors"
+
+module ActiveEntity
+  class AssociationNotFoundError < ConfigurationError #:nodoc:
+    def initialize(record = nil, association_name = nil)
+      if record && association_name
+        super("Association named '#{association_name}' was not found on #{record.class.name}; perhaps you misspelled it?")
+      else
+        super("Association was not found.")
+      end
+    end
+  end
+
+  class InverseOfAssociationNotFoundError < ActiveEntityError #:nodoc:
+    def initialize(reflection = nil, associated_class = nil)
+      if reflection
+        super("Could not find the inverse association for #{reflection.name} (#{reflection.options[:inverse_of].inspect} in #{associated_class.nil? ? reflection.class_name : associated_class.name})")
+      else
+        super("Could not find the inverse association.")
+      end
+    end
+  end
+
+  # See ActiveEntity::Associations::ClassMethods for documentation.
+  module Associations # :nodoc:
+    extend ActiveSupport::Autoload
+    extend ActiveSupport::Concern
+
+    # These classes will be loaded when associations are created.
+    # So there is no need to eager load them.
+    module Embedded
+      extend ActiveSupport::Autoload
+
+      autoload :Association, "active_entity/associations/embedded/association"
+      autoload :SingularAssociation, "active_entity/associations/embedded/singular_association"
+      autoload :CollectionAssociation, "active_entity/associations/embedded/collection_association"
+      autoload :CollectionProxy, "active_entity/associations/embedded/collection_proxy"
+
+      module Builder #:nodoc:
+        autoload :Association,             "active_entity/associations/embedded/builder/association"
+        autoload :SingularAssociation,     "active_entity/associations/embedded/builder/singular_association"
+        autoload :CollectionAssociation,   "active_entity/associations/embedded/builder/collection_association"
+
+        autoload :EmbeddedIn,              "active_entity/associations/embedded/builder/embedded_in"
+        autoload :EmbedsOne,               "active_entity/associations/embedded/builder/embeds_one"
+        autoload :EmbedsMany,              "active_entity/associations/embedded/builder/embeds_many"
+      end
+
+      eager_autoload do
+        autoload :EmbeddedInAssociation
+        autoload :EmbedsOneAssociation
+        autoload :EmbedsManyAssociation
+      end
+    end
+
+    def self.eager_load!
+      super
+      Embedded.eager_load!
+    end
+
+    # Returns the association instance for the given name, instantiating it if it doesn't already exist
+    def association(name) #:nodoc:
+      association = association_instance_get(name)
+
+      if association.nil?
+        unless reflection = self.class._reflect_on_association(name)
+          raise AssociationNotFoundError.new(self, name)
+        end
+        association = reflection.association_class.new(self, reflection)
+        association_instance_set(name, association)
+      end
+
+      association
+    end
+
+    def association_cached?(name) # :nodoc:
+      @association_cache.key?(name)
+    end
+
+    def initialize_dup(*) # :nodoc:
+      @association_cache = {}
+      super
+    end
+
+    private
+      # Clears out the association cache.
+      def clear_association_cache
+        @association_cache.clear if persisted?
+      end
+
+      def init_internals
+        @association_cache = {}
+        super
+      end
+
+      # Returns the specified association instance if it exists, +nil+ otherwise.
+      def association_instance_get(name)
+        @association_cache[name]
+      end
+
+      # Set the specified association instance.
+      def association_instance_set(name, association)
+        @association_cache[name] = association
+      end
+
+      module ClassMethods
+        def embedded_in(name, **options)
+          reflection = Embedded::Builder::EmbeddedIn.build(self, name, options)
+          Reflection.add_reflection self, name, reflection
+        end
+
+        def embeds_one(name, **options)
+          reflection = Embedded::Builder::EmbedsOne.build(self, name, options)
+          Reflection.add_reflection self, name, reflection
+        end
+
+        def embeds_many(name, **options)
+          reflection = Embedded::Builder::EmbedsMany.build(self, name, options)
+          Reflection.add_reflection self, name, reflection
+        end
+
+        def association_names
+          @association_names ||=
+            if !abstract_class?
+              reflections.keys.map(&:to_sym)
+            else
+              []
+            end
+        end
+
+        def embedded_association_names
+          @association_names ||=
+            if !abstract_class?
+              reflections.select { |_, r| r.embedded? }.keys.map(&:to_sym)
+            else
+              []
+            end
+        end
+      end
+  end
+end

data/lib/active_entity/associations/embedded/association.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/wrap"
+
+module ActiveEntity
+  module Associations
+    module Embedded
+      # = Active Entity Associations
+      #
+      # This is the root class of all associations ('+ Foo' signifies an included module Foo):
+      #
+      #   Association
+      #     SingularAssociation
+      #       HasOneAssociation + ForeignAssociation
+      #         HasOneThroughAssociation + ThroughAssociation
+      #       BelongsToAssociation
+      #         BelongsToPolymorphicAssociation
+      #     CollectionAssociation
+      #       HasManyAssociation + ForeignAssociation
+      #         HasManyThroughAssociation + ThroughAssociation
+      class Association #:nodoc:
+        attr_reader :owner, :target, :reflection
+
+        delegate :options, to: :reflection
+
+        def initialize(owner, reflection)
+          reflection.check_validity!
+
+          @owner, @reflection = owner, reflection
+
+          @target = nil
+          @inversed = false
+        end
+
+        # Has the \target been already \loaded?
+        def loaded?
+          true
+        end
+
+        # Sets the target of this association to <tt>\target</tt>, and the \loaded flag to +true+.
+        attr_writer :target
+
+        # Set the inverse association, if possible
+        def set_inverse_instance(record)
+          if inverse = inverse_association_for(record)
+            inverse.inversed_from(owner)
+          end
+          record
+        end
+
+        # Remove the inverse association, if possible
+        def remove_inverse_instance(record)
+          if inverse = inverse_association_for(record)
+            inverse.inversed_from(nil)
+          end
+        end
+
+        def inversed_from(record)
+          self.target = record
+          @inversed = !!record
+        end
+
+        # Returns the class of the target. belongs_to polymorphic overrides this to look at the
+        # polymorphic_type field on the owner.
+        def klass
+          reflection.klass
+        end
+
+        def extensions
+          reflection.extensions
+        end
+
+        # We can't dump @reflection and @through_reflection since it contains the scope proc
+        def marshal_dump
+          ivars = (instance_variables - [:@reflection, :@through_reflection]).map { |name| [name, instance_variable_get(name)] }
+          [@reflection.name, ivars]
+        end
+
+        def marshal_load(data)
+          reflection_name, ivars = data
+          ivars.each { |name, val| instance_variable_set(name, val) }
+          @reflection = @owner.class._reflect_on_association(reflection_name)
+        end
+
+        def initialize_attributes(record, attributes = {}) #:nodoc:
+          record.send(:_assign_attributes, attributes) if attributes.any?
+          set_inverse_instance(record)
+        end
+
+        private
+
+          # Raises ActiveEntity::AssociationTypeMismatch unless +record+ is of
+          # the kind of the class of the associated objects. Meant to be used as
+          # a sanity check when you are about to assign an associated record.
+          def raise_on_type_mismatch!(record)
+            unless record.is_a?(reflection.klass)
+              fresh_class = reflection.class_name.safe_constantize
+              unless fresh_class && record.is_a?(fresh_class)
+                message = "#{reflection.class_name}(##{reflection.klass.object_id}) expected, "\
+                  "got #{record.inspect} which is an instance of #{record.class}(##{record.class.object_id})"
+                raise ActiveEntity::AssociationTypeMismatch, message
+              end
+            end
+          end
+
+          def inverse_association_for(record)
+            if invertible_for?(record)
+              record.association(inverse_reflection_for(record).name)
+            end
+          end
+
+          # Can be redefined by subclasses, notably polymorphic belongs_to
+          # The record parameter is necessary to support polymorphic inverses as we must check for
+          # the association in the specific class of the record.
+          def inverse_reflection_for(record)
+            reflection.inverse_of
+          end
+
+          # Returns true if inverse association on the given record needs to be set.
+          # This method is redefined by subclasses.
+          def invertible_for?(record)
+            inverse_reflection_for(record)
+          end
+
+          def build_record(attributes)
+            reflection.build_association(attributes) do |record|
+              initialize_attributes(record, attributes)
+              yield(record) if block_given?
+            end
+          end
+      end
+    end
+  end
+end

data/lib/active_entity/associations/embedded/builder/association.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# This is the parent Association class which defines the variables
+# used by all associations.
+#
+# The hierarchy is defined as follows:
+#  Association
+#    - SingularAssociation
+#      - BelongsToAssociation
+#      - HasOneAssociation
+#    - CollectionAssociation
+#      - HasManyAssociation
+
+module ActiveEntity::Associations::Embedded::Builder # :nodoc:
+  class Association #:nodoc:
+    class << self
+      attr_accessor :extensions
+    end
+    self.extensions = []
+
+    VALID_OPTIONS = [:class_name, :anonymous_class, :validate] # :nodoc:
+
+    def self.build(model, name, options)
+      if model.dangerous_attribute_method?(name)
+        raise ArgumentError, "You tried to define an association named #{name} on the model #{model.name}, but " \
+                             "this will conflict with a method #{name} already defined by Active Entity. " \
+                             "Please choose a different association name."
+      end
+
+      reflection = create_reflection model, name, options
+      define_accessors model, reflection
+      define_callbacks model, reflection
+      define_validations model, reflection
+      reflection
+    end
+
+    def self.create_reflection(model, name, options)
+      raise ArgumentError, "association names must be a Symbol" unless name.kind_of?(Symbol)
+
+      validate_options(options)
+
+      ActiveEntity::Reflection.create(macro, name, nil, options, model)
+    end
+
+    def self.macro
+      raise NotImplementedError
+    end
+
+    def self.valid_options(options)
+      VALID_OPTIONS + Association.extensions.flat_map(&:valid_options)
+    end
+
+    def self.validate_options(options)
+      options.assert_valid_keys(valid_options(options))
+    end
+
+    def self.define_callbacks(model, reflection)
+      Association.extensions.each do |extension|
+        extension.build model, reflection
+      end
+    end
+
+    # Defines the setter and getter methods for the association
+    # class Post < ActiveEntity::Base
+    #   has_many :comments
+    # end
+    #
+    # Post.first.comments and Post.first.comments= methods are defined by this method...
+    def self.define_accessors(model, reflection)
+      mixin = model.generated_association_methods
+      name = reflection.name
+      define_readers(mixin, name)
+      define_writers(mixin, name)
+    end
+
+    def self.define_readers(mixin, name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}
+          association(:#{name}).reader
+        end
+      CODE
+    end
+
+    def self.define_writers(mixin, name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}=(value)
+          association(:#{name}).writer(value)
+        end
+      CODE
+    end
+
+    def self.define_validations(_model, _reflection)
+      # noop
+    end
+
+    def self.valid_dependent_options
+      raise NotImplementedError
+    end
+  end
+end

data/lib/active_entity/associations/embedded/builder/collection_association.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "active_entity/associations"
+
+module ActiveEntity::Associations::Embedded::Builder # :nodoc:
+  class CollectionAssociation < Association #:nodoc:
+    CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
+
+    def self.valid_options(options)
+      super + [:before_add, :after_add, :before_remove, :after_remove, :extend]
+    end
+
+    def self.define_callbacks(model, reflection)
+      super
+      name    = reflection.name
+      options = reflection.options
+      CALLBACKS.each { |callback_name|
+        define_callback(model, callback_name, name, options)
+      }
+    end
+
+    def self.define_extensions(model, name)
+      if block_given?
+        extension_module_name = "#{model.name.demodulize}#{name.to_s.camelize}AssociationExtension"
+        extension = Module.new(&Proc.new)
+        model.module_parent.const_set(extension_module_name, extension)
+      end
+    end
+
+    def self.define_callback(model, callback_name, name, options)
+      full_callback_name = "#{callback_name}_for_#{name}"
+
+      # TODO : why do i need method_defined? I think its because of the inheritance chain
+      model.class_attribute full_callback_name unless model.method_defined?(full_callback_name)
+      callbacks = Array(options[callback_name.to_sym]).map do |callback|
+        case callback
+        when Symbol
+          ->(_method, owner, record) { owner.send(callback, record) }
+        when Proc
+          ->(_method, owner, record) { callback.call(owner, record) }
+        else
+          ->(method, owner, record) { callback.send(method, owner, record) }
+        end
+      end
+      model.send "#{full_callback_name}=", callbacks
+    end
+
+    # Defines the setter and getter methods for the collection_singular_ids.
+    def self.define_readers(mixin, name)
+      super
+
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name.to_s.singularize}_ids
+          association(:#{name}).ids_reader
+        end
+      CODE
+    end
+
+    def self.define_writers(mixin, name)
+      super
+
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name.to_s.singularize}_ids=(ids)
+          association(:#{name}).ids_writer(ids)
+        end
+      CODE
+    end
+  end
+end