activerecord 3.0.20 → 3.1.0.beta1

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: 018450ec0bab2ac9c4463b87ba81b71a1f8e3c50
-  data.tar.gz: 114e389d25b5a17e40a687fb7dc91a03098ed6d3
-SHA512:
-  metadata.gz: 33533a3b4ff77a3493e70dfec8e87c53ebbbaaca4a7ac38b7d6fa35c2888a49c2071bc96dc0cdba5194d6b3ee771ed4143bc034c85ccd6ad7b6d494e33991092
-  data.tar.gz: 793f4d22187c8bb59daa512a235f22ececc0caf11171c0012c2d21d9e2de7b9a7ae714ac5715caadc89dab1c63eeea128ca71c336a3931d60d21a87c0040d671

data/lib/active_record/association_preload.rb

@@ -1,431 +0,0 @@
-require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/enumerable'
-
-module ActiveRecord
-  # See ActiveRecord::AssociationPreload::ClassMethods for documentation.
-  module AssociationPreload #:nodoc:
-    extend ActiveSupport::Concern
-
-    # Implements the details of eager loading of Active Record associations.
-    # Application developers should not use this module directly.
-    #
-    # <tt>ActiveRecord::Base</tt> is extended with this module. The source code in
-    # <tt>ActiveRecord::Base</tt> references methods defined in this module.
-    #
-    # Note that 'eager loading' and 'preloading' are actually the same thing.
-    # However, there are two different eager loading strategies.
-    #
-    # The first one is by using table joins. This was only strategy available
-    # prior to Rails 2.1. Suppose that you have an Author model with columns
-    # 'name' and 'age', and a Book model with columns 'name' and 'sales'. Using
-    # this strategy, Active Record would try to retrieve all data for an author
-    # and all of its books via a single query:
-    #
-    #   SELECT * FROM authors
-    #   LEFT OUTER JOIN books ON authors.id = books.id
-    #   WHERE authors.name = 'Ken Akamatsu'
-    #
-    # However, this could result in many rows that contain redundant data. After
-    # having received the first row, we already have enough data to instantiate
-    # the Author object. In all subsequent rows, only the data for the joined
-    # 'books' table is useful; the joined 'authors' data is just redundant, and
-    # processing this redundant data takes memory and CPU time. The problem
-    # quickly becomes worse and worse as the level of eager loading increases
-    # (i.e. if Active Record is to eager load the associations' associations as
-    # well).
-    #
-    # The second strategy is to use multiple database queries, one for each
-    # level of association. Since Rails 2.1, this is the default strategy. In
-    # situations where a table join is necessary (e.g. when the +:conditions+
-    # option references an association's column), it will fallback to the table
-    # join strategy.
-    #
-    # See also ActiveRecord::Associations::ClassMethods, which explains eager
-    # loading in a more high-level (application developer-friendly) manner.
-    module ClassMethods
-      protected
-
-      # Eager loads the named associations for the given Active Record record(s).
-      #
-      # In this description, 'association name' shall refer to the name passed
-      # to an association creation method. For example, a model that specifies
-      # <tt>belongs_to :author</tt>, <tt>has_many :buyers</tt> has association
-      # names +:author+ and +:buyers+.
-      #
-      # == Parameters
-      # +records+ is an array of ActiveRecord::Base. This array needs not be flat,
-      # i.e. +records+ itself may also contain arrays of records. In any case,
-      # +preload_associations+ will preload the all associations records by
-      # flattening +records+.
-      #
-      # +associations+ specifies one or more associations that you want to
-      # preload. It may be:
-      # - a Symbol or a String which specifies a single association name. For
-      #   example, specifying +:books+ allows this method to preload all books
-      #   for an Author.
-      # - an Array which specifies multiple association names. This array
-      #   is processed recursively. For example, specifying <tt>[:avatar, :books]</tt>
-      #   allows this method to preload an author's avatar as well as all of his
-      #   books.
-      # - a Hash which specifies multiple association names, as well as
-      #   association names for the to-be-preloaded association objects. For
-      #   example, specifying <tt>{ :author => :avatar }</tt> will preload a
-      #   book's author, as well as that author's avatar.
-      #
-      # +:associations+ has the same format as the +:include+ option for
-      # <tt>ActiveRecord::Base.find</tt>. So +associations+ could look like this:
-      #
-      #   :books
-      #   [ :books, :author ]
-      #   { :author => :avatar }
-      #   [ :books, { :author => :avatar } ]
-      #
-      # +preload_options+ contains options that will be passed to ActiveRecord::Base#find
-      # (which is called under the hood for preloading records). But it is passed
-      # only one level deep in the +associations+ argument, i.e. it's not passed
-      # to the child associations when +associations+ is a Hash.
-      def preload_associations(records, associations, preload_options={})
-        records = Array.wrap(records).compact
-        return if records.empty?
-        case associations
-        when Array then associations.each {|association| preload_associations(records, association, preload_options)}
-        when Symbol, String then preload_one_association(records, associations.to_sym, preload_options)
-        when Hash then
-          associations.each do |parent, child|
-            raise "parent must be an association name" unless parent.is_a?(String) || parent.is_a?(Symbol)
-            preload_associations(records, parent, preload_options)
-            reflection = reflections[parent]
-            parents = records.sum { |record| Array.wrap(record.send(reflection.name)) }
-            unless parents.empty?
-              parents = parents.uniq if reflection.macro == :belongs_to
-              parents.first.class.preload_associations(parents, child)
-            end
-          end
-        end
-      end
-
-      private
-
-      # Preloads a specific named association for the given records. This is
-      # called by +preload_associations+ as its base case.
-      def preload_one_association(records, association, preload_options={})
-        class_to_reflection = {}
-        # Not all records have the same class, so group then preload
-        # group on the reflection itself so that if various subclass share the same association then
-        # we do not split them unnecessarily
-        records.group_by { |record| class_to_reflection[record.class] ||= record.class.reflections[association]}.each do |reflection, _records|
-          raise ConfigurationError, "Association named '#{ association }' was not found; perhaps you misspelled it?" unless reflection
-
-          # 'reflection.macro' can return 'belongs_to', 'has_many', etc. Thus,
-          # the following could call 'preload_belongs_to_association',
-          # 'preload_has_many_association', etc.
-          send("preload_#{reflection.macro}_association", _records, reflection, preload_options)
-        end
-      end
-
-      def add_preloaded_records_to_collection(parent_records, reflection_name, associated_record)
-        parent_records.each do |parent_record|
-          association_proxy = parent_record.send(reflection_name)
-          association_proxy.loaded
-          association_proxy.target.push(*Array.wrap(associated_record))
-
-          association_proxy.__send__(:set_inverse_instance, associated_record, parent_record)
-        end
-      end
-
-      def add_preloaded_record_to_collection(parent_records, reflection_name, associated_record)
-        parent_records.each do |parent_record|
-          parent_record.send("set_#{reflection_name}_target", associated_record)
-        end
-      end
-
-      def set_association_collection_records(id_to_record_map, reflection_name, associated_records, key)
-        associated_records.each do |associated_record|
-          mapped_records = id_to_record_map[associated_record[key].to_s]
-          add_preloaded_records_to_collection(mapped_records, reflection_name, associated_record)
-        end
-      end
-
-      def set_association_single_records(id_to_record_map, reflection_name, associated_records, key)
-        seen_keys = {}
-        associated_records.each do |associated_record|
-          #this is a has_one or belongs_to: there should only be one record.
-          #Unfortunately we can't (in portable way) ask the database for
-          #'all records where foo_id in (x,y,z), but please
-          # only one row per distinct foo_id' so this where we enforce that
-          next if seen_keys[associated_record[key].to_s]
-          seen_keys[associated_record[key].to_s] = true
-          mapped_records = id_to_record_map[associated_record[key].to_s]
-          mapped_records.each do |mapped_record|
-            association_proxy = mapped_record.send("set_#{reflection_name}_target", associated_record)
-            association_proxy.__send__(:set_inverse_instance, associated_record, mapped_record)
-          end
-        end
-
-        id_to_record_map.each do |id, records|
-          next if seen_keys.include?(id.to_s)
-          records.each {|record| record.send("set_#{reflection_name}_target", nil) }
-        end
-      end
-
-      # Given a collection of Active Record objects, constructs a Hash which maps
-      # the objects' IDs to the relevant objects. Returns a 2-tuple
-      # <tt>(id_to_record_map, ids)</tt> where +id_to_record_map+ is the Hash,
-      # and +ids+ is an Array of record IDs.
-      def construct_id_map(records, primary_key=nil)
-        id_to_record_map = {}
-        ids = []
-        records.each do |record|
-          primary_key ||= record.class.primary_key
-          ids << record[primary_key]
-          mapped_records = (id_to_record_map[ids.last.to_s] ||= [])
-          mapped_records << record
-        end
-        ids.uniq!
-        return id_to_record_map, ids
-      end
-
-      def preload_has_and_belongs_to_many_association(records, reflection, preload_options={})
-        table_name = reflection.klass.quoted_table_name
-        id_to_record_map, ids = construct_id_map(records)
-        records.each {|record| record.send(reflection.name).loaded}
-        options = reflection.options
-
-        conditions = "t0.#{reflection.primary_key_name} #{in_or_equals_for_ids(ids)}"
-        conditions << append_conditions(reflection, preload_options)
-
-        associated_records_proxy = reflection.klass.unscoped.
-            includes(options[:include]).
-            joins("INNER JOIN #{connection.quote_table_name options[:join_table]} t0 ON #{reflection.klass.quoted_table_name}.#{reflection.klass.primary_key} = t0.#{reflection.association_foreign_key}").
-            select("#{options[:select] || table_name+'.*'}, t0.#{reflection.primary_key_name} as the_parent_record_id").
-            order(options[:order])
-
-        all_associated_records = associated_records(ids) do |some_ids|
-          associated_records_proxy.where([conditions, ids]).to_a
-        end
-
-        set_association_collection_records(id_to_record_map, reflection.name, all_associated_records, 'the_parent_record_id')
-      end
-
-      def preload_has_one_association(records, reflection, preload_options={})
-        return if records.first.send("loaded_#{reflection.name}?")
-        id_to_record_map, ids = construct_id_map(records, reflection.options[:primary_key])
-        options = reflection.options
-        records.each {|record| record.send("set_#{reflection.name}_target", nil)}
-        if options[:through]
-          through_records = preload_through_records(records, reflection, options[:through])
-          through_reflection = reflections[options[:through]]
-          through_primary_key = through_reflection.primary_key_name
-          unless through_records.empty?
-            source = reflection.source_reflection.name
-            through_records.first.class.preload_associations(through_records, source)
-            if through_reflection.macro == :belongs_to
-              rev_id_to_record_map, rev_ids = construct_id_map(records, through_primary_key)
-              rev_primary_key = through_reflection.klass.primary_key
-              through_records.each do |through_record|
-                add_preloaded_record_to_collection(rev_id_to_record_map[through_record[rev_primary_key].to_s],
-                                                   reflection.name, through_record.send(source))
-              end
-            else
-              through_records.each do |through_record|
-                add_preloaded_record_to_collection(id_to_record_map[through_record[through_primary_key].to_s],
-                                                   reflection.name, through_record.send(source))
-              end
-            end
-          end
-        else
-          set_association_single_records(id_to_record_map, reflection.name, find_associated_records(ids, reflection, preload_options), reflection.primary_key_name)
-        end
-      end
-
-      def preload_has_many_association(records, reflection, preload_options={})
-        return if records.first.send(reflection.name).loaded?
-        options = reflection.options
-
-        primary_key_name = reflection.through_reflection_primary_key_name
-        id_to_record_map, ids = construct_id_map(records, primary_key_name || reflection.options[:primary_key])
-        records.each {|record| record.send(reflection.name).loaded}
-
-        if options[:through]
-          through_records = preload_through_records(records, reflection, options[:through])
-          through_reflection = reflections[options[:through]]
-          unless through_records.empty?
-            source = reflection.source_reflection.name
-            through_records.first.class.preload_associations(through_records, source, options)
-            through_records.each do |through_record|
-              through_record_id = through_record[reflection.through_reflection_primary_key].to_s
-              add_preloaded_records_to_collection(id_to_record_map[through_record_id], reflection.name, through_record.send(source))
-            end
-          end
-
-        else
-          set_association_collection_records(id_to_record_map, reflection.name, find_associated_records(ids, reflection, preload_options),
-                                             reflection.primary_key_name)
-        end
-      end
-
-      def preload_through_records(records, reflection, through_association)
-        through_reflection = reflections[through_association]
-        through_primary_key = through_reflection.primary_key_name
-
-        through_records = []
-        if reflection.options[:source_type]
-          interface = reflection.source_reflection.options[:foreign_type]
-          preload_options = {:conditions => ["#{connection.quote_column_name interface} = ?", reflection.options[:source_type]]}
-
-          records.compact!
-          records.first.class.preload_associations(records, through_association, preload_options)
-
-          # Dont cache the association - we would only be caching a subset
-          records.each do |record|
-            proxy = record.send(through_association)
-
-            if proxy.respond_to?(:target)
-              through_records.concat Array.wrap(proxy.target)
-              proxy.reset
-            else # this is a has_one :through reflection
-              through_records << proxy if proxy
-            end
-          end
-        else
-          options = {}
-          options[:include] = reflection.options[:include] || reflection.options[:source] if reflection.options[:conditions] || reflection.options[:order]
-          options[:order] = reflection.options[:order]
-          options[:conditions] = reflection.options[:conditions]
-          records.first.class.preload_associations(records, through_association, options)
-
-          records.each do |record|
-            through_records.concat Array.wrap(record.send(through_association))
-          end
-        end
-        through_records
-      end
-
-      def preload_belongs_to_association(records, reflection, preload_options={})
-        return if records.first.send("loaded_#{reflection.name}?")
-        options = reflection.options
-        primary_key_name = reflection.primary_key_name
-
-        if options[:polymorphic]
-          polymorph_type = options[:foreign_type]
-          klasses_and_ids = {}
-
-          # Construct a mapping from klass to a list of ids to load and a mapping of those ids back
-          # to their parent_records
-          records.each do |record|
-            if klass = record.send(polymorph_type)
-              klass_id = record.send(primary_key_name)
-              if klass_id
-                id_map = klasses_and_ids[klass] ||= {}
-                id_list_for_klass_id = (id_map[klass_id.to_s] ||= [])
-                id_list_for_klass_id << record
-              end
-            end
-          end
-          klasses_and_ids = klasses_and_ids.to_a
-        else
-          id_map = {}
-          records.each do |record|
-            key = record.send(primary_key_name)
-            if key
-              mapped_records = (id_map[key.to_s] ||= [])
-              mapped_records << record
-            end
-          end
-          klasses_and_ids = [[reflection.klass.name, id_map]]
-        end
-
-        klasses_and_ids.each do |klass_and_id|
-          klass_name, id_map = *klass_and_id
-          next if id_map.empty?
-          klass = klass_name.constantize
-
-          table_name = klass.quoted_table_name
-          primary_key = (reflection.options[:primary_key] || klass.primary_key).to_s
-          column_type = klass.columns.detect{|c| c.name == primary_key}.type
-          ids = id_map.keys.map do |id|
-            if column_type == :integer
-              id.to_i
-            elsif column_type == :float
-              id.to_f
-            else
-              id
-            end
-          end
-
-          conditions = "#{table_name}.#{connection.quote_column_name(primary_key)} #{in_or_equals_for_ids(ids)}"
-          conditions << append_conditions(reflection, preload_options)
-
-          associated_records = klass.unscoped.where([conditions, ids]).apply_finder_options(options.slice(:include, :select, :joins, :order)).to_a
-
-          set_association_single_records(id_map, reflection.name, associated_records, primary_key)
-        end
-      end
-
-      def find_associated_records(ids, reflection, preload_options)
-        options = reflection.options
-        table_name = reflection.klass.quoted_table_name
-
-        if interface = reflection.options[:as]
-          conditions = "#{reflection.klass.quoted_table_name}.#{connection.quote_column_name "#{interface}_id"} #{in_or_equals_for_ids(ids)} and #{reflection.klass.quoted_table_name}.#{connection.quote_column_name "#{interface}_type"} = '#{self.base_class.sti_name}'"
-        else
-          foreign_key = reflection.primary_key_name
-          conditions = "#{reflection.klass.quoted_table_name}.#{foreign_key} #{in_or_equals_for_ids(ids)}"
-        end
-
-        conditions << append_conditions(reflection, preload_options)
-
-        find_options = {
-          :select => preload_options[:select] || options[:select] || Arel::SqlLiteral.new("#{table_name}.*"),
-          :include => preload_options[:include] || options[:include],
-          :joins => options[:joins],
-          :group => preload_options[:group] || options[:group],
-          :order => preload_options[:order] || options[:order]
-        }
-
-        associated_records(ids) do |some_ids|
-          reflection.klass.scoped.apply_finder_options(find_options.merge(:conditions => [conditions, some_ids])).to_a
-        end
-      end
-
-      def process_conditions_for_preload(conditions, klass = self)
-        sanitized = klass.send(:sanitize_sql, conditions)
-
-        if sanitized =~ /\#\{.*\}/
-          ActiveSupport::Deprecation.warn(
-            'String-based interpolation of association conditions is deprecated. Please use a ' \
-            'proc instead. So, for example, has_many :older_friends, :conditions => \'age > #{age}\' ' \
-            'should be changed to has_many :older_friends, :conditions => proc { "age > #{age}" }.'
-          )
-          instance_eval("%@#{sanitized.gsub('@', '\@')}@", __FILE__, __LINE__)
-        elsif conditions.respond_to?(:to_proc)
-          klass.send(:sanitize_sql, instance_eval(&conditions))
-        else
-          sanitized
-        end
-      end
-
-      def append_conditions(reflection, preload_options)
-        sql = ""
-        sql << " AND (#{process_conditions_for_preload(reflection.options[:conditions], reflection.klass)})" if reflection.options[:conditions]
-        sql << " AND (#{process_conditions_for_preload(preload_options[:conditions])})" if preload_options[:conditions]
-        sql
-      end
-
-      def in_or_equals_for_ids(ids)
-        ids.size > 1 ? "IN (?)" : "= ?"
-      end
-
-      # Some databases impose a limit on the number of ids in a list (in Oracle its 1000)
-      # Make several smaller queries if necessary or make one query if the adapter supports it
-      def associated_records(ids)
-        max_ids_in_a_list = connection.ids_in_list_limit || ids.size
-        records = []
-        ids.each_slice(max_ids_in_a_list) do |some_ids|
-          records += yield(some_ids)
-        end
-        records
-      end
-    end
-  end
-end

