activerecord 1.0.0 → 3.0.0

data/lib/active_record/reflection.rb

@@ -1,126 +1,403 @@
 module ActiveRecord
+  # = Active Record Reflection
   module Reflection # :nodoc:
-    def self.append_features(base)
-      super
-      base.extend(ClassMethods)
+    extend ActiveSupport::Concern
 
-      base.class_eval do
-        class << self
-          alias_method :composed_of_without_reflection, :composed_of
-
-          def composed_of_with_reflection(part_id, options = {})
-            composed_of_without_reflection(part_id, options)
-            write_inheritable_array "aggregations", [ AggregateReflection.new(part_id, options, self) ]
-          end
-
-          alias_method :composed_of, :composed_of_with_reflection          
+    # Reflection enables to interrogate Active Record classes and objects
+    # about their associations and aggregations. This information can,
+    # for example, be used in a form builder that takes an Active Record object
+    # and creates input fields for all of the attributes depending on their type
+    # and displays the associations to other objects.
+    #
+    # MacroReflection class has info for AggregateReflection and AssociationReflection
+    # classes.
+    module ClassMethods
+      def create_reflection(macro, name, options, active_record)
+        case macro
+          when :has_many, :belongs_to, :has_one, :has_and_belongs_to_many
+            klass = options[:through] ? ThroughReflection : AssociationReflection
+            reflection = klass.new(macro, name, options, active_record)
+          when :composed_of
+            reflection = AggregateReflection.new(macro, name, options, active_record)
         end
+        write_inheritable_hash :reflections, name => reflection
+        reflection
       end
-      
-      for association_type in %w( belongs_to has_one has_many has_and_belongs_to_many )
-        base.module_eval <<-"end_eval"
-          class << self
-            alias_method :#{association_type}_without_reflection, :#{association_type}
-
-            def #{association_type}_with_reflection(association_id, options = {})
-              #{association_type}_without_reflection(association_id, options)
-              write_inheritable_array "associations", [ AssociationReflection.new(association_id, options, self) ]
-            end
 
-            alias_method :#{association_type}, :#{association_type}_with_reflection          
-          end
-        end_eval
+      # Returns a hash containing all AssociationReflection objects for the current class.
+      # Example:
+      #
+      #   Invoice.reflections
+      #   Account.reflections
+      #
+      def reflections
+        read_inheritable_attribute(:reflections) || write_inheritable_attribute(:reflections, {})
       end
-    end
 
-    # Reflection allows you to interrogate Active Record classes and objects about their associations and aggregations. 
-    # This information can for example be used in a form builder that took an Active Record object and created input
-    # fields for all of the attributes depending on their type and displayed the associations to other objects.
-    #
-    # You can find the interface for the AggregateReflection and AssociationReflection classes in the abstract MacroReflection class.
-    module ClassMethods
       # Returns an array of AggregateReflection objects for all the aggregations in the class.
       def reflect_on_all_aggregations
-        read_inheritable_attribute "aggregations"
+        reflections.values.select { |reflection| reflection.is_a?(AggregateReflection) }
       end
-      
-      # Returns the AggregateReflection object for the named +aggregation+ (use the symbol). Example:
-      #   Account.reflect_on_aggregation(:balance) # returns the balance AggregateReflection
+
+      # Returns the AggregateReflection object for the named +aggregation+ (use the symbol).
+      #
+      #   Account.reflect_on_aggregation(:balance) # => the balance AggregateReflection
+      #
       def reflect_on_aggregation(aggregation)
-        reflect_on_all_aggregations.find { |reflection| reflection.name == aggregation } unless reflect_on_all_aggregations.nil?
+        reflections[aggregation].is_a?(AggregateReflection) ? reflections[aggregation] : nil
       end
 
