activerecord 3.0.0 → 4.0.0

data/lib/active_record/associations/association_scope.rb

@@ -0,0 +1,135 @@
+module ActiveRecord
+  module Associations
+    class AssociationScope #:nodoc:
+      include JoinHelper
+
+      attr_reader :association, :alias_tracker
+
+      delegate :klass, :owner, :reflection, :interpolate, :to => :association
+      delegate :chain, :scope_chain, :options, :source_options, :active_record, :to => :reflection
+
+      def initialize(association)
+        @association   = association
+        @alias_tracker = AliasTracker.new klass.connection
+      end
+
+      def scope
+        scope = klass.unscoped
+        scope.extending! Array(options[:extend])
+        add_constraints(scope)
+      end
+
+      private
+
+      def column_for(table_name, column_name)
+        columns = alias_tracker.connection.schema_cache.columns_hash(table_name)
+        columns[column_name]
+      end
+
+      def bind_value(scope, column, value)
+        substitute = alias_tracker.connection.substitute_at(
+          column, scope.bind_values.length)
+        scope.bind_values += [[column, value]]
+        substitute
+      end
+
+      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
+
+        chain.each_with_index do |reflection, i|
+          table, foreign_table = tables.shift, tables.first
+
+          if reflection.source_macro == :has_and_belongs_to_many
+            join_table = tables.shift
+
+            scope = scope.joins(join(
+              join_table,
+              table[reflection.association_primary_key].
+                eq(join_table[reflection.association_foreign_key])
+            ))
+
+            table, foreign_table = join_table, tables.first
+          end
+
+          if reflection.source_macro == :belongs_to
+            if reflection.options[:polymorphic]
+              key = reflection.association_primary_key(self.klass)
+            else
+              key = reflection.association_primary_key
+            end
+
+            foreign_key = reflection.foreign_key
+          else
+            key         = reflection.foreign_key
+            foreign_key = reflection.active_record_primary_key
+          end
+
+          if reflection == chain.last
+            bind_val = bind scope, table.table_name, key.to_s, owner[foreign_key]
+            scope    = scope.where(table[key].eq(bind_val))
+
+            if reflection.type
+              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])
+
+            if reflection.type
+              type = chain[i + 1].klass.base_class.name
+              constraint = constraint.and(table[reflection.type].eq(type))
+            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)
+
+            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
+            scope.order_values |= item.order_values
+          end
+        end
+
+        scope
+      end
+
+      def alias_suffix
+        reflection.name
+      end
+
+      def table_name_for(reflection)
+        if reflection == self.reflection
+          # If this is a polymorphic belongs_to, we want to get the klass from the
+          # association because it depends on the polymorphic_type attribute of
+          # the owner
+          klass.table_name
+        else
+          reflection.table_name
+        end
+      end
+
+      def eval_scope(klass, scope)
+        if scope.is_a?(Relation)
+          scope
+        else
+          klass.unscoped.instance_exec(owner, &scope)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/associations/belongs_to_association.rb

@@ -1,41 +1,27 @@
 module ActiveRecord
-  # = Active Record Belongs To Associations
+  # = Active Record Belongs To Association
   module Associations
-    class BelongsToAssociation < AssociationProxy #:nodoc:
-      def create(attributes = {})
-        replace(@reflection.create_association(attributes))
-      end
+    class BelongsToAssociation < SingularAssociation #:nodoc:
 
-      def build(attributes = {})
-        replace(@reflection.build_association(attributes))
+      def handle_dependency
+        target.send(options[:dependent]) if load_target
       end
 
       def replace(record)
-        counter_cache_name = @reflection.counter_cache_column
-
-        if record.nil?
-          if counter_cache_name && !@owner.new_record?
-            @reflection.klass.decrement_counter(counter_cache_name, previous_record_id) if @owner[@reflection.primary_key_name]
-          end
+        raise_on_type_mismatch!(record) if record
 
-          @target = @owner[@reflection.primary_key_name] = nil
-        else
-          raise_on_type_mismatch(record)
-
-          if counter_cache_name && !@owner.new_record? && record.id != @owner[@reflection.primary_key_name]
-            @reflection.klass.increment_counter(counter_cache_name, record.id)
-            @reflection.klass.decrement_counter(counter_cache_name, @owner[@reflection.primary_key_name]) if @owner[@reflection.primary_key_name]
-          end
+        update_counters(record)
+        replace_keys(record)
+        set_inverse_instance(record)
 
-          @target = (AssociationProxy === record ? record.target : record)
-          @owner[@reflection.primary_key_name] = record_id(record) unless record.new_record?
-          @updated = true
-        end
+        @updated = true if record
 
-        set_inverse_instance(record, @owner)
+        self.target = record
+      end
 