data/lib/active_record/associations/association_collection.rb

@@ -1,572 +0,0 @@
-require 'set'
-require 'active_support/core_ext/array/wrap'
-
-module ActiveRecord
-  module Associations
-    # = Active Record Association Collection
-    #
-    # AssociationCollection is an abstract class that provides common stuff to
-    # ease the implementation of association proxies that represent
-    # collections. See the class hierarchy in AssociationProxy.
-    #
-    # 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 AssociationCollection < AssociationProxy #:nodoc:
-      def initialize(owner, reflection)
-        super
-        construct_sql
-      end
-
-      delegate :group, :order, :limit, :joins, :where, :preload, :eager_load, :includes, :from, :lock, :readonly, :having, :to => :scoped
-
-      def select(select = nil)
-        if block_given?
-          load_target
-          @target.select.each { |e| yield e }
-        else
-          scoped.select(select)
-        end
-      end
-
-      def scoped
-        with_scope(construct_scope) { @reflection.klass.scoped }
-      end
-
-      def find(*args)
-        options = args.extract_options!
-
-        # If using a custom finder_sql, scan the entire collection.
-        if @reflection.options[:finder_sql]
-          expects_array = args.first.kind_of?(Array)
-          ids           = args.flatten.compact.uniq.map { |arg| arg.to_i }
-
-          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
-        else
-          merge_options_from_reflection!(options)
-          construct_find_options!(options)
-
-          find_scope = construct_scope[:find].slice(:conditions, :order)
-
-          with_scope(:find => find_scope) do
-            relation = @reflection.klass.send(:construct_finder_arel, options, @reflection.klass.send(:current_scoped_methods))
-
-            case args.first
-            when :first, :last
-              relation.send(args.first)
-            when :all
-              records = relation.all
-              @reflection.options[:uniq] ? uniq(records) : records
-            else
-              relation.find(*args)
-            end
-          end
-        end
-      end
-
-      # Fetches the first one using SQL if possible.
-      def first(*args)
-        if fetch_first_or_last_using_find?(args)
-          find(:first, *args)
-        else
-          load_target unless loaded?
-          @target.first(*args)
-        end
-      end
-
-      # Fetches the last one using SQL if possible.
-      def last(*args)
-        if fetch_first_or_last_using_find?(args)
-          find(:last, *args)
-        else
-          load_target unless loaded?
-          @target.last(*args)
-        end
-      end
-
-      def to_ary
-        load_target
-        if @target.is_a?(Array)
-          @target.to_ary
-        else
-          Array.wrap(@target)
-        end
-      end
-      alias_method :to_a, :to_ary
-
-      def reset
-        reset_target!
-        reset_named_scopes_cache!
-        @loaded = false
-      end
-
-      def build(attributes = {}, &block)
-        if attributes.is_a?(Array)
-          attributes.collect { |attr| build(attr, &block) }
-        else
-          build_record(attributes) do |record|
-            block.call(record) if block_given?
-            set_belongs_to_association_for(record)
-          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 <<(*records)
-        result = true
-        load_target if @owner.new_record?
-
-        transaction do
-          flatten_deeper(records).each do |record|
-            raise_on_type_mismatch(record)
-            add_record_to_target_with_callbacks(record) do |r|
-              result &&= insert_record(record) unless @owner.new_record?
-            end
-          end
-        end
-
-        result && self
-      end
-
-      alias_method :push, :<<
-      alias_method :concat, :<<
-
-      # 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
-
-      # Remove all records from this association
-      #
-      # See delete for more info.
-      def delete_all
-        load_target
-        delete(@target)
-        reset_target!
-        reset_named_scopes_cache!
-      end
-
-      # Calculate sum using SQL, not Enumerable
-      def sum(*args)
-        if block_given?
-          calculate(:sum, *args) { |*block_args| yield(*block_args) }
-        else
-          calculate(:sum, *args)
-        end
-      end
-
-      # Count all records using SQL. If the +:counter_sql+ option is set for the association, it will
-      # be used for the query. If no +:counter_sql+ was supplied, but +:finder_sql+ was set, the
-      # descendant's +construct_sql+ method will have set :counter_sql automatically.
-      # Otherwise, construct options and pass them with scope to the target class's +count+.
-      def count(column_name = nil, options = {})
-        column_name, options = nil, column_name if column_name.is_a?(Hash)
-
-        if @reflection.options[:finder_sql] || @reflection.options[:counter_sql]
-          unless options.blank?
-            raise ArgumentError, "If finder_sql/counter_sql is used then options cannot be passed"
-          end
-
-          @reflection.klass.count_by_sql(@counter_sql)
-        else
-
-          if @reflection.options[:uniq]
-            # This is needed because 'SELECT count(DISTINCT *)..' is not valid SQL.
-            column_name = "#{@reflection.quoted_table_name}.#{@reflection.klass.primary_key}" unless column_name
-            options.merge!(:distinct => true)
-          end
-
-          value = @reflection.klass.send(:with_scope, construct_scope) { @reflection.klass.count(column_name, options) }
-
-          limit  = @reflection.options[:limit]
-          offset = @reflection.options[:offset]
-
-          if limit || offset
-            [ [value - offset.to_i, 0].max, limit.to_i ].min
-          else
-            value
-          end
-        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)
-        remove_records(records) do |_records, old_records|
-          delete_records(old_records) if old_records.any?
-          _records.each { |record| @target.delete(record) }
-        end
-      end
-
-      # Destroy +records+ and remove them from this association calling
-      # +before_remove+ and +after_remove+ callbacks.
-      #
-      # Note that this method will _always_ remove 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)}
-        remove_records(records) do |_records, old_records|
-          old_records.each { |record| record.destroy }
-        end
-
-        load_target
-      end
-
-      # Removes all records from this association.  Returns +self+ so method calls may be chained.
-      def clear
-        return self if length.zero? # forces load_target if it hasn't happened already
-
-        if @reflection.options[:dependent] && @reflection.options[:dependent] == :destroy
-          destroy_all
-        else
-          delete_all
-        end
-
-        self
-      end
-
-      # Destroy all the records from this association.
-      #
-      # See destroy for more info.
-      def destroy_all
-        load_target
-        destroy(@target).tap do
-          reset_target!
-          reset_named_scopes_cache!
-        end
-      end
-
-      def create(attrs = {})
-        if attrs.is_a?(Array)
-          attrs.collect { |attr| create(attr) }
-        else
-          create_record(attrs) do |record|
-            yield(record) if block_given?
-            record.save
-          end
-        end
-      end
-
-      def create!(attrs = {})
-        create_record(attrs) do |record|
-          yield(record) if block_given?
-          record.save!
-        end
-      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 @owner.new_record? || (loaded? && !@reflection.options[:uniq])
-          @target.size
-        elsif !loaded? && @reflection.options[:group]
-          load_target.size
-        elsif !loaded? && !@reflection.options[:uniq] && @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
-
-      # Equivalent to <tt>collection.size.zero?</tt>. If the collection has
-      # not been already loaded and you are going to fetch the records anyway
-      # it is better to check <tt>collection.length.zero?</tt>.
-      def empty?
-        size.zero?
-      end
-
-      def any?
-        if block_given?
-          method_missing(: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?
-          method_missing(:many?) { |*block_args| yield(*block_args) }
-        else
-          size > 1
-        end
-      end
-
-      def uniq(collection = self)
-        seen = Set.new
-        collection.map do |record|
-          unless seen.include?(record.id)
-            seen << record.id
-            record
-          end
-        end.compact
-      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) }
-
-        load_target
-        other   = other_array.size < 100 ? other_array : other_array.to_set
-        current = @target.size < 100 ? @target : @target.to_set
-
-        transaction do
-          delete(@target.select { |v| !other.include?(v) })
-          concat(other_array.select { |v| !current.include?(v) })
-        end
-      end
-
-      def include?(record)
-        return false unless record.is_a?(@reflection.klass)
-        return include_in_memory?(record) if record.new_record?
-        load_target if @reflection.options[:finder_sql] && !loaded?
-        return @target.include?(record) if loaded?
-        exists?(record)
-      end
-
-      def proxy_respond_to?(method, include_private = false)
-        super || @reflection.klass.respond_to?(method, include_private)
-      end
-
-      protected
-        def construct_find_options!(options)
-        end
-
-        def construct_counter_sql
-          if @reflection.options[:counter_sql]
-            @counter_sql = interpolate_and_sanitize_sql(@reflection.options[:counter_sql])
-          elsif @reflection.options[:finder_sql]
-            # replace the SELECT clause with COUNT(*), preserving any hints within /* ... */
-            @counter_sql = interpolate_and_sanitize_sql(@reflection.options[:finder_sql]).sub(/SELECT\b(\/\*.*?\*\/ )?(.*)\bFROM\b/im) { "SELECT #{$1}COUNT(*) FROM" }
-          else
-            @counter_sql = @finder_sql
-          end
-        end
-
-        def load_target
-          if !@owner.new_record? || foreign_key_present
-            begin
-              if !loaded?
-                if @target.is_a?(Array) && @target.any?
-                  @target = find_target.map do |f|
-                    i = @target.index(f)
-                    if i
-                      @target.delete_at(i).tap do |t|
-                        keys = ["id"] + t.changes.keys + (f.attribute_names - t.attribute_names)
-                        t.attributes = f.attributes.except(*keys)
-                      end
-                    else
-                      f
-                    end
-                  end + @target
-                else
-                  @target = find_target
-                end
-              end
-            rescue ActiveRecord::RecordNotFound
-              reset
-            end
-          end
-
-          loaded if target
-          target
-        end
-
-        def method_missing(method, *args)
-          match = DynamicFinderMatch.match(method)
-          if match && match.creator?
-            attributes = match.attribute_names
-            return send(:"find_by_#{attributes.join('_and_')}", *args) || create(Hash[attributes.zip(args)])
-          end
-
-          if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
-            if block_given?
-              super { |*block_args| yield(*block_args) }
-            else
-              super
-            end
-          elsif @reflection.klass.scopes[method]
-            @_named_scopes_cache ||= {}
-            @_named_scopes_cache[method] ||= {}
-            @_named_scopes_cache[method][args] ||= with_scope(construct_scope) { @reflection.klass.send(method, *args) }
-          else
-            with_scope(construct_scope) do
-              if block_given?
-                @reflection.klass.send(method, *args) { |*block_args| yield(*block_args) }
-              else
-                @reflection.klass.send(method, *args)
-              end
-            end
-          end
-        end
-
-        # overloaded in derived Association classes to provide useful scoping depending on association type.
-        def construct_scope
-          {}
-        end
-
-        def reset_target!
-          @target = Array.new
-        end
-
-        def reset_named_scopes_cache!
-          @_named_scopes_cache = {}
-        end
-
-        def find_target
-          records =
-            if @reflection.options[:finder_sql]
-              @reflection.klass.find_by_sql(@finder_sql)
-            else
-              find(:all)
-            end
-
-          records = @reflection.options[:uniq] ? uniq(records) : records
-          records.each do |record|
-            set_inverse_instance(record, @owner)
-          end
-          records
-        end
-
-        def add_record_to_target_with_callbacks(record)
-          callback(:before_add, record)
-          yield(record) if block_given?
-          @target ||= [] unless loaded?
-          if index = @target.index(record)
-            @target[index] = record
-          else
-             @target << record
-          end
-          callback(:after_add, record)
-          set_inverse_instance(record, @owner)
-          record
-        end
-
-      private
-        def create_record(attrs)
-          attrs.update(@reflection.options[:conditions]) if @reflection.options[:conditions].is_a?(Hash)
-          ensure_owner_is_not_new
-
-          scoped_where = scoped.where_values_hash
-          create_scope = scoped_where ? construct_scope[:create].merge(scoped_where) : construct_scope[:create]
-          record = @reflection.klass.send(:with_scope, :create => create_scope) do
-            @reflection.build_association(attrs)
-          end
-          if block_given?
-            add_record_to_target_with_callbacks(record) { |*block_args| yield(*block_args) }
-          else
-            add_record_to_target_with_callbacks(record)
-          end
-        end
-
-        def build_record(attrs)
-          attrs.update(@reflection.options[:conditions]) if @reflection.options[:conditions].is_a?(Hash)
-          record = @reflection.build_association(attrs)
-          if block_given?
-            add_record_to_target_with_callbacks(record) { |*block_args| yield(*block_args) }
-          else
-            add_record_to_target_with_callbacks(record)
-          end
-        end
-
-        def remove_records(*records)
-          records = flatten_deeper(records)
-          records.each { |record| raise_on_type_mismatch(record) }
-
-          transaction do
-            records.each { |record| callback(:before_remove, record) }
-            old_records = records.reject { |r| r.new_record? }
-            yield(records, old_records)
-            records.each { |record| callback(:after_remove, record) }
-          end
-        end
-
-        def callback(method, record)
-          callbacks_for(method).each do |callback|
-            case callback
-            when Symbol
-              @owner.send(callback, record)
-            when Proc
-              callback.call(@owner, record)
-            else
-              callback.send(method, @owner, record)
-            end
-          end
-        end
-
-        def callbacks_for(callback_name)
-          full_callback_name = "#{callback_name}_for_#{@reflection.name}"
-          @owner.class.read_inheritable_attribute(full_callback_name.to_sym) || []
-        end
-
-        def ensure_owner_is_not_new
-          if @owner.new_record?
-            raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
-          end
-        end
-
-        def fetch_first_or_last_using_find?(args)
-          args.first.kind_of?(Hash) || !(loaded? || @owner.new_record? || @reflection.options[:finder_sql] ||
-                                         @target.any? { |record| record.new_record? } || args.first.kind_of?(Integer))
-        end
-
-        def include_in_memory?(record)
-          if @reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
-            @owner.send(proxy_reflection.through_reflection.name).any? { |source|
-              target = source.send(proxy_reflection.source_reflection.name)
-              target.respond_to?(:include?) ? target.include?(record) : target == record
-            } || @target.include?(record)
-          else
-            @target.include?(record)
-          end
-        end
-    end
-  end
-end