activerecord 3.0.20 → 3.1.0.beta1

data/lib/active_record/associations/preloader/has_many.rb

@@ -0,0 +1,17 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class HasMany < CollectionAssociation #:nodoc:
+
+        def association_key_name
+          reflection.foreign_key
+        end
+
+        def owner_key_name
+          reflection.active_record_primary_key
+        end
+
+      end
+    end
+  end
+end

data/lib/active_record/associations/preloader/has_many_through.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class HasManyThrough < CollectionAssociation #:nodoc:
+        include ThroughAssociation
+
+        def associated_records_by_owner
+          super.each do |owner, records|
+            records.uniq! if options[:uniq]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/associations/preloader/has_one.rb

@@ -0,0 +1,23 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class HasOne < SingularAssociation #:nodoc:
+
+        def association_key_name
+          reflection.foreign_key
+        end
+
+        def owner_key_name
+          reflection.active_record_primary_key
+        end
+
+        private
+
+        def build_scope
+          super.order(preload_options[:order] || options[:order])
+        end
+
+      end
+    end
+  end
+end

data/lib/active_record/associations/preloader/has_one_through.rb

@@ -0,0 +1,9 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class HasOneThrough < SingularAssociation #:nodoc:
+        include ThroughAssociation
+      end
+    end
+  end
+end

data/lib/active_record/associations/preloader/singular_association.rb

@@ -0,0 +1,21 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class SingularAssociation < Association #:nodoc:
+
+        private
+
+        def preload
+          associated_records_by_owner.each do |owner, associated_records|
+            record = associated_records.first
+
+            association = owner.association(reflection.name)
+            association.target = record
+            association.set_inverse_instance(record)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/active_record/associations/preloader/through_association.rb

@@ -0,0 +1,67 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      module ThroughAssociation #:nodoc:
+
+        def through_reflection
+          reflection.through_reflection
+        end
+
+        def source_reflection
+          reflection.source_reflection
+        end
+
+        def associated_records_by_owner
+          through_records = through_records_by_owner
+
+          ActiveRecord::Associations::Preloader.new(
+            through_records.values.flatten,
+            source_reflection.name, options
+          ).run
+
+          through_records.each do |owner, records|
+            records.map! { |r| r.send(source_reflection.name) }.flatten!
+            records.compact!
+          end
+        end
+
+        private
+
+        def through_records_by_owner
+          ActiveRecord::Associations::Preloader.new(
+            owners, through_reflection.name,
+            through_options
+          ).run
+
+          Hash[owners.map do |owner|
+            through_records = Array.wrap(owner.send(through_reflection.name))
+
+            # Dont cache the association - we would only be caching a subset
+            if reflection.options[:source_type] && through_reflection.collection?
+              owner.association(through_reflection.name).reset
+            end
+
+            [owner, through_records]
+          end]
+        end
+
+        def through_options
+          through_options = {}
+
+          if options[:source_type]
+            through_options[:conditions] = { reflection.foreign_type => options[:source_type] }
+          else
+            if options[:conditions]
+              through_options[:include]    = options[:include] || options[:source]
+              through_options[:conditions] = options[:conditions]
+            end
+
+            through_options[:order] = options[:order]
+          end
+
+          through_options
+        end
+      end
+    end
+  end
+end

data/lib/active_record/associations/singular_association.rb

@@ -0,0 +1,55 @@
+module ActiveRecord
+  module Associations
+    class SingularAssociation < Association #:nodoc:
+      # Implements the reader method, e.g. foo.bar for Foo.has_one :bar
+      def reader(force_reload = false)
+        if force_reload
+          klass.uncached { reload }
+        elsif !loaded? || stale_target?
+          reload
+        end
+
+        target
+      end
+
+      # Implements the writer method, e.g. foo.items= for Foo.has_many :items
+      def writer(record)
+        replace(record)
+      end
+
+      def create(attributes = {}, options = {})
+        new_record(:create, attributes, options)
+      end
+
+      def create!(attributes = {}, options = {})
+        build(attributes, options).tap { |record| record.save! }
+      end
+
+      def build(attributes = {}, options = {})
+        new_record(:build, attributes, options)
+      end
+
+      private
+
+        def find_target
+          scoped.first.tap { |record| set_inverse_instance(record) }
+        end
+
+        # Implemented by subclasses
+        def replace(record)
+          raise NotImplementedError, "Subclasses must implement a replace(record) method"
+        end
+
+        def set_new_record(record)
+          replace(record)
+        end
+
+        def new_record(method, attributes, options)
+          attributes = scoped.scope_for_create.merge(attributes || {})
+          record = reflection.send("#{method}_association", attributes, options)
+          set_new_record(record)
+          record
+        end
+    end
+  end
+end

data/lib/active_record/associations/through_association.rb