-        loaded
-        record
+      def reset
+        super
+        @updated = false
       end
 
       def updated?
@@ -43,48 +29,63 @@ module ActiveRecord
       end
 
       private
-        def find_target
-          find_method = if @reflection.options[:primary_key]
-                          "find_by_#{@reflection.options[:primary_key]}"
-                        else
-                          "find"
-                        end
-
-          options = @reflection.options.dup
-          (options.keys - [:select, :include, :readonly]).each do |key|
-            options.delete key
+
+        def find_target?
+          !loaded? && foreign_key_present? && klass
+        end
+
+        def update_counters(record)
+          counter_cache_name = reflection.counter_cache_column
+
+          if counter_cache_name && owner.persisted? && different_target?(record)
+            if record
+              record.class.increment_counter(counter_cache_name, record.id)
+            end
+
+            if foreign_key_present?
+              klass.decrement_counter(counter_cache_name, target_id)
+            end
           end
-          options[:conditions] = conditions
-
-          the_target = @reflection.klass.send(find_method,
-            @owner[@reflection.primary_key_name],
-            options
-          ) if @owner[@reflection.primary_key_name]
-          set_inverse_instance(the_target, @owner)
-          the_target
         end
 
-        def foreign_key_present
-          !@owner[@reflection.primary_key_name].nil?
+        # Checks whether record is different to the current target, without loading it
+        def different_target?(record)
+          if record.nil? 
+            owner[reflection.foreign_key] 
+          else
+            record.id != owner[reflection.foreign_key]
+          end
+        end
+
+        def replace_keys(record)
+          if record
+            owner[reflection.foreign_key] = record[reflection.association_primary_key(record.class)]
+          else
+            owner[reflection.foreign_key] = nil
+          end
+        end
+
+        def foreign_key_present?
+          owner[reflection.foreign_key]
         end
 
         # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
         # has_one associations.
-        def we_can_set_the_inverse_on_this?(record)
-          @reflection.has_inverse? && @reflection.inverse_of.macro == :has_one
+        def invertible_for?(record)
+          inverse = inverse_reflection_for(record)
+          inverse && inverse.macro == :has_one
         end
 
-        def record_id(record)
-          record.send(@reflection.options[:primary_key] || :id)
+        def target_id
+          if options[:primary_key]
+            owner.send(reflection.name).try(:id)
+          else
+            owner[reflection.foreign_key]
+          end
         end
 
-        def previous_record_id
-          @previous_record_id ||= if @reflection.options[:primary_key]
-                                    previous_record = @owner.send(@reflection.name)
-                                    previous_record.nil? ? nil : previous_record.id
-                                  else
-                                    @owner[@reflection.primary_key_name]
-                                  end
+        def stale_state
+          owner[reflection.foreign_key] && owner[reflection.foreign_key].to_s
         end
     end
   end

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -1,77 +1,34 @@
 module ActiveRecord
   # = Active Record Belongs To Polymorphic Association
   module Associations
-    class BelongsToPolymorphicAssociation < AssociationProxy #:nodoc:
-      def replace(record)
-        if record.nil?
-          @target = @owner[@reflection.primary_key_name] = @owner[@reflection.options[:foreign_type]] = nil
-        else
-          @target = (AssociationProxy === record ? record.target : record)
-
-          @owner[@reflection.primary_key_name] = record_id(record)
-          @owner[@reflection.options[:foreign_type]] = record.class.base_class.name.to_s
-
-          @updated = true
-        end
-
-        set_inverse_instance(record, @owner)
-        loaded
-        record
-      end
-
-      def updated?
-        @updated
+    class BelongsToPolymorphicAssociation < BelongsToAssociation #:nodoc:
+      def klass
+        type = owner[reflection.foreign_type]
+        type.presence && type.constantize
       end
 
       private
 
-        # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
-        # has_one associations.
-        def we_can_set_the_inverse_on_this?(record)
-          if @reflection.has_inverse?
-            inverse_association = @reflection.polymorphic_inverse_of(record.class)
-            inverse_association && inverse_association.macro == :has_one
-          else
-            false
-          end
-        end
-
-        def set_inverse_instance(record, instance)
-          return if record.nil? || !we_can_set_the_inverse_on_this?(record)
-          inverse_relationship = @reflection.polymorphic_inverse_of(record.class)
-          unless inverse_relationship.nil?
-            record.send(:"set_#{inverse_relationship.name}_target", instance)
-          end
+        def replace_keys(record)
+          super
+          owner[reflection.foreign_type] = record && record.class.base_class.name
         end
 
