duck_record 0.0.20 → 0.0.21

data/lib/duck_record/associations/belongs_to_association.rb

@@ -0,0 +1,71 @@
+module DuckRecord
+  # = Active Record Belongs To Association
+  module Associations
+    class BelongsToAssociation < SingularAssociation #:nodoc:
+      def replace(record)
+        if owner.class.readonly_attributes.include?(reflection.foreign_key.to_s)
+          return
+        end
+
+        if record
+          raise_on_type_mismatch!(record)
+          replace_keys(record)
+          @updated = true
+        else
+          remove_keys
+        end
+
+        self.target = record
+      end
+
+      def default(&block)
+        writer(owner.instance_exec(&block)) if reader.nil?
+      end
+
+      def reset
+        super
+        @updated = false
+      end
+
+      def updated?
+        @updated
+      end
+
+      private
+
+        def find_target?
+          !loaded? && foreign_key_present? && klass
+        end
+
+        # Checks whether record is different to the current target, without loading it
+        def different_target?(record)
+          record.id != owner._read_attribute(reflection.foreign_key)
+        end
+
+        def replace_keys(record)
+          owner[reflection.foreign_key] = record._read_attribute(reflection.association_primary_key(record.class))
+        end
+
+        def remove_keys
+          owner[reflection.foreign_key] = nil
+        end
+
+        def foreign_key_present?
+          owner._read_attribute(reflection.foreign_key)
+        end
+
+        def target_id
+          if options[:primary_key]
+            owner.send(reflection.name).try(:id)
+          else
+            owner._read_attribute(reflection.foreign_key)
+          end
+        end
+
+        def stale_state
+          result = owner._read_attribute(reflection.foreign_key) { |n| owner.send(:missing_attribute, n, caller) }
+          result&.to_s
+        end
+    end
+  end
+end

data/lib/duck_record/associations/builder/{embeds_association.rb → association.rb}

@@ -10,15 +10,15 @@
 #      - HasManyAssociation
 
 module DuckRecord::Associations::Builder # :nodoc:
-  class EmbedsAssociation #:nodoc:
+  class Association #:nodoc:
     class << self
       attr_accessor :extensions
     end
     self.extensions = []
 
-    VALID_OPTIONS = [:class_name, :anonymous_class, :validate] # :nodoc:
+    VALID_OPTIONS = [:class_name, :anonymous_class, :foreign_key, :validate] # :nodoc:
 
-    def self.build(model, name, options, &block)
+    def self.build(model, name, scope, options, &block)
       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 Record. " \
@@ -26,19 +26,44 @@ module DuckRecord::Associations::Builder # :nodoc:
       end
 
       extension = define_extensions model, name, &block
-      reflection = create_reflection model, name, options, extension
+      reflection = create_reflection model, name, scope, options, extension
       define_accessors model, reflection
       define_callbacks model, reflection
       define_validations model, reflection
       reflection
     end
 
-    def self.create_reflection(model, name, options, extension = nil)
+    def self.create_reflection(model, name, scope, options, extension = nil)
       raise ArgumentError, "association names must be a Symbol" unless name.kind_of?(Symbol)
 
+      if scope.is_a?(Hash)
+        options = scope
+        scope   = nil
+      end
+
       validate_options(options)
 
-      DuckRecord::Reflection.create(macro, name, options, model)
+      scope = build_scope(scope, extension)
+
+      DuckRecord::Reflection.create(macro, name, scope, options, model)
+    end
+
+    def self.build_scope(scope, extension)
+      new_scope = scope
+
+      if scope && scope.arity == 0
+        new_scope = proc { instance_exec(&scope) }
+      end
+
+      if extension
+        new_scope = wrap_scope new_scope, extension
+      end
+
+      new_scope
+    end
+
+    def self.wrap_scope(scope, _extension)
+      scope
     end
 
     def self.macro
@@ -46,7 +71,7 @@ module DuckRecord::Associations::Builder # :nodoc:
     end
 
     def self.valid_options(options)
-      VALID_OPTIONS + EmbedsAssociation.extensions.flat_map(&:valid_options)
+      VALID_OPTIONS + Association.extensions.flat_map(&:valid_options)
     end
 
     def self.validate_options(options)
@@ -57,7 +82,7 @@ module DuckRecord::Associations::Builder # :nodoc:
     end
 
     def self.define_callbacks(model, reflection)
-      EmbedsAssociation.extensions.each do |extension|
+      Association.extensions.each do |extension|
         extension.build model, reflection
       end
     end
@@ -86,7 +111,10 @@ module DuckRecord::Associations::Builder # :nodoc:
     def self.define_writers(mixin, name)
       mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
         def #{name}=(value)
-          return if self.class.readonly_attributes.include?("#{name}")
+          if self.class.readonly_attributes.include?("#{name}") && attr_readonly_enabled?
+            return
+          end
+
           association(:#{name}).writer(value)
         end
       CODE

data/lib/duck_record/associations/builder/belongs_to.rb

@@ -0,0 +1,44 @@
+module DuckRecord::Associations::Builder # :nodoc:
+  class BelongsTo < SingularAssociation #:nodoc:
+    def self.macro
+      :belongs_to
+    end
+
+    def self.valid_options(_options)
+      super + [:optional, :default]
+    end
+
+    def self.define_callbacks(model, reflection)
+      super
+      add_default_callbacks(model, reflection) if reflection.options[:default]
+    end
+
+    def self.define_accessors(mixin, reflection)
+      super
+    end
+
+    def self.add_default_callbacks(model, reflection)
+      model.before_validation lambda { |o|
+        o.association(reflection.name).default(&reflection.options[:default])
+      }
+    end
+
+    def self.define_validations(model, reflection)
+      if reflection.options.key?(:required)
+        reflection.options[:optional] = !reflection.options.delete(:required)
+      end
+
+      if reflection.options[:optional].nil?
+        required = true
+      else
+        required = !reflection.options[:optional]
+      end
+
+      super
+
+      if required
+        model.validates_presence_of reflection.name, message: :required
+      end
+    end
+  end
+end

data/lib/duck_record/associations/builder/collection_association.rb

@@ -0,0 +1,45 @@
+# This class is inherited by the has_many and has_many_and_belongs_to_many association classes
+module DuckRecord::Associations::Builder # :nodoc:
+  class CollectionAssociation < Association #:nodoc:
+    CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
+
+    def self.valid_options(_options)
+      super + [:index_errors] + CALLBACKS
+    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.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
+  end
+end

data/lib/duck_record/associations/builder/embeds_many.rb

@@ -1,52 +1,9 @@
 # This class is inherited by the has_many and has_many_and_belongs_to_many association classes
 
-require "duck_record/associations"
-
 module DuckRecord::Associations::Builder # :nodoc:
-  class EmbedsMany < EmbedsAssociation #:nodoc:
-    CALLBACKS = [:before_add, :after_add]
-
+  class EmbedsMany < CollectionAssociation #:nodoc:
     def self.macro
       :embeds_many
     end
-
-    def self.valid_options(options)
-      super + CALLBACKS
-    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.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
   end
 end

data/lib/duck_record/associations/builder/embeds_one.rb

@@ -1,34 +1,9 @@
 # This class is inherited by the has_one and belongs_to association classes
 
 module DuckRecord::Associations::Builder # :nodoc:
-  class EmbedsOne < EmbedsAssociation #:nodoc:
+  class EmbedsOne < SingularAssociation #:nodoc:
     def self.macro
       :embeds_one
     end
-
-    def self.define_validations(model, reflection)
-      super
-
-      if reflection.options[:required]
-        model.validates_presence_of reflection.name, message: :required
-      end
-    end
-
-    def self.define_accessors(model, reflection)
-      super
-      mixin = model.generated_association_methods
-      name = reflection.name
-
-      define_constructors(mixin, name) if reflection.constructable?
-    end
-
-    # Defines the (build|create)_association methods for belongs_to or has_one association
-    def self.define_constructors(mixin, name)
-      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
-        def build_#{name}(*args, &block)
-          association(:#{name}).build(*args, &block)
-        end
-      CODE
-    end
   end
 end

data/lib/duck_record/associations/builder/has_many.rb

@@ -0,0 +1,11 @@
+module DuckRecord::Associations::Builder # :nodoc:
+  class HasMany < CollectionAssociation #:nodoc:
+    def self.macro
+      :has_many
+    end
+
+    def self.valid_options(_options)
+      super + [:primary_key, :through, :source, :source_type, :join_table, :foreign_type, :index_errors]
+    end
+  end
+end

data/lib/duck_record/associations/builder/has_one.rb

@@ -0,0 +1,20 @@
+module DuckRecord::Associations::Builder # :nodoc:
+  class HasOne < SingularAssociation #:nodoc:
+    def self.macro
+      :has_one
+    end
+
+    def self.valid_options(options)
+      valid = super
+      valid += [:through, :source, :source_type] if options[:through]
+      valid
+    end
+
+    def self.define_validations(model, reflection)
+      super
+      if reflection.options[:required]
+        model.validates_presence_of reflection.name, message: :required
+      end
+    end
+  end
+end

data/lib/duck_record/associations/builder/singular_association.rb

@@ -0,0 +1,33 @@
+# This class is inherited by the has_one and belongs_to association classes
+module DuckRecord::Associations::Builder # :nodoc:
+  class SingularAssociation < Association #:nodoc:
+    def self.valid_options(options)
+      super + [:primary_key, :required]
+    end
+
+    def self.define_validations(model, reflection)
+      super
+
+      if reflection.options[:required]
+        model.validates_presence_of reflection.name, message: :required
+      end
+    end
+
+    def self.define_accessors(model, reflection)
+      super
+      mixin = model.generated_association_methods
+      name = reflection.name
+
+      define_constructors(mixin, name) if reflection.constructable?
+    end
+
+    # Defines the (build|create)_association methods for belongs_to or has_one association
+    def self.define_constructors(mixin, name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def build_#{name}(*args, &block)
+          association(:#{name}).build(*args, &block)
+        end
+      CODE
+    end
+  end
+end

data/lib/duck_record/associations/collection_association.rb

@@ -0,0 +1,476 @@
+module DuckRecord
+  module Associations
+    # = Active Record Association Collection
+    #
+    # CollectionAssociation is an abstract class that provides common stuff to
+    # ease the implementation of association proxies that represent
+    # collections. See the class hierarchy in Association.
+    #
+    #   CollectionAssociation:
+    #     HasManyAssociation => has_many
+    #       HasManyThroughAssociation + ThroughAssociation => has_many :through
+    #
+    # The CollectionAssociation class provides common methods to the collections
+    # defined by +has_and_belongs_to_many+, +has_many+ or +has_many+ with
+    # the +:through association+ option.
+    #
+    # You need to be careful with assumptions regarding the target: The proxy
+    # does not fetch records from the database until it needs them, but new
+    # ones created with +build+ are added to the target. So, the target may be
+    # non-empty and still lack children waiting to be read from the database.
+    # If you look directly to the database you cannot assume that's the entire
+    # collection because new records may have been added to the target, etc.
+    #
+    # If you need to work on all current children, new and existing records,
+    # +load_target+ and the +loaded+ flag are your friends.
+    class CollectionAssociation < Association #:nodoc:
+      # Implements the reader method, e.g. foo.items for Foo.has_many :items
+      def reader
+        if stale_target?
+          reload
+        end
+
+        @proxy ||= CollectionProxy.new(klass, self)
+        @proxy.reset_scope
+      end
+
+      # Implements the writer method, e.g. foo.items= for Foo.has_many :items
+      def writer(records)
+        replace(records)
+      end
+
+      # Implements the ids reader method, e.g. foo.item_ids for Foo.has_many :items
+      def ids_reader
+        if loaded?
+          target.pluck(reflection.association_primary_key)
+        else
+          @association_ids ||= scope.pluck(reflection.association_primary_key)
+        end
+      end
+
+      # Implements the ids writer method, e.g. foo.item_ids= for Foo.has_many :items
+      def ids_writer(ids)
+        pk_type = reflection.association_primary_key_type
+        ids = Array(ids).reject(&:blank?)
+        ids.map! { |i| pk_type.cast(i) }
+
+        primary_key = reflection.association_primary_key
+        records = klass.where(primary_key => ids).index_by do |r|
+          r.public_send(primary_key)
+        end.values_at(*ids).compact
+
+        if records.size != ids.size
+          klass.all.raise_record_not_found_exception!(ids, records.size, ids.size, primary_key)
+        else
+          replace(records)
+        end
+      end
+
+      def reset
+        super
+        @target = []
+      end
+
+      def find(*args)
+        if block_given?
+          load_target.find(*args) { |*block_args| yield(*block_args) }
+        else
+          scope.find(*args)
+        end
+      end
+
+      def build(attributes = {}, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| build(attr, &block) }
+        else
+          add_to_target(build_record(attributes)) do |record|
+            yield(record) if block_given?
+          end
+        end
+      end
+
+      # Add +records+ to this association. Returns +self+ so method calls may
+      # be chained. Since << flattens its argument list and inserts each record,
+      # +push+ and +concat+ behave identically.
+      def concat(*records)
+        records = records.flatten
+        if owner.new_record?
+          load_target
+          concat_records(records)
+        else
+          transaction { concat_records(records) }
+        end
+      end
+
+      # Starts a transaction in the association class's database connection.
+      #
+      #   class Author < ActiveRecord::Base
+      #     has_many :books
+      #   end
+      #
+      #   Author.first.books.transaction do
+      #     # same effect as calling Book.transaction
+      #   end
+      def transaction(*args)
+        reflection.klass.transaction(*args) do
+          yield
+        end
+      end
+
+      # Removes all records from the association without calling callbacks
+      # on the associated records. It honors the +:dependent+ option. However
+      # if the +:dependent+ value is +:destroy+ then in that case the +:delete_all+
+      # deletion strategy for the association is applied.
+      #
+      # You can force a particular deletion strategy by passing a parameter.
+      #
+      # Example:
+      #
+      # @author.books.delete_all(:nullify)
+      # @author.books.delete_all(:delete_all)
+      #
+      # See delete for more info.
+      def delete_all
+        delete_or_nullify_all_records(:delete_all).tap do
+          reset
+          loaded!
+        end
+      end
+
+      # Destroy all the records from this association.
+      #
+      # See destroy for more info.
+      def destroy_all
+        destroy(load_target).tap do
+          reset
+          loaded!
+        end
+      end
+
+      # Removes +records+ from this association calling +before_remove+ and
+      # +after_remove+ callbacks.
+      #
+      # This method is abstract in the sense that +delete_records+ has to be
+      # provided by descendants. Note this method does not imply the records
+      # are actually removed from the database, that depends precisely on
+      # +delete_records+. They are in any case removed from the collection.
+      def delete(*records)
+        return if records.empty?
+        records = find(records) if records.any? { |record| record.kind_of?(Integer) || record.kind_of?(String) }
+        delete_or_destroy(records, options[:dependent])
+      end
+
+      # Deletes the +records+ and removes them from this association calling
+      # +before_remove+ , +after_remove+ , +before_destroy+ and +after_destroy+ callbacks.
+      #
+      # Note that this method removes records from the database ignoring the
+      # +:dependent+ option.
+      def destroy(*records)
+        return if records.empty?
+        records = find(records) if records.any? { |record| record.kind_of?(Integer) || record.kind_of?(String) }
+        delete_or_destroy(records, :destroy)
+      end
+
+      # Returns the size of the collection by executing a SELECT COUNT(*)
+      # query if the collection hasn't been loaded, and calling
+      # <tt>collection.size</tt> if it has.
+      #
+      # If the collection has been already loaded +size+ and +length+ are
+      # equivalent. If not and you are going to need the records anyway
+      # +length+ will take one less query. Otherwise +size+ is more efficient.
+      #
+      # This method is abstract in the sense that it relies on
+      # +count_records+, which is a method descendants have to provide.
+      def size
+        if !find_target? || loaded?
+          target.size
+        elsif !association_scope.group_values.empty?
+          load_target.size
+        elsif !association_scope.distinct_value && target.is_a?(Array)
+          unsaved_records = target.select(&:new_record?)
+          unsaved_records.size + count_records
+        else
+          count_records
+        end
+      end
+
+      # Returns true if the collection is empty.
+      #
+      # If the collection has been loaded
+      # it is equivalent to <tt>collection.size.zero?</tt>. If the
+      # collection has not been loaded, it is equivalent to
+      # <tt>collection.exists?</tt>. If the collection has not already been
+      # loaded and you are going to fetch the records anyway it is better to
+      # check <tt>collection.length.zero?</tt>.
+      def empty?
+        if loaded?
+          size.zero?
+        else
+          @target.blank? && !scope.exists?
+        end
+      end
+
+      # Replace this collection with +other_array+. This will perform a diff
+      # and delete/add only records that have changed.
+      def replace(other_array)
+        other_array.each { |val| raise_on_type_mismatch!(val) }
+        original_target = load_target.dup
+
+        if owner.new_record?
+          replace_records(other_array, original_target)
+        else
+          replace_common_records_in_memory(other_array, original_target)
+          if other_array != original_target
+            transaction { replace_records(other_array, original_target) }
+          else
+            other_array
+          end
+        end
+      end
+
+      def include?(record)
+        if record.is_a?(reflection.klass)
+          if record.new_record?
+            include_in_memory?(record)
+          else
+            loaded? ? target.include?(record) : scope.exists?(record.id)
+          end
+        else
+          false
+        end
+      end
+
+      def load_target
+        if find_target?
+          @target = merge_target_lists(find_target, target)
+        end
+
+        loaded!
+        target
+      end
+
+      def add_to_target(record, skip_callbacks = false, &block)
+        if association_scope.distinct_value
+          index = @target.index(record)
+        end
+        replace_on_target(record, index, skip_callbacks, &block)
+      end
+
+      def scope
+        scope = super
+        scope.none! if null_scope?
+        scope
+      end
+
+      def null_scope?
+        owner.new_record? && !foreign_key_present?
+      end
+
+      def find_from_target?
+        loaded? ||
+          owner.new_record? ||
+          target.any? { |record| record.new_record? || record.changed? }
+      end
+
+      private
+
+        def find_target
+          return scope.to_a if skip_statement_cache?
+
+          conn = klass.connection
+          sc = reflection.association_scope_cache(conn, owner) do
+            ActiveRecord::StatementCache.create(conn) { |params|
+              as = ActiveRecord::Associations::AssociationScope.create { params.bind }
+              target_scope.merge as.scope(self, conn)
+            }
+          end
+
+          binds = ActiveRecord::Associations::AssociationScope.get_bind_values(owner, reflection.chain)
+          sc.execute(binds, klass, conn) do |record|
+            set_inverse_instance(record)
+          end
+        end
+
+        # We have some records loaded from the database (persisted) and some that are
+        # in-memory (memory). The same record may be represented in the persisted array
+        # and in the memory array.
+        #
+        # So the task of this method is to merge them according to the following rules:
+        #
+        #   * The final array must not have duplicates
+        #   * The order of the persisted array is to be preserved
+        #   * Any changes made to attributes on objects in the memory array are to be preserved
+        #   * Otherwise, attributes should have the value found in the database
+        def merge_target_lists(persisted, memory)
+          return persisted if memory.empty?
+          return memory    if persisted.empty?
+
+          persisted.map! do |record|
+            if mem_record = memory.delete(record)
+
+              ((record.attribute_names & mem_record.attribute_names) - mem_record.changed_attribute_names_to_save).each do |name|
+                mem_record[name] = record[name]
+              end
+
+              mem_record
+            else
+              record
+            end
+          end
+
+          persisted + memory
+        end
+
+        def _create_record(attributes, raise = false, &block)
+          unless owner.persisted?
+            raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
+          end
+
+          if attributes.is_a?(Array)
+            attributes.collect { |attr| _create_record(attr, raise, &block) }
+          else
+            transaction do
+              add_to_target(build_record(attributes)) do |record|
+                yield(record) if block_given?
+                insert_record(record, true, raise) { @_was_loaded = loaded? }
+              end
+            end
+          end
+        end
+
+        # Do the relevant stuff to insert the given record into the association collection.
+        def insert_record(record, validate = true, raise = false, &block)
+          if raise
+            record.save!(validate: validate, &block)
+          else
+            record.save(validate: validate, &block)
+          end
+        end
+
+        def create_scope
+          scope.scope_for_create.stringify_keys
+        end
+
+        def delete_or_destroy(records, method)
+          records = records.flatten
+          records.each { |record| raise_on_type_mismatch!(record) }
+          existing_records = records.reject(&:new_record?)
+
+          if existing_records.empty?
+            remove_records(existing_records, records, method)
+          else
+            transaction { remove_records(existing_records, records, method) }
+          end
+        end
+
+        def remove_records(existing_records, records, method)
+          records.each { |record| callback(:before_remove, record) }
+
+          delete_records(existing_records, method) if existing_records.any?
+          records.each { |record| target.delete(record) }
+
+          records.each { |record| callback(:after_remove, record) }
+        end
+
+        # Delete the given records from the association,
+        # using one of the methods +:destroy+, +:delete_all+
+        # or +:nullify+ (or +nil+, in which case a default is used).
+        def delete_records(records, method)
+          raise NotImplementedError
+        end
+
+        def replace_records(new_target, original_target)
+          delete(target - new_target)
+
+          unless concat(new_target - target)
+            @target = original_target
+            raise RecordNotSaved, "Failed to replace #{reflection.name} because one or more of the " \
+                                  "new records could not be saved."
+          end
+
+          target
+        end
+
+        def replace_common_records_in_memory(new_target, original_target)
+          common_records = new_target & original_target
+          common_records.each do |record|
+            skip_callbacks = true
+            replace_on_target(record, @target.index(record), skip_callbacks)
+          end
+        end
+
+        def concat_records(records, raise = false)
+          result = true
+
+          records.each do |record|
+            raise_on_type_mismatch!(record)
+            add_to_target(record) do
+              result &&= insert_record(record, true, raise) { @_was_loaded = loaded? } unless owner.new_record?
+            end
+          end
+
+          result && records
+        end
+
+        def replace_on_target(record, index, skip_callbacks)
+          callback(:before_add, record) unless skip_callbacks
+
+          set_inverse_instance(record)
+
+          @_was_loaded = true
+
+          yield(record) if block_given?
+
+          if index
+            target[index] = record
+          elsif @_was_loaded || !loaded?
+            target << record
+          end
+
+          callback(:after_add, record) unless skip_callbacks
+
+          record
+        ensure
+          @_was_loaded = nil
+        end
+
+        def callback(method, record)
+          callbacks_for(method).each do |callback|
+            callback.call(method, owner, record)
+          end
+        end
+
+        def callbacks_for(callback_name)
+          full_callback_name = "#{callback_name}_for_#{reflection.name}"
+          owner.class.send(full_callback_name)
+        end
+
+        def include_in_memory?(record)
+          if reflection.is_a?(DuckRecord::Reflection::ThroughReflection)
+            assoc = owner.association(reflection.through_reflection.name)
+            assoc.reader.any? { |source|
+              target_reflection = source.send(reflection.source_reflection.name)
+              target_reflection.respond_to?(:include?) ? target_reflection.include?(record) : target_reflection == record
+            } || target.include?(record)
+          else
+            target.include?(record)
+          end
+        end
+
+        # If the :inverse_of option has been
+        # specified, then #find scans the entire collection.
+        def find_by_scan(*args)
+          expects_array = args.first.kind_of?(Array)
+          ids           = args.flatten.compact.map(&:to_s).uniq
+
+          if ids.size == 1
+            id = ids.first
+            record = load_target.detect { |r| id == r.id.to_s }
+            expects_array ? [ record ] : record
+          else
+            load_target.select { |r| ids.include?(r.id.to_s) }
+          end
+        end
+    end
+  end
+end