activerecord 3.2.22.5 → 4.0.0.beta1

data/lib/active_record/associations/alias_tracker.rb

@@ -8,7 +8,7 @@ module ActiveRecord
       attr_reader :aliases, :table_joins, :connection
 
       # table_joins is an array of arel joins which might conflict with the aliases we assign here
-      def initialize(connection = ActiveRecord::Model.connection, table_joins = [])
+      def initialize(connection = Base.connection, table_joins = [])
         @aliases     = Hash.new { |h,k| h[k] = initial_count_for(k) }
         @table_joins = table_joins
         @connection  = connection

data/lib/active_record/associations/association.rb

@@ -1,5 +1,4 @@
 require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/object/inclusion'
 
 module ActiveRecord
   module Associations
@@ -25,9 +24,7 @@ module ActiveRecord
       def initialize(owner, reflection)
         reflection.check_validity!
 
-        @target = nil
         @owner, @reflection = owner, reflection
-        @updated = false
 
         reset
         reset_scope
@@ -38,13 +35,12 @@ module ActiveRecord
       #   post.comments.aliased_table_name # => "comments"
       #
       def aliased_table_name
-        reflection.klass.table_name
+        klass.table_name
       end
 
       # Resets the \loaded flag to +false+ and sets the \target to +nil+.
       def reset
         @loaded = false
-        IdentityMap.remove(target) if IdentityMap.enabled? && target
         @target = nil
         @stale_state = nil
       end
@@ -84,10 +80,15 @@ module ActiveRecord
         loaded!
       end
 
-      def scoped
+      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
@@ -121,7 +122,7 @@ module ActiveRecord
       # Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the
       # through association's scope)
       def target_scope
-        klass.scoped
+        klass.all
       end
 
       # Loads the \target if needed and returns it.
@@ -129,28 +130,14 @@ module ActiveRecord
       # 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 stale(the target no longer points to the record(s) that the
-      # relevant foreign_key(s) refers to.), force reload the \target.
-      #
-      # Otherwise if the \target is already \loaded it is just returned. Thus, you can
-      # call +load_target+ unconditionally to get the \target.
+      # 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
-        if (@stale_state && stale_target?) || find_target?
-          begin
-            if IdentityMap.enabled? && association_class && association_class.respond_to?(:base_class)
-              @target = IdentityMap.get(association_class, owner[reflection.foreign_key])
-            elsif @stale_state && stale_target?
-              @target = find_target
-            end
-          rescue NameError
-            nil
-          ensure
-            @target ||= find_target
-          end
-        end
+        @target = find_target if (@stale_state && stale_target?) || find_target?
+
         loaded! unless loaded?
         target
       rescue ActiveRecord::RecordNotFound
@@ -158,13 +145,25 @@ module ActiveRecord
       end
 
       def interpolate(sql, record = nil)
-        if sql.respond_to?(:to_proc) && !sql.is_a?(Hash)
+        if sql.respond_to?(:to_proc)
           owner.send(: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?
@@ -174,7 +173,7 @@ module ActiveRecord
         def creation_attributes
           attributes = {}
 
-          if reflection.macro.in?([:has_one, :has_many]) && !options[:through]
+          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]
@@ -224,22 +223,18 @@ module ActiveRecord
         end
 
         # This should be implemented to return the values of the relevant key(s) on the owner,
-        # so that when state_state is different from the value stored on the last find_target,
+        # 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 association_class
-          @reflection.klass
-        end
-
-        def build_record(attributes, options)
-          reflection.build_association(attributes, options) do |record|
+        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, :without_protection => true)
+            record.assign_attributes(attributes)
           end
         end
     end

data/lib/active_record/associations/association_scope.rb

@@ -6,7 +6,7 @@ module ActiveRecord
       attr_reader :association, :alias_tracker
 
       delegate :klass, :owner, :reflection, :interpolate, :to => :association
-      delegate :chain, :conditions, :options, :source_options, :active_record, :to => :reflection
+      delegate :chain, :scope_chain, :options, :source_options, :active_record, :to => :reflection
 
       def initialize(association)
         @association   = association
@@ -15,23 +15,28 @@ module ActiveRecord
 
       def scope
         scope = klass.unscoped
-        scope = scope.extending(*Array.wrap(options[:extend]))
-
-        # It's okay to just apply all these like this. The options will only be present if the
-        # association supports that option; this is enforced by the association builder.
-        scope = scope.apply_finder_options(options.slice(
-          :readonly, :include, :order, :limit, :joins, :group, :having, :offset, :select))
+        scope.extending! Array(options[:extend])
+        add_constraints(scope)
+      end
 
-        if options[:through] && !options[:include]
-          scope = scope.includes(source_options[:include])
-        end
+      private
 
-        scope = scope.uniq if options[:uniq]
+      def column_for(table_name, column_name)
+        columns = alias_tracker.connection.schema_cache.columns_hash[table_name]
+        columns[column_name]
+      end
 
-        add_constraints(scope)
+      def bind_value(scope, column, value)
+        substitute = alias_tracker.connection.substitute_at(
+          column, scope.bind_values.length)
+        scope.bind_values += [[column, value]]
+        substitute
       end
 
-      private
+      def bind(scope, table_name, column_name, value)
+        column   = column_for table_name, column_name
+        bind_value scope, column, value
+      end
 
       def add_constraints(scope)
         tables = construct_tables
@@ -53,7 +58,7 @@ module ActiveRecord
 
           if reflection.source_macro == :belongs_to
             if reflection.options[:polymorphic]
-              key = reflection.association_primary_key(klass)
+              key = reflection.association_primary_key(self.klass)
             else
               key = reflection.association_primary_key
             end
@@ -64,21 +69,14 @@ module ActiveRecord
             foreign_key = reflection.active_record_primary_key
           end
 
-          conditions = self.conditions[i]
-
           if reflection == chain.last
-            scope = scope.where(table[key].eq(owner[foreign_key]))
+            bind_val = bind scope, table.table_name, key.to_s, owner[foreign_key]
+            scope    = scope.where(table[key].eq(bind_val))
 
             if reflection.type
-              scope = scope.where(table[reflection.type].eq(owner.class.base_class.name))
-            end
-
-            conditions.each do |condition|
-              if options[:through] && condition.is_a?(Hash)
-                condition = disambiguate_condition(table, condition)
-              end
-
-              scope = scope.where(interpolate(condition))
+              value    = owner.class.base_class.name
+              bind_val = bind scope, table.table_name, reflection.type.to_s, value
+              scope    = scope.where(table[reflection.type].eq(bind_val))
             end
           else
             constraint = table[key].eq(foreign_table[foreign_key])
@@ -89,10 +87,20 @@ module ActiveRecord
             end
 
             scope = scope.joins(join(foreign_table, constraint))
+          end
+
+          # Exclude the scope of the association itself, because that
+          # was already merged in the #scope method.
+          scope_chain[i].each do |scope_chain_item|
+            klass = i == 0 ? self.klass : reflection.klass
+            item  = eval_scope(klass, scope_chain_item)
 
-            unless conditions.empty?
-              scope = scope.where(sanitize(conditions, table))
+            if scope_chain_item == self.reflection.scope
+              scope.merge! item.except(:where, :includes)
             end
+
+            scope.includes! item.includes_values
+            scope.where_values += item.where_values
           end
         end
 
@@ -114,19 +122,11 @@ module ActiveRecord
         end
       end
 
-      def disambiguate_condition(table, condition)
-        if condition.is_a?(Hash)
-          Hash[
-            condition.map do |k, v|
-              if v.is_a?(Hash)
-                [k, v]
-              else
-                [table.table_alias || table.name, { k => v }]
-              end
-            end
-          ]
+      def eval_scope(klass, scope)
+        if scope.is_a?(Relation)
+          scope
         else
-          condition
+          klass.unscoped.instance_exec(owner, &scope)
         end
       end
     end

data/lib/active_record/associations/belongs_to_association.rb

@@ -2,6 +2,11 @@ module ActiveRecord
   # = Active Record Belongs To Associations
   module Associations
     class BelongsToAssociation < SingularAssociation #:nodoc:
+
+      def handle_dependency
+        target.send(options[:dependent]) if load_target
+      end
+
       def replace(record)
         raise_on_type_mismatch(record) if record
 
@@ -14,6 +19,11 @@ module ActiveRecord
         self.target = record
       end
 
+      def reset
+        super
+        @updated = false
+      end
+
       def updated?
         @updated
       end
@@ -40,8 +50,11 @@ module ActiveRecord
 
         # Checks whether record is different to the current target, without loading it
         def different_target?(record)
-          record.nil? && owner[reflection.foreign_key] ||
-          record && record.id != owner[reflection.foreign_key]
+          if record.nil? 
+            owner[reflection.foreign_key] 
+          else
+            record.id != owner[reflection.foreign_key]
+          end
         end
 
         def replace_keys(record)

data/lib/active_record/associations/builder/association.rb

@@ -1,55 +1,108 @@
 module ActiveRecord::Associations::Builder
   class Association #:nodoc:
-    class_attribute :valid_options
-    self.valid_options = [:class_name, :foreign_key, :select, :conditions, :include, :extend, :readonly, :validate]
+    class << self
+      attr_accessor :valid_options
+    end
 
-    # Set by subclasses
-    class_attribute :macro
+    self.valid_options = [:class_name, :foreign_key, :validate]
 
-    attr_reader :model, :name, :options, :reflection
+    attr_reader :model, :name, :scope, :options, :reflection
 
-    def self.build(model, name, options)
-      new(model, name, options).build
+    def self.build(*args, &block)
+      new(*args, &block).build
     end
 
-    def initialize(model, name, options)
-      @model, @name, @options = model, name, options
+    def initialize(model, name, scope, options)
+      raise ArgumentError, "association names must be a Symbol" unless name.kind_of?(Symbol)
+
+      @model   = model
+      @name    = name
+
+      if scope.is_a?(Hash)
+        @scope   = nil
+        @options = scope
+      else
+        @scope   = scope
+        @options = options
+      end
+
+      if @scope && @scope.arity == 0
+        prev_scope = @scope
+        @scope = proc { instance_exec(&prev_scope) }
+      end
     end
 
     def mixin
       @model.generated_feature_methods
     end
 
+    include Module.new { def build; end }
+
     def build
       validate_options
-      reflection = model.create_reflection(self.class.macro, name, options, model)
       define_accessors
-      reflection
+      configure_dependency if options[:dependent]
+      @reflection = model.create_reflection(macro, name, scope, options, model)
+      super # provides an extension point
+      @reflection
     end
 
-    private
+    def macro
+      raise NotImplementedError
+    end
 
-      def validate_options
-        options.assert_valid_keys(self.class.valid_options)
-      end
+    def valid_options
+      Association.valid_options
+    end
 
-      def define_accessors
-        define_readers
-        define_writers
-      end
+    def validate_options
+      options.assert_valid_keys(valid_options)
+    end
+
+    def define_accessors
+      define_readers
+      define_writers
+    end
 
-      def define_readers
-        name = self.name
-        mixin.redefine_method(name) do |*params|
-          association(name).reader(*params)
+    def define_readers
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}(*args)
+          association(:#{name}).reader(*args)
         end
-      end
+      CODE
+    end
 
-      def define_writers
-        name = self.name
-        mixin.redefine_method("#{name}=") do |value|
-          association(name).writer(value)
+    def define_writers
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}=(value)
+          association(:#{name}).writer(value)
         end
+      CODE
+    end
+
+    def configure_dependency
+      unless valid_dependent_options.include? options[:dependent]
+        raise ArgumentError, "The :dependent option must be one of #{valid_dependent_options}, but is :#{options[:dependent]}"
+      end
+
+      if options[:dependent] == :restrict
+        ActiveSupport::Deprecation.warn(
+          "The :restrict option is deprecated. Please use :restrict_with_exception instead, which " \
+          "provides the same functionality."
+        )
       end
+
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{macro}_dependent_for_#{name}
+          association(:#{name}).handle_dependency
+        end
+      CODE
+
+      model.before_destroy "#{macro}_dependent_for_#{name}"
+    end
+
+    def valid_dependent_options
+      raise NotImplementedError
+    end
   end
 end