@@ -0,0 +1,80 @@
+module ActiveRecord
+  # = Active Record Through Association
+  module Associations
+    module ThroughAssociation #:nodoc:
+
+      delegate :source_reflection, :through_reflection, :chain, :to => :reflection
+
+      protected
+
+        # We merge in these scopes for two reasons:
+        #
+        #   1. To get the default_scope conditions for any of the other reflections in the chain
+        #   2. To get the type conditions for any STI models in the chain
+        def target_scope
+          scope = super
+          chain[1..-1].each do |reflection|
+            scope = scope.merge(reflection.klass.scoped)
+          end
+          scope
+        end
+
+      private
+
+        # Construct attributes for :through pointing to owner and associate. This is used by the
+        # methods which create and delete records on the association.
+        #
+        # We only support indirectly modifying through associations which has a belongs_to source.
+        # This is the "has_many :tags, :through => :taggings" situation, where the join model
+        # typically has a belongs_to on both side. In other words, associations which could also
+        # be represented as has_and_belongs_to_many associations.
+        #
+        # We do not support creating/deleting records on the association where the source has
+        # some other type, because this opens up a whole can of worms, and in basically any
+        # situation it is more natural for the user to just create or modify their join records
+        # directly as required.
+        def construct_join_attributes(*records)
+          if source_reflection.macro != :belongs_to
+            raise HasManyThroughCantAssociateThroughHasOneOrManyReflection.new(owner, reflection)
+          end
+
+          join_attributes = {
+            source_reflection.foreign_key =>
+              records.map { |record|
+                record.send(source_reflection.association_primary_key)
+              }
+          }
+
+          if options[:source_type]
+            join_attributes[source_reflection.foreign_type] =
+              records.map { |record| record.class.base_class.name }
+          end
+
+          if records.count == 1
+            Hash[join_attributes.map { |k, v| [k, v.first] }]
+          else
+            join_attributes
+          end
+        end
+
+        # Note: this does not capture all cases, for example it would be crazy to try to
+        # properly support stale-checking for nested associations.
+        def stale_state
+          if through_reflection.macro == :belongs_to
+            owner[through_reflection.foreign_key].to_s
+          end
+        end
+
+        def foreign_key_present?
+          through_reflection.macro == :belongs_to &&
+          !owner[through_reflection.foreign_key].nil?
+        end
+
+        def ensure_not_nested
+          if reflection.nested?
+            raise HasManyThroughNestedAssociationsAreReadonly.new(owner, reflection)
+          end
+        end
+    end
+  end
+end

data/lib/active_record/attribute_methods.rb

@@ -10,7 +10,18 @@ module ActiveRecord
       # Generates all the attribute related methods for columns in the database
       # accessors, mutators and query methods.
       def define_attribute_methods
-        super(columns_hash.keys)
+        return if attribute_methods_generated?
+        super(column_names)
+        @attribute_methods_generated = true
+      end
+
+      def attribute_methods_generated?
+        @attribute_methods_generated ||= false
+      end
+
+      def undefine_attribute_methods(*args)
+        super
+        @attribute_methods_generated = false
       end
 
       # Checks whether the method is defined in the model or any of its subclasses
@@ -18,7 +29,11 @@ module ActiveRecord
       # method is defined by Active Record though.
       def instance_method_already_implemented?(method_name)
         method_name = method_name.to_s
-        @_defined_class_methods         ||= ancestors.first(ancestors.index(ActiveRecord::Base)).sum([]) { |m| m.public_instance_methods(false) | m.private_instance_methods(false) | m.protected_instance_methods(false) }.map {|m| m.to_s }.to_set
+        index = ancestors.index(ActiveRecord::Base) || ancestors.length
+        @_defined_class_methods         ||= ancestors.first(index).map { |m|
+          m.instance_methods(false) | m.private_instance_methods(false)
+        }.flatten.map {|m| m.to_s }.to_set
+
         @@_defined_activerecord_methods ||= defined_activerecord_methods
         raise DangerousAttributeError, "#{method_name} is defined by ActiveRecord" if @@_defined_activerecord_methods.include?(method_name)
         @_defined_class_methods.include?(method_name)
@@ -27,9 +42,8 @@ module ActiveRecord
       def defined_activerecord_methods
         active_record = ActiveRecord::Base
         super_klass   = ActiveRecord::Base.superclass
-        methods =  active_record.public_instance_methods - super_klass.public_instance_methods
-        methods += active_record.private_instance_methods - super_klass.private_instance_methods
-        methods += active_record.protected_instance_methods - super_klass.protected_instance_methods
+        methods = (active_record.instance_methods - super_klass.instance_methods) +
+                  (active_record.private_instance_methods - super_klass.private_instance_methods)
         methods.map {|m| m.to_s }.to_set
       end
     end

data/lib/active_record/attribute_methods/before_type_cast.rb