-        def find_target
-          return nil if association_class.nil?
-
-          target =
-            if @reflection.options[:conditions]
-              association_class.find(
-                @owner[@reflection.primary_key_name],
-                :select     => @reflection.options[:select],
-                :conditions => conditions,
-                :include    => @reflection.options[:include]
-              )
-            else
-              association_class.find(@owner[@reflection.primary_key_name], :select => @reflection.options[:select], :include => @reflection.options[:include])
-            end
-          set_inverse_instance(target, @owner)
-          target
+        def different_target?(record)
+          super || record.class != klass
         end
 
-        def foreign_key_present
-          !@owner[@reflection.primary_key_name].nil?
+        def inverse_reflection_for(record)
+          reflection.polymorphic_inverse_of(record.class)
         end
 
-        def record_id(record)
-          record.send(@reflection.options[:primary_key] || :id)
+        def raise_on_type_mismatch!(record)
+          # A polymorphic association cannot have a type mismatch, by definition
         end
 
-        def association_class
-          @owner[@reflection.options[:foreign_type]] ? @owner[@reflection.options[:foreign_type]].constantize : nil
+        def stale_state
+          foreign_key = super
+          foreign_key && [foreign_key.to_s, owner[reflection.foreign_type].to_s]
         end
     end
   end

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

@@ -0,0 +1,108 @@
+module ActiveRecord::Associations::Builder
+  class Association #:nodoc:
+    class << self
+      attr_accessor :valid_options
+    end
+
+    self.valid_options = [:class_name, :foreign_key, :validate]
+
+    attr_reader :model, :name, :scope, :options, :reflection
+
+    def self.build(*args, &block)
+      new(*args, &block).build
+    end
+
+    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
+      define_accessors
+      configure_dependency if options[:dependent]
+      @reflection = model.create_reflection(macro, name, scope, options, model)
+      super # provides an extension point
+      @reflection
+    end
+
+    def macro
+      raise NotImplementedError
+    end
+
+    def valid_options
+      Association.valid_options
+    end
+
+    def validate_options
+      options.assert_valid_keys(valid_options)
+    end
+
+    def define_accessors
+      define_readers
+      define_writers
+    end
+
+    def define_readers
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}(*args)
+          association(:#{name}).reader(*args)
+        end
+      CODE
+    end
+
+    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

@@ -0,0 +1,98 @@
+module ActiveRecord::Associations::Builder
+  class BelongsTo < SingularAssociation #:nodoc:
+    def macro
+      :belongs_to
+    end
+
+    def valid_options
+      super + [:foreign_type, :polymorphic, :touch]
+    end
+
+    def constructable?
+      !options[:polymorphic]
+    end
+
+    def build
+      reflection = super
+      add_counter_cache_callbacks(reflection) if options[:counter_cache]
+      add_touch_callbacks(reflection)         if options[:touch]
+      reflection
+    end
+
+    def add_counter_cache_callbacks(reflection)
+      cache_column = reflection.counter_cache_column
+      foreign_key = reflection.foreign_key
+
+      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
+
+        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}
+            record.class.decrement_counter(:#{cache_column}, record.id) unless record.nil?
+          end
+        end
+
+        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? && defined?(#{name.to_s.camelize})
+            model = #{name.to_s.camelize}
+            foreign_key_was = self.#{foreign_key}_was
+            foreign_key = self.#{foreign_key}
+
+            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_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 = reflection.class_name.safe_constantize
+      klass.attr_readonly cache_column if klass && klass.respond_to?(:attr_readonly)
+    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    = attribute_was(foreign_key_field)
+
+          if old_foreign_id
+            klass      = association(#{name.inspect}).klass
+            old_record = klass.find_by(klass.primary_key => old_foreign_id)
+
+            if old_record
+              old_record.touch #{options[:touch].inspect if options[:touch] != true}
+            end
+          end
+
+          record = #{name}
+          unless record.nil? || record.new_record?
+            record.touch #{options[:touch].inspect if options[:touch] != true}
+          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

@@ -0,0 +1,89 @@
+require 'active_record/associations'
+
+module ActiveRecord::Associations::Builder
+  class CollectionAssociation < Association #:nodoc:
+
+    CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
+
+    def valid_options
+      super + [:table_name, :finder_sql, :counter_sql, :before_add,
+               :after_add, :before_remove, :after_remove, :extend]
+    end
+
+    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) }
+      reflection
+    end
+
+    def writable?
+      true
+    end
+
+    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
+
+        prev_scope = @scope
+
+        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.name.demodulize}#{name.to_s.camelize}AssociationExtension"
+    end
+
+    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(options[callback_name.to_sym]))
+    end
+
+    def define_readers
+      super
+
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name.to_s.singularize}_ids
+          association(:#{name}).ids_reader
+        end
+      CODE
+    end
+
+    def define_writers
+      super
+
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name.to_s.singularize}_ids=(ids)
+          association(:#{name}).ids_writer(ids)
+        end
+      CODE
+    end
+  end
+end