activerecord 3.2.22.4 → 4.0.13

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,26 @@ module ActiveRecord
             end
 
             scope = scope.joins(join(foreign_table, constraint))
+          end
+
+          is_first_chain = i == 0
+          klass = is_first_chain ? self.klass : reflection.klass
 
-            unless conditions.empty?
-              scope = scope.where(sanitize(conditions, table))
+          # Exclude the scope of the association itself, because that
+          # was already merged in the #scope method.
+          scope_chain[i].each do |scope_chain_item|
+            item  = eval_scope(klass, scope_chain_item)
+
+            if scope_chain_item == self.reflection.scope
+              scope.merge! item.except(:where, :includes)
+            end
+
+            if is_first_chain
+              scope.includes! item.includes_values
             end
+
+            scope.where_values += item.where_values
+            scope.order_values |= item.order_values
           end
         end
 
@@ -114,19 +128,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

@@ -1,9 +1,14 @@
 module ActiveRecord
-  # = Active Record Belongs To Associations
+  # = Active Record Belongs To Association
   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
+        raise_on_type_mismatch!(record) if record
 
         update_counters(record)
         replace_keys(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/belongs_to_polymorphic_association.rb

@@ -22,7 +22,7 @@ module ActiveRecord
           reflection.polymorphic_inverse_of(record.class)
         end
 
-        def raise_on_type_mismatch(record)
+        def raise_on_type_mismatch!(record)
           # A polymorphic association cannot have a type mismatch, by definition
         end
 

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

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

@@ -1,10 +1,12 @@
-require 'active_support/core_ext/object/inclusion'
-
 module ActiveRecord::Associations::Builder
   class BelongsTo < SingularAssociation #:nodoc:
-    self.macro = :belongs_to
+    def macro
+      :belongs_to
+    end
 
-    self.valid_options += [:foreign_type, :polymorphic, :touch]
+    def valid_options
+      super + [:foreign_type, :polymorphic, :touch, :counter_cache]
+    end
 
     def constructable?
       !options[:polymorphic]
@@ -14,75 +16,90 @@ module ActiveRecord::Associations::Builder
       reflection = super
       add_counter_cache_callbacks(reflection) if options[:counter_cache]
       add_touch_callbacks(reflection)         if options[:touch]
-      configure_dependency
       reflection
     end
 
-    private
+    def add_counter_cache_callbacks(reflection)
+      cache_column = reflection.counter_cache_column
+      foreign_key = reflection.foreign_key
+      klass = reflection.class_name.safe_constantize
 
-      def add_counter_cache_callbacks(reflection)
-        cache_column = reflection.counter_cache_column
-        name         = self.name
-
-        method_name = "belongs_to_counter_cache_after_create_for_#{name}"
-        mixin.redefine_method(method_name) do
-          record = send(name)
-          record.class.increment_counter(cache_column, record.id) unless record.nil?
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def belongs_to_counter_cache_after_create_for_#{name}
+          if record = #{name}
+            record.class.increment_counter(:#{cache_column}, record.id)
+            @_after_create_counter_called = true
+          end
         end
-        model.after_create(method_name)
-
-        method_name = "belongs_to_counter_cache_before_destroy_for_#{name}"
-        mixin.redefine_method(method_name) do
-          record = send(name)
 
-          if record && !self.destroyed?
-            record.class.decrement_counter(cache_column, record.id)
+        def belongs_to_counter_cache_before_destroy_for_#{name}
+          unless destroyed_by_association && destroyed_by_association.foreign_key.to_sym == #{foreign_key.to_sym.inspect}
+            record = #{name}
+            if record && !self.destroyed?
+              record.class.decrement_counter(:#{cache_column}, record.id)
+            end
           end
         end
-        model.before_destroy(method_name)
-
-        model.send(:module_eval,
-          "#{reflection.class_name}.send(:attr_readonly,\"#{cache_column}\".intern) if defined?(#{reflection.class_name}) && #{reflection.class_name}.respond_to?(:attr_readonly)", __FILE__, __LINE__
-        )
-      end
-
-      def add_touch_callbacks(reflection)
-        name        = self.name
-        method_name = "belongs_to_touch_after_save_or_destroy_for_#{name}"
-        touch       = options[:touch]
 
-        mixin.redefine_method(method_name) do
-          record = send(name)
+        def belongs_to_counter_cache_after_update_for_#{name}
+          if (@_after_create_counter_called ||= false)
+            @_after_create_counter_called = false
+          elsif self.#{foreign_key}_changed? && !new_record? && #{constructable?}
+            model = #{klass}
+            foreign_key_was = self.#{foreign_key}_was
+            foreign_key = self.#{foreign_key}
 
-          unless record.nil?
-            if touch == true
-              record.touch
-            else
-              record.touch(touch)
+            if foreign_key && model.respond_to?(:increment_counter)
+              model.increment_counter(:#{cache_column}, foreign_key)
+            end
+            if foreign_key_was && model.respond_to?(:decrement_counter)
+              model.decrement_counter(:#{cache_column}, foreign_key_was)
             end
           end
         end
+      CODE
 
-        model.after_save(method_name)
-        model.after_touch(method_name)
-        model.after_destroy(method_name)
-      end
+      model.after_create   "belongs_to_counter_cache_after_create_for_#{name}"
+      model.before_destroy "belongs_to_counter_cache_before_destroy_for_#{name}"
+      model.after_update   "belongs_to_counter_cache_after_update_for_#{name}"
+      klass.attr_readonly cache_column if klass && klass.respond_to?(:attr_readonly)
+    end
 
-      def configure_dependency
-        if options[:dependent]
-          unless options[:dependent].in?([:destroy, :delete])
-            raise ArgumentError, "The :dependent option expects either :destroy or :delete (#{options[:dependent].inspect})"
-          end
+    def add_touch_callbacks(reflection)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def belongs_to_touch_after_save_or_destroy_for_#{name}
+          foreign_key_field = #{reflection.foreign_key.inspect}
+          old_foreign_id    = changed_attributes[foreign_key_field]
+
+          if old_foreign_id
+            association = association(:#{name})
+            reflection = association.reflection
+            if reflection.polymorphic?
+              klass = send("#{reflection.foreign_type}_was").constantize
+            else
+              klass = association.klass
+            end
+            old_record = klass.find_by(klass.primary_key => old_foreign_id)
 
-          method_name = "belongs_to_dependent_#{options[:dependent]}_for_#{name}"
-          model.send(:class_eval, <<-eoruby, __FILE__, __LINE__ + 1)
-            def #{method_name}
-              association = #{name}
-              association.#{options[:dependent]} if association
+            if old_record
+              old_record.touch #{options[:touch].inspect if options[:touch] != true}
             end
-          eoruby
-          model.after_destroy method_name
+          end
+
+          record = #{name}
+          if record && record.persisted?
+            record.touch #{options[:touch].inspect if options[:touch] != true}
+          end
         end
-      end
+      CODE
+
+      model.after_save    "belongs_to_touch_after_save_or_destroy_for_#{name}"
+      model.after_touch   "belongs_to_touch_after_save_or_destroy_for_#{name}"
+      model.after_destroy "belongs_to_touch_after_save_or_destroy_for_#{name}"
+    end
+
+    def valid_dependent_options
+      [:destroy, :delete]
+    end
   end
 end

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

@@ -1,24 +1,24 @@
+require 'active_record/associations'
+
 module ActiveRecord::Associations::Builder
   class CollectionAssociation < Association #:nodoc:
-    CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
-
-    self.valid_options += [
-      :table_name, :order, :group, :having, :limit, :offset, :uniq, :finder_sql,
-      :counter_sql, :before_add, :after_add, :before_remove, :after_remove
-    ]
 
-    attr_reader :block_extension
+    CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
 
-    def self.build(model, name, options, &extension)
-      new(model, name, options, &extension).build
+    def valid_options
+      super + [:table_name, :finder_sql, :counter_sql, :before_add,
+               :after_add, :before_remove, :after_remove, :extend]
     end
 
-    def initialize(model, name, options, &extension)
-      super(model, name, options)
+    attr_reader :block_extension, :extension_module
+
+    def initialize(*args, &extension)
+      super(*args)
       @block_extension = extension
     end
 
     def build
+      show_deprecation_warnings
       wrap_block_extension
       reflection = super
       CALLBACKS.each { |callback_name| define_callback(callback_name) }
@@ -29,47 +29,61 @@ module ActiveRecord::Associations::Builder
       true
     end
 
-    private
+    def show_deprecation_warnings
+      [:finder_sql, :counter_sql].each do |name|
+        if options.include? name
+          ActiveSupport::Deprecation.warn("The :#{name} association option is deprecated. Please find an alternative (such as using scopes).")
+        end
+      end
+    end
+
+    def wrap_block_extension
+      if block_extension
+        @extension_module = mod = Module.new(&block_extension)
+        silence_warnings do
+          model.parent.const_set(extension_module_name, mod)
+        end
 
-      def wrap_block_extension
-        options[:extend] = Array.wrap(options[:extend])
+        prev_scope = @scope
 
-        if block_extension
-          silence_warnings do
-            model.parent.const_set(extension_module_name, Module.new(&block_extension))
-          end
-          options[:extend].push("#{model.parent}::#{extension_module_name}".constantize)
+        if prev_scope
+          @scope = proc { |owner| instance_exec(owner, &prev_scope).extending(mod) }
+        else
+          @scope = proc { extending(mod) }
         end
       end
+    end
 
-      def extension_module_name
-        @extension_module_name ||= "#{model.to_s.demodulize}#{name.to_s.camelize}AssociationExtension"
-      end
+    def extension_module_name
+      @extension_module_name ||= "#{model.name.demodulize}#{name.to_s.camelize}AssociationExtension"
+    end
 
-      def define_callback(callback_name)
-        full_callback_name = "#{callback_name}_for_#{name}"
+    def define_callback(callback_name)
+      full_callback_name = "#{callback_name}_for_#{name}"
 
-        # TODO : why do i need method_defined? I think its because of the inheritance chain
-        model.class_attribute full_callback_name.to_sym unless model.method_defined?(full_callback_name)
-        model.send("#{full_callback_name}=", Array.wrap(options[callback_name.to_sym]))
-      end
+      # TODO : why do i need method_defined? I think its because of the inheritance chain
+      model.class_attribute full_callback_name.to_sym unless model.method_defined?(full_callback_name)
+      model.send("#{full_callback_name}=", Array(options[callback_name.to_sym]))
+    end
 
-      def define_readers
-        super
+    def define_readers
+      super
 
-        name = self.name
-        mixin.redefine_method("#{name.to_s.singularize}_ids") do
-          association(name).ids_reader
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name.to_s.singularize}_ids
+          association(:#{name}).ids_reader
         end
-      end
+      CODE
+    end
 
-      def define_writers
-        super
+    def define_writers
+      super
 
-        name = self.name
-        mixin.redefine_method("#{name.to_s.singularize}_ids=") do |ids|
-          association(name).ids_writer(ids)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name.to_s.singularize}_ids=(ids)
+          association(:#{name}).ids_writer(ids)
         end
-      end
+      CODE
+    end
   end
 end