-      # Returns an array of AssociationReflection objects for all the aggregations in the class.
-      def reflect_on_all_associations
-        read_inheritable_attribute "associations"
+      # Returns an array of AssociationReflection objects for all the
+      # associations in the class. If you only want to reflect on a certain
+      # association type, pass in the symbol (<tt>:has_many</tt>, <tt>:has_one</tt>,
+      # <tt>:belongs_to</tt>) as the first parameter.
+      #
+      # Example:
+      #
+      #   Account.reflect_on_all_associations             # returns an array of all associations
+      #   Account.reflect_on_all_associations(:has_many)  # returns an array of all has_many associations
+      #
+      def reflect_on_all_associations(macro = nil)
+        association_reflections = reflections.values.select { |reflection| reflection.is_a?(AssociationReflection) }
+        macro ? association_reflections.select { |reflection| reflection.macro == macro } : association_reflections
       end
-      
-      # Returns the AssociationReflection object for the named +aggregation+ (use the symbol). Example:
-      #   Account.reflect_on_association(:owner) # returns the owner AssociationReflection
+
+      # Returns the AssociationReflection object for the +association+ (use the symbol).
+      #
+      #   Account.reflect_on_association(:owner)             # returns the owner AssociationReflection
+      #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
+      #
       def reflect_on_association(association)
-        reflect_on_all_associations.find { |reflection| reflection.name == association } unless reflect_on_all_associations.nil?
+        reflections[association].is_a?(AssociationReflection) ? reflections[association] : nil
+      end
+
+      # Returns an array of AssociationReflection objects for all associations which have <tt>:autosave</tt> enabled.
+      def reflect_on_all_autosave_associations
+        reflections.values.select { |reflection| reflection.options[:autosave] }
       end
     end
-    
 
-    # Abstract base class for AggregateReflection and AssociationReflection that describes the interface available for both of 
-    # those classes. Objects of AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
+
+    # Abstract base class for AggregateReflection and AssociationReflection. Objects of
+    # AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
     class MacroReflection
       attr_reader :active_record
-      def initialize(name, options, active_record)
-        @name, @options, @active_record = name, options, active_record
-      end
-      
-      # Returns the name of the macro, so it would return :balance for "composed_of :balance, :class_name => 'Money'" or
-      # :clients for "has_many :clients".
-      def name
-        @name
-      end
-      
-      # Returns the hash of options used for the macro, so it would return { :class_name => "Money" } for 
-      # "composed_of :balance, :class_name => 'Money'" or {} for "has_many :clients".
-      def options
-        @options
-      end
-      
-      # Returns the class for the macro, so "composed_of :balance, :class_name => 'Money'" would return the Money class and
-      # "has_many :clients" would return the Client class.
-      def klass() end
-      
-      def ==(other_aggregation)
-        name == other_aggregation.name && other_aggregation.options && active_record == other_aggregation.active_record
+
+      def initialize(macro, name, options, active_record)
+        @macro, @name, @options, @active_record = macro, name, options, active_record
       end
-    end
 
+      # Returns the name of the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>:balance</tt>
+      # <tt>has_many :clients</tt> returns <tt>:clients</tt>
+      attr_reader :name
 
-    # Holds all the meta-data about an aggregation as it was specified in the Active Record class.
-    class AggregateReflection < MacroReflection #:nodoc:
+      # Returns the macro type.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>:composed_of</tt>
+      # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
+      attr_reader :macro
+
+      # Returns the hash of options used for the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>{ :class_name => "Money" }</tt>
+      # <tt>has_many :clients</tt> returns +{}+
+      attr_reader :options
+
+      # Returns the class for the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns the Money class
+      # <tt>has_many :clients</tt> returns the Client class
       def klass
-        Object.const_get(options[:class_name] || name_to_class_name(name.id2name)) 
+        @klass ||= class_name.constantize
+      end
+
+      # Returns the class name for the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>'Money'</tt>
+      # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
+      def class_name
+        @class_name ||= options[:class_name] || derive_class_name
+      end
+
+      # Returns +true+ if +self+ and +other_aggregation+ have the same +name+ attribute, +active_record+ attribute,
+      # and +other_aggregation+ has an options hash assigned to it.
+      def ==(other_aggregation)
+        other_aggregation.kind_of?(self.class) && name == other_aggregation.name && other_aggregation.options && active_record == other_aggregation.active_record
       end
-      
+
+      def sanitized_conditions #:nodoc:
+        @sanitized_conditions ||= klass.send(:sanitize_sql, options[:conditions]) if options[:conditions]
+      end
+
       private
-        def name_to_class_name(name)
-          name.capitalize.gsub(/_(.)/) { |s| $1.capitalize }
+        def derive_class_name
+          name.to_s.camelize
         end
     end
 
-    # Holds all the meta-data about an association as it was specified in the Active Record class.
+
+    # Holds all the meta-data about an aggregation as it was specified in the
+    # Active Record class.
+    class AggregateReflection < MacroReflection #:nodoc:
+    end
+
+    # Holds all the meta-data about an association as it was specified in the
+    # Active Record class.
     class AssociationReflection < MacroReflection #:nodoc:
+      # Returns the target association's class.
+      #
+      #   class Author < ActiveRecord::Base
+      #     has_many :books
+      #   end
+      #
+      #   Author.reflect_on_association(:books).klass
+      #   # => Book
+      #
+      # <b>Note:</b> Do not call +klass.new+ or +klass.create+ to instantiate
+      # a new association object. Use +build_association+ or +create_association+
+      # instead. This allows plugins to hook into association object creation.
       def klass
-        active_record.send(:compute_type, (name_to_class_name(name.id2name)))
+        @klass ||= active_record.send(:compute_type, class_name)
+      end
+
+      def initialize(macro, name, options, active_record)
+        super
+        @collection = [:has_many, :has_and_belongs_to_many].include?(macro)
+      end
+
+      # Returns a new, unsaved instance of the associated class. +options+ will
+      # be passed to the class's constructor.
+      def build_association(*options)
+        klass.new(*options)
+      end
+
+      # Creates a new instance of the associated class, and immediately saves it
+      # with ActiveRecord::Base#save. +options+ will be passed to the class's
+      # creation method. Returns the newly created object.
+      def create_association(*options)
+        klass.create(*options)
+      end
+
+      # Creates a new instance of the associated class, and immediately saves it
+      # with ActiveRecord::Base#save!. +options+ will be passed to the class's
+      # creation method. If the created record doesn't pass validations, then an
+      # exception will be raised.
+      #
+      # Returns the newly created object.
+      def create_association!(*options)
+        klass.create!(*options)
+      end
+
+      def table_name
+        @table_name ||= klass.table_name
+      end
+
+      def quoted_table_name
+        @quoted_table_name ||= klass.quoted_table_name
+      end
+
+      def primary_key_name
+        @primary_key_name ||= options[:foreign_key] || derive_primary_key_name
+      end
+
+      def primary_key_column
+        @primary_key_column ||= klass.columns.find { |c| c.name == klass.primary_key }
+      end
+
+      def association_foreign_key
+        @association_foreign_key ||= @options[:association_foreign_key] || class_name.foreign_key
+      end
+
+      def counter_cache_column
+        if options[:counter_cache] == true
+          "#{active_record.name.demodulize.underscore.pluralize}_count"
+        elsif options[:counter_cache]
+          options[:counter_cache]
+        end
+      end
+
+      def columns(tbl_name, log_msg)
+        @columns ||= klass.connection.columns(tbl_name, log_msg)
+      end
+
+      def reset_column_information
+        @columns = nil
+      end
+
+      def check_validity!
+        check_validity_of_inverse!
+      end
+
+      def check_validity_of_inverse!
+        unless options[:polymorphic]
+          if has_inverse? && inverse_of.nil?
+            raise InverseOfAssociationNotFoundError.new(self)
+          end
+        end
+      end
+
+      def through_reflection
+        false
+      end
+
+      def through_reflection_primary_key_name
+      end
+
+      def source_reflection
+        nil
+      end
+
+      def has_inverse?
+        !@options[:inverse_of].nil?
+      end
+
+      def inverse_of
+        if has_inverse?
+          @inverse_of ||= klass.reflect_on_association(options[:inverse_of])
+        end
+      end
+
+      def polymorphic_inverse_of(associated_class)
+        if has_inverse?
+          if inverse_relationship = associated_class.reflect_on_association(options[:inverse_of])
+            inverse_relationship
+          else
+            raise InverseOfAssociationNotFoundError.new(self, associated_class)
+          end
+        end
+      end
+
+      # Returns whether or not this association reflection is for a collection
+      # association. Returns +true+ if the +macro+ is either +has_many+ or
+      # +has_and_belongs_to_many+, +false+ otherwise.
+      def collection?
+        @collection
+      end
+
+      # Returns whether or not the association should be validated as part of
+      # the parent's validation.
+      #
+      # Unless you explicitly disable validation with
+      # <tt>:validate => false</tt>, validation will take place when:
+      #
+      # * you explicitly enable validation; <tt>:validate => true</tt>
+      # * you use autosave; <tt>:autosave => true</tt>
+      # * the association is a +has_many+ association
+      def validate?
+        !options[:validate].nil? ? options[:validate] : (options[:autosave] == true || macro == :has_many)
+      end
+
+      def dependent_conditions(record, base_class, extra_conditions)
+        dependent_conditions = []
+        dependent_conditions << "#{primary_key_name} = #{record.send(name).send(:owner_quoted_id)}"
+        dependent_conditions << "#{options[:as]}_type = '#{base_class.name}'" if options[:as]
+        dependent_conditions << klass.send(:sanitize_sql, options[:conditions]) if options[:conditions]
+        dependent_conditions << extra_conditions if extra_conditions
+        dependent_conditions = dependent_conditions.collect {|where| "(#{where})" }.join(" AND ")
+        dependent_conditions = dependent_conditions.gsub('@', '\@')
+        dependent_conditions
+      end
+
+      # Returns +true+ if +self+ is a +belongs_to+ reflection.
+      def belongs_to?
+        macro == :belongs_to
       end
 
       private
-        def name_to_class_name(name)
-          if name !~ /::/
-            class_name = active_record.send(
-              :type_name_with_module, 
-              (options[:class_name] || active_record.class_name(active_record.table_name_prefix + name + active_record.table_name_suffix))
-            )
+        def derive_class_name
+          class_name = name.to_s.camelize
+          class_name = class_name.singularize if collection?
+          class_name
+        end
+
+        def derive_primary_key_name
+          if belongs_to?
+            "#{name}_id"
+          elsif options[:as]
+            "#{options[:as]}_id"
+          else
+            active_record.name.foreign_key
           end
-          return class_name || name
+        end
+    end
+
+    # Holds all the meta-data about a :through association as it was specified
+    # in the Active Record class.
+    class ThroughReflection < AssociationReflection #:nodoc:
+      # Gets the source of the through reflection.  It checks both a singularized
+      # and pluralized form for <tt>:belongs_to</tt> or <tt>:has_many</tt>.
+      #
+      #   class Post < ActiveRecord::Base
+      #     has_many :taggings
+      #     has_many :tags, :through => :taggings
+      #   end
+      #
+      def source_reflection
+        @source_reflection ||= source_reflection_names.collect { |name| through_reflection.klass.reflect_on_association(name) }.compact.first
+      end
+
+      # Returns the AssociationReflection object specified in the <tt>:through</tt> option
+      # of a HasManyThrough or HasOneThrough association.
+      #
+      #   class Post < ActiveRecord::Base
+      #     has_many :taggings
+      #     has_many :tags, :through => :taggings
+      #   end
+      #
+      #   tags_reflection = Post.reflect_on_association(:tags)
+      #   taggings_reflection = tags_reflection.through_reflection
+      #
+      def through_reflection
+        @through_reflection ||= active_record.reflect_on_association(options[:through])
+      end
+
+      # Gets an array of possible <tt>:through</tt> source reflection names:
+      #
+      #   [:singularized, :pluralized]
+      #
+      def source_reflection_names
+        @source_reflection_names ||= (options[:source] ? [options[:source]] : [name.to_s.singularize, name]).collect { |n| n.to_sym }
+      end
+
+      def check_validity!
+        if through_reflection.nil?
+          raise HasManyThroughAssociationNotFoundError.new(active_record.name, self)
+        end
+
+        if source_reflection.nil?
+          raise HasManyThroughSourceAssociationNotFoundError.new(self)
+        end
+
+        if options[:source_type] && source_reflection.options[:polymorphic].nil?
+          raise HasManyThroughAssociationPointlessSourceTypeError.new(active_record.name, self, source_reflection)
+        end
+
+        if source_reflection.options[:polymorphic] && options[:source_type].nil?
+          raise HasManyThroughAssociationPolymorphicError.new(active_record.name, self, source_reflection)
+        end
+
+        unless [:belongs_to, :has_many, :has_one].include?(source_reflection.macro) && source_reflection.options[:through].nil?
+          raise HasManyThroughSourceAssociationMacroError.new(self)
+        end
+
+        check_validity_of_inverse!
+      end
+
+      def through_reflection_primary_key
+        through_reflection.belongs_to? ? through_reflection.klass.primary_key : through_reflection.primary_key_name
+      end
+
+      def through_reflection_primary_key_name
+        through_reflection.primary_key_name if through_reflection.belongs_to?
+      end
+
+      private
+        def derive_class_name
+          # get the class_name of the belongs_to association of the through reflection
+          options[:source_type] || source_reflection.class_name
         end
     end
   end
-end
+end

data/lib/active_record/relation/batches.rb

@@ -0,0 +1,89 @@
+require 'active_support/core_ext/object/blank'
+
+module ActiveRecord
+  module Batches # :nodoc:
+    # Yields each record that was found by the find +options+. The find is
+    # performed by find_in_batches with a batch size of 1000 (or as
+    # specified by the <tt>:batch_size</tt> option).
+    #
+    # Example:
+    #
+    #   Person.where("age > 21").find_each do |person|
+    #     person.party_all_night!
+    #   end
+    #
+    # Note: This method is only intended to use for batch processing of
+    # large amounts of records that wouldn't fit in memory all at once. If
+    # you just need to loop over less than 1000 records, it's probably
+    # better just to use the regular find methods.
+    def find_each(options = {})
+      find_in_batches(options) do |records|
+        records.each { |record| yield record }
+      end
+
+      self
+    end
+
+    # Yields each batch of records that was found by the find +options+ as
+    # an array. The size of each batch is set by the <tt>:batch_size</tt>
+    # option; the default is 1000.
+    #
+    # You can control the starting point for the batch processing by
+    # supplying the <tt>:start</tt> option. This is especially useful if you
+    # want multiple workers dealing with the same processing queue. You can
+    # make worker 1 handle all the records between id 0 and 10,000 and
+    # worker 2 handle from 10,000 and beyond (by setting the <tt>:start</tt>
+    # option on that worker).
+    #
+    # It's not possible to set the order. That is automatically set to
+    # ascending on the primary key ("id ASC") to make the batch ordering
+    # work. This also mean that this method only works with integer-based
+    # primary keys. You can't set the limit either, that's used to control
+    # the the batch sizes.
+    #
+    # Example:
+    #
+    #   Person.where("age > 21").find_in_batches do |group|
+    #     sleep(50) # Make sure it doesn't get too crowded in there!
+    #     group.each { |person| person.party_all_night! }
+    #   end
+    def find_in_batches(options = {})
+      relation = self
+
+      if orders.present? || taken.present?
+        ActiveRecord::Base.logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
+      end
+
+      if (finder_options = options.except(:start, :batch_size)).present?
+        raise "You can't specify an order, it's forced to be #{batch_order}" if options[:order].present?
+        raise "You can't specify a limit, it's forced to be the batch_size"  if options[:limit].present?
+
+        relation = apply_finder_options(finder_options)
+      end
+
+      start = options.delete(:start).to_i
+      batch_size = options.delete(:batch_size) || 1000
+
+      relation = relation.except(:order).order(batch_order).limit(batch_size)
+      records = relation.where(primary_key.gteq(start)).all
+
+      while records.any?
+        yield records
+
+        break if records.size < batch_size
+
+        if primary_key_offset = records.last.id
+          records = relation.where(primary_key.gt(primary_key_offset)).to_a
+        else
+          raise "Primary key not included in the custom select clause"
+        end
+      end
+    end
+
+    private
+
+    def batch_order
+      "#{@klass.table_name}.#{@klass.primary_key} ASC"
+    end
+  end
+end