@@ -13,18 +13,19 @@ module ActiveRecord
 
       # Returns a hash of attributes before typecasting and deserialization.
       def attributes_before_type_cast
-        Hash[attribute_names.map { |name| [name, read_attribute_before_type_cast(name)] }]
+        @attributes
       end
 
       private
-        # Handle *_before_type_cast for method_missing.
-        def attribute_before_type_cast(attribute_name)
-          if attribute_name == 'id'
-            read_attribute_before_type_cast(self.class.primary_key)
-          else
-            read_attribute_before_type_cast(attribute_name)
-          end
+
+      # Handle *_before_type_cast for method_missing.
+      def attribute_before_type_cast(attribute_name)
+        if attribute_name == 'id'
+          read_attribute_before_type_cast(self.class.primary_key)
+        else
+          read_attribute_before_type_cast(attribute_name)
         end
+      end
     end
   end
 end

data/lib/active_record/attribute_methods/dirty.rb

@@ -1,3 +1,4 @@
+require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/object/blank'
 
 module ActiveRecord
@@ -12,7 +13,7 @@ module ActiveRecord
           raise "You cannot include Dirty after Timestamp"
         end
 
-        superclass_delegating_accessor :partial_updates
+        class_attribute :partial_updates
         self.partial_updates = true
       end
 
@@ -21,6 +22,8 @@ module ActiveRecord
         if status = super
           @previously_changed = changes
           @changed_attributes.clear
+        elsif IdentityMap.enabled?
+          IdentityMap.remove(self)
         end
         status
       end
@@ -31,6 +34,9 @@ module ActiveRecord
           @previously_changed = changes
           @changed_attributes.clear
         end
+        rescue
+          IdentityMap.remove(self) if IdentityMap.enabled?
+          raise
       end
 
       # <tt>reload</tt> the record and clears changed attributes.
@@ -88,7 +94,7 @@ module ActiveRecord
       end
 
       def clone_with_time_zone_conversion_attribute?(attr, old)
-        old.class.name == "Time" && time_zone_aware_attributes && !skip_time_zone_conversion_for_attributes.include?(attr.to_sym)
+        old.class.name == "Time" && time_zone_aware_attributes && !self.skip_time_zone_conversion_for_attributes.include?(attr.to_sym)
       end
     end
   end

data/lib/active_record/attribute_methods/primary_key.rb

@@ -3,17 +3,18 @@ module ActiveRecord
     module PrimaryKey
       extend ActiveSupport::Concern
 
-      # Returns this record's primary key value wrapped in an Array
-      # or nil if the record is a new_record?
+      # Returns this record's primary key value wrapped in an Array or nil if
+      # the record is not persisted? or has just been destroyed.
       def to_key
-        new_record? ? nil : [ id ]
+        key = send(self.class.primary_key)
+        [key] if key
       end
 
       module ClassMethods
         # Defines the primary key field -- can be overridden in subclasses. Overwriting will negate any effect of the
         # primary_key_prefix_type setting, though.
         def primary_key
-          reset_primary_key
+          @primary_key ||= reset_primary_key
         end
 
         # Returns a quoted version of the primary key name, used to construct SQL statements.
@@ -22,20 +23,36 @@ module ActiveRecord
         end
 
         def reset_primary_key #:nodoc:
-          key = get_primary_key(base_class.name)
+          key = self == base_class ? get_primary_key(base_class.name) :
+            base_class.primary_key
+
           set_primary_key(key)
           key
         end
 
         def get_primary_key(base_name) #:nodoc:
-          key = 'id'
+          return 'id' unless base_name && !base_name.blank?
+
           case primary_key_prefix_type
-            when :table_name
-              key = base_name.to_s.foreign_key(false)
-            when :table_name_with_underscore
-              key = base_name.to_s.foreign_key
+          when :table_name
+            base_name.foreign_key(false)
+          when :table_name_with_underscore
+            base_name.foreign_key
+          else
+            if ActiveRecord::Base != self && connection.table_exists?(table_name)
+              connection.primary_key(table_name)
+            else
+              'id'
+            end
           end
-          key
+        end
+
+        attr_accessor :original_primary_key
+        
+        # Attribute writer for the primary key column
+        def primary_key=(value)
+          @quoted_primary_key = nil
+          @primary_key = value
         end
 
         # Sets the name of the primary key column to use to the given value,
@@ -47,9 +64,12 @@ module ActiveRecord
         #   end
         def set_primary_key(value = nil, &block)
           @quoted_primary_key = nil
-          define_attr_method :primary_key, value, &block
+          @primary_key ||= ''
+          self.original_primary_key = @primary_key
+          value &&= value.to_s
+          connection_pool.primary_keys[table_name] = value
+          self.primary_key = block_given? ? instance_eval(&block) : value
         end
-        alias :primary_key= :set_primary_key
       end
     end
   end