ocean-dynamo 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f06f0f651adf9199dd190cedd203390528548a1f
-  data.tar.gz: 1082719f92e830ef6e60658b77048719cfaed6b1
+  metadata.gz: 050bb409c80700917429d0826f6e7f2f57665ff8
+  data.tar.gz: 04dfbcbcf7a927b5616ae070f56ec7d536550689
 SHA512:
-  metadata.gz: 67d5231c8cef81f6b566c4e9a1f630c32dc510289a5fe3d27a05cb2a83a4bf5f31db1df13b16a6369e7482351dbbf87470d4bb8fa859710eae6290d050701ec5
-  data.tar.gz: b529ee10710b85465e3b82668268ed5c78226b83a2a3619f54c213492ebf4d8aa334b0344fefb960548db84e536dd92e8f614da51592a7849405e0f758402ccc
+  metadata.gz: 0158fc7b07d5f594a88efd0499fe0466233a6de48fbc120e760968003c26b4a8c337e81110defb98cf66dd8d9093510056e2b7313696d7ec9035d19c598a50e5
+  data.tar.gz: 1705bacb9d7df7102790ce612b5fc6753b30965094e5ede5300b241251e577e11c01a09f1d509bfd570463feaafb311c50d82b015a6db981be80fe10075b7408

data/README.rdoc

@@ -170,8 +170,8 @@ controllers. OceanDynamo implements much of the infrastructure of ActiveRecord;
 for instance, +read_attribute+, +write_attribute+, and much of the control logic and
 internal organisation.
 
-* +has_many+ can now be nested in multiple layers through the use of +:composite_key+ 
-  in +belongs_to+. See the documentation for +belongs_to+.
+* <tt>belongs_to :thingy now defines <tt>.build_thingy</tt> and <tt>.create_thingy</tt>.
+* Work begun on collection proxies, etc.
 
 === Future milestones
 

data/lib/ocean-dynamo.rb

@@ -14,6 +14,9 @@ require "ocean-dynamo/attributes"
 require "ocean-dynamo/persistence"
 require "ocean-dynamo/queries"
 require "ocean-dynamo/associations/associations"
+require "ocean-dynamo/associations/association"
+require "ocean-dynamo/associations/collection_association"
+require "ocean-dynamo/associations/relation"
 require "ocean-dynamo/associations/belongs_to"
 require "ocean-dynamo/associations/has_many"
 

data/lib/ocean-dynamo/active_record_stuff/association.rb

@@ -0,0 +1,244 @@
+require 'active_support/core_ext/array/wrap'
+
+module ActiveRecord #:nodoc:
+  module Associations #:nodoc:
+    # = Active Record Associations
+    #
+    # This is the root class of all associations ('+ Foo' signifies an included module Foo):
+    #
+    #   Association
+    #     SingularAssociation
+    #       HasOneAssociation
+    #         HasOneThroughAssociation + ThroughAssociation
+    #       BelongsToAssociation
+    #         BelongsToPolymorphicAssociation
+    #     CollectionAssociation
+    #       HasAndBelongsToManyAssociation
+    #       HasManyAssociation
+    #         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
+
+        reset
+        reset_scope
+      end
+
+      # Returns the name of the table of the associated class:
+      #
+      #   post.comments.aliased_table_name # => "comments"
+      #
+      def aliased_table_name
+        klass.table_name
+      end
+
+      # Resets the \loaded flag to +false+ and sets the \target to +nil+.
+      def reset
+        @loaded = false
+        @target = nil
+        @stale_state = nil
+      end
+
+      # Reloads the \target and returns +self+ on success.
+      def reload
+        reset
+        reset_scope
+        load_target
+        self unless target.nil?
+      end
+
+      # Has the \target been already \loaded?
+      def loaded?
+        @loaded
+      end
+
+      # Asserts the \target has been loaded setting the \loaded flag to +true+.
+      def loaded!
+        @loaded      = true
+        @stale_state = stale_state
+      end
+
+      # The target is stale if the target no longer points to the record(s) that the
+      # relevant foreign_key(s) refers to. If stale, the association accessor method
+      # on the owner will reload the target. It's up to subclasses to implement the
+      # stale_state method if relevant.
+      #
+      # Note that if the target has not been loaded, it is not considered stale.
+      def stale_target?
+        loaded? && @stale_state != stale_state
+      end
+
+      # Sets the target of this association to <tt>\target</tt>, and the \loaded flag to +true+.
+      def target=(target)
+        @target = target
+        loaded!
+      end
+
+      def scope
+        target_scope.merge(association_scope)
+      end
+
+      def scoped
+        ActiveSupport::Deprecation.warn "#scoped is deprecated. use #scope instead."
+        scope
+      end
+
+      # The scope for this association.
+      #
+      # Note that the association_scope is merged into the target_scope only when the
+      # scope method is called. This is because at that point the call may be surrounded
+      # by scope.scoping { ... } or with_scope { ... } etc, which affects the scope which
+      # actually gets built.
+      def association_scope
+        if klass
+          @association_scope ||= AssociationScope.new(self).scope
+        end
+      end
+
+      def reset_scope
+        @association_scope = nil
+      end
+
+      # Set the inverse association, if possible
+      def set_inverse_instance(record)
+        if record && invertible_for?(record)
+          inverse = record.association(inverse_reflection_for(record).name)
+          inverse.target = owner
+        end
+      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
+
+      # Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the
+      # through association's scope)
+      def target_scope
+        klass.all
+      end
+
+      # Loads the \target if needed and returns it.
+      #
+      # This method is abstract in the sense that it relies on +find_target+,
+      # which is expected to be provided by descendants.
+      #
+      # If the \target is already \loaded it is just returned. Thus, you can call
+      # +load_target+ unconditionally to get the \target.
+      #
+      # ActiveRecord::RecordNotFound is rescued within the method, and it is
+      # not reraised. The proxy is \reset and +nil+ is the return value.
+      def load_target
+        @target = find_target if (@stale_state && stale_target?) || find_target?
+
+        loaded! unless loaded?
+        target
+      rescue ActiveRecord::RecordNotFound
+        reset
+      end
+
+      def interpolate(sql, record = nil)
+        if sql.respond_to?(:to_proc)
+          owner.instance_exec(record, &sql)
+        else
+          sql
+        end
+      end
+
+      # We can't dump @reflection since it contains the scope proc
+      def marshal_dump
+        ivars = (instance_variables - [:@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
+
+      private
+
+        def find_target?
+          !loaded? && (!owner.new_record? || foreign_key_present?) && klass
+        end
+
+        def creation_attributes
+          attributes = {}
+
+          if (reflection.macro == :has_one || reflection.macro == :has_many) && !options[:through]
+            attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
+
+            if reflection.options[:as]
+              attributes[reflection.type] = owner.class.base_class.name
+            end
+          end
+
+          attributes
+        end
+
+        # Sets the owner attributes on the given record
+        def set_owner_attributes(record)
+          creation_attributes.each { |key, value| record[key] = value }
+        end
+
+        # Should be true if there is a foreign key present on the owner which
+        # references the target. This is used to determine whether we can load
+        # the target if the owner is currently a new record (and therefore
+        # without a key).
+        #
+        # Currently implemented by belongs_to (vanilla and polymorphic) and
+        # has_one/has_many :through associations which go through a belongs_to
+        def foreign_key_present?
+          false
+        end
+
+        # Raises ActiveRecord::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) || record.is_a?(reflection.class_name.constantize)
+            message = "#{reflection.class_name}(##{reflection.klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
+            raise ActiveRecord::AssociationTypeMismatch, message
+          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
+
+        # This should be implemented to return the values of the relevant key(s) on the owner,
+        # so that when stale_state is different from the value stored on the last find_target,
+        # the target is stale.
+        #
+        # This is only relevant to certain associations, which is why it returns nil by default.
+        def stale_state
+        end
+
+        def build_record(attributes)
+          reflection.build_association(attributes) do |record|
+            skip_assign = [reflection.foreign_key, reflection.type].compact
+            attributes = create_scope.except(*(record.changed - skip_assign))
+            record.assign_attributes(attributes)
+            set_inverse_instance(record)
+          end
+        end
+    end
+  end
+end

data/lib/ocean-dynamo/active_record_stuff/collection_association.rb

@@ -0,0 +1,580 @@
+module ActiveRecord #:nodoc:
+  module Associations #:nodoc:
+    # = 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 AssociationProxy.
+    #
+    #   CollectionAssociation:
+    #     HasAndBelongsToManyAssociation => has_and_belongs_to_many
+    #     HasManyAssociation => has_many
+    #       HasManyThroughAssociation + ThroughAssociation => has_many :through
+    #
+    # CollectionAssociation class provides common methods to the collections
+    # defined by +has_and_belongs_to_many+, +has_many+ or +has_many+ with
+    # +: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(force_reload = false)
+        if force_reload
+          klass.uncached { reload }
+        elsif stale_target?
+          reload
+        end
+
+        @proxy ||= CollectionProxy.create(klass, self)
+      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?
+          load_target.map do |record|
+            record.send(reflection.association_primary_key)
+          end
+        else
+          column  = "#{reflection.quoted_table_name}.#{reflection.association_primary_key}"
+          scope.pluck(column)
+        end
+      end
+
+      # Implements the ids writer method, e.g. foo.item_ids= for Foo.has_many :items
+      def ids_writer(ids)
+        pk_column = reflection.primary_key_column
+        ids = Array(ids).reject { |id| id.blank? }
+        ids.map! { |i| pk_column.type_cast(i) }
+        replace(klass.find(ids).index_by { |r| r.id }.values_at(*ids))
+      end
+
+      def reset
+        super
+        @target = []
+      end
+
+      def select(select = nil)
+        if block_given?
+          load_target.select.each { |e| yield e }
+        else
+          scope.select(select)
+        end
+      end
+
+      def find(*args)
+        if block_given?
+          load_target.find(*args) { |*block_args| yield(*block_args) }
+        else
+          if options[:inverse_of] && loaded?
+            args = args.flatten
+            raise RecordNotFound, "Couldn't find #{scope.klass.name} without an ID" if args.blank?
+
+            result = find_by_scan(*args)
+
+            result_size = Array(result).size
+            if !result || result_size != args.size
+              scope.raise_record_not_found_exception!(args, result_size, args.size)
+            else
+              result
+            end
+          else
+            scope.find(*args)
+          end
+        end
+      end
+
+      def first(*args)
+        first_or_last(:first, *args)
+      end
+
+      def last(*args)
+        first_or_last(:last, *args)
+      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
+
+      def create(attributes = {}, &block)
+        create_record(attributes, &block)
+      end
+
+      def create!(attributes = {}, &block)
+        create_record(attributes, true, &block)
+      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)
+        load_target if owner.new_record?
+
+        if owner.new_record?
+          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 default
+      # 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(dependent = nil)
+        if dependent.present? && ![:nullify, :delete_all].include?(dependent)
+          raise ArgumentError, "Valid values are :nullify or :delete_all"
+        end
+
+        dependent = if dependent.present?
+                      dependent
+                    elsif options[:dependent] == :destroy
+                      # since delete_all should not invoke callbacks so use the default deletion strategy
+                      # for :destroy
+                      reflection.is_a?(ActiveRecord::Reflection::ThroughReflection) ? :delete_all : :nullify
+                    else
+                      options[:dependent]
+                    end
+
+        delete(:all, dependent: dependent).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
+
+      # Count all records using SQL.  Construct options and pass them with
+      # scope to the target class's +count+.
+      def count(column_name = nil, count_options = {})
+        column_name, count_options = nil, column_name if column_name.is_a?(Hash)
+
+        relation = scope
+        if association_scope.distinct_value
+          # This is needed because 'SELECT count(DISTINCT *)..' is not valid SQL.
+          column_name ||= reflection.klass.primary_key
+          relation = relation.distinct
+        end
+
+        value = relation.count(column_name)
+
+        limit  = options[:limit]
+        offset = options[:offset]
+
+        if limit || offset
+          [ [value - offset.to_i, 0].max, limit.to_i ].min
+        else
+          value
+        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)
+        _options = records.extract_options!
+        dependent = _options[:dependent] || options[:dependent]
+
+        if records.first == :all
+          if loaded? || dependent == :destroy
+            delete_or_destroy(load_target, dependent)
+          else
+            delete_records(:all, dependent)
+          end
+        else
+          records = find(records) if records.any? { |record| record.kind_of?(Fixnum) || record.kind_of?(String) }
+          delete_or_destroy(records, dependent)
+        end
+      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)
+        records = find(records) if records.any? { |record| record.kind_of?(Fixnum) || 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?
+          if association_scope.distinct_value
+            target.uniq.size
+          else
+            target.size
+          end
+        elsif !loaded? && !association_scope.group_values.empty?
+          load_target.size
+        elsif !loaded? && !association_scope.distinct_value && target.is_a?(Array)
+          unsaved_records = target.select { |r| r.new_record? }
+          unsaved_records.size + count_records
+        else
+          count_records
+        end
+      end
+
+      # Returns the size of the collection calling +size+ on the target.
+      #
+      # If the collection has been already loaded +length+ and +size+ are
+      # equivalent. If not and you are going to need the records anyway this
+      # method will take one less query. Otherwise +size+ is more efficient.
+      def length
+        load_target.size
+      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
+
+      # Returns true if the collections is not empty.
+      # Equivalent to +!collection.empty?+.
+      def any?
+        if block_given?
+          load_target.any? { |*block_args| yield(*block_args) }
+        else
+          !empty?
+        end
+      end
+
+      # Returns true if the collection has more than 1 record.
+      # Equivalent to +collection.size > 1+.
+      def many?
+        if block_given?
+          load_target.many? { |*block_args| yield(*block_args) }
+        else
+          size > 1
+        end
+      end
+
+      def distinct
+        seen = {}
+        load_target.find_all do |record|
+          seen[record.id] = true unless seen.key?(record.id)
+        end
+      end
+      alias uniq distinct
+
+      # 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
+          transaction { replace_records(other_array, original_target) }
+        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)
+          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)
+        callback(:before_add, record) unless skip_callbacks
+        yield(record) if block_given?
+
+        if association_scope.distinct_value && index = @target.index(record)
+          @target[index] = record
+        else
+          @target << record
+        end
+
+        callback(:after_add, record) unless skip_callbacks
+        set_inverse_instance(record)
+
+        record
+      end
+
+      def scope(opts = {})
+        scope = super()
+        scope.none! if opts.fetch(:nullify, true) && null_scope?
+        scope
+      end
+
+      def null_scope?
+        owner.new_record? && !foreign_key_present?
+      end
+
+      private
+
+        def find_target
+          records = scope.to_a
+          records.each { |record| set_inverse_instance(record) }
+          records
+        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.changes.keys).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)
+              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)
+          raise NotImplementedError
+        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 { |r| r.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 concat_records(records)
+          result = true
+
+          records.flatten.each do |record|
+            raise_on_type_mismatch!(record)
+            add_to_target(record) do |rec|
+              result &&= insert_record(rec) unless owner.new_record?
+            end
+          end
+
+          result && records
+        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
+
+        # Should we deal with assoc.first or assoc.last by issuing an independent query to
+        # the database, or by getting the target, and then taking the first/last item from that?
+        #
+        # If the args is just a non-empty options hash, go to the database.
+        #
+        # Otherwise, go to the database only if none of the following are true:
+        #   * target already loaded
+        #   * owner is new record
+        #   * target contains new or changed record(s)
+        #   * the first arg is an integer (which indicates the number of records to be returned)
+        def fetch_first_or_last_using_find?(args)
+          if args.first.is_a?(Hash)
+            true
+          else
+            !(loaded? ||
+              owner.new_record? ||
+              target.any? { |record| record.new_record? || record.changed? } ||
+              args.first.kind_of?(Integer))
+          end
+        end
+
+        def include_in_memory?(record)
+          if reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
+            owner.send(reflection.through_reflection.name).any? { |source|
+              target = source.send(reflection.source_reflection.name)
+              target.respond_to?(:include?) ? target.include?(record) : target == 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{ |arg| arg.to_i }.uniq
+
+          if ids.size == 1
+            id = ids.first
+            record = load_target.detect { |r| id == r.id }
+            expects_array ? [ record ] : record
+          else
+            load_target.select { |r| ids.include?(r.id) }
+          end
+        end
+
+        # Fetches the first/last using SQL if possible, otherwise from the target array.
+        def first_or_last(type, *args)
+          args.shift if args.first.is_a?(Hash) && args.first.empty?
+
+          collection = fetch_first_or_last_using_find?(args) ? scope : load_target
+          collection.send(type, *args).tap do |record|
+            set_inverse_instance record if record.is_a? ActiveRecord::Base
+          end
+        end
+    end
+  end
+end