activerecord 1.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

@@ -0,0 +1,92 @@
+module ActiveRecord
+  # = 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
+
+        update_counters(record)
+        replace_keys(record)
+        set_inverse_instance(record)
+
+        @updated = true if record
+
+        self.target = record
+      end
+
+      def reset
+        super
+        @updated = false
+      end
+
+      def updated?
+        @updated
+      end
+
+      private
+
+        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
+        end
+
+        # 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 invertible_for?(record)
+          inverse = inverse_reflection_for(record)
+          inverse && inverse.macro == :has_one
+        end
+
+        def target_id
+          if options[:primary_key]
+            owner.send(reflection.name).try(:id)
+          else
+            owner[reflection.foreign_key]
+          end
+        end
+
+        def stale_state
+          owner[reflection.foreign_key] && owner[reflection.foreign_key].to_s
+        end
+    end
+  end
+end

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -0,0 +1,35 @@
+module ActiveRecord
+  # = Active Record Belongs To Polymorphic Association
+  module Associations
+    class BelongsToPolymorphicAssociation < BelongsToAssociation #:nodoc:
+      def klass
+        type = owner[reflection.foreign_type]
+        type.presence && type.constantize
+      end
+
+      private
+
+        def replace_keys(record)
+          super
+          owner[reflection.foreign_type] = record && record.class.base_class.name
+        end
+
+        def different_target?(record)
+          super || record.class != klass
+        end
+
+        def inverse_reflection_for(record)
+          reflection.polymorphic_inverse_of(record.class)
+        end
+
+        def raise_on_type_mismatch!(record)
+          # A polymorphic association cannot have a type mismatch, by definition
+        end
+
+        def stale_state
+          foreign_key = super
+          foreign_key && [foreign_key.to_s, owner[reflection.foreign_type].to_s]
+        end
+    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

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

@@ -0,0 +1,39 @@
+module ActiveRecord::Associations::Builder
+  class HasAndBelongsToMany < CollectionAssociation #:nodoc:
+    def macro
+      :has_and_belongs_to_many
+    end
+
+    def valid_options
+      super + [:join_table, :association_foreign_key, :delete_sql, :insert_sql]
+    end
+
+    def build
+      reflection = super
+      define_destroy_hook
+      reflection
+    end
+
+    def show_deprecation_warnings
+      super
+
+      [:delete_sql, :insert_sql].each do |name|
+        if options.include? name
+          ActiveSupport::Deprecation.warn("The :#{name} association option is deprecated. Please find an alternative (such as using has_many :through).")
+        end
+      end
+    end
+
+    def define_destroy_hook
+      name = self.name
+      model.send(:include, Module.new {
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def destroy_associations
+            association(:#{name}).delete_all
+            super
+          end
+        RUBY
+      })
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module ActiveRecord::Associations::Builder
+  class HasMany < CollectionAssociation #:nodoc:
+    def macro
+      :has_many
+    end
+
+    def valid_options
+      super + [:primary_key, :dependent, :as, :through, :source, :source_type, :inverse_of, :counter_cache]
+    end
+
+    def valid_dependent_options
+      [:destroy, :delete_all, :nullify, :restrict, :restrict_with_error, :restrict_with_exception]
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module ActiveRecord::Associations::Builder
+  class HasOne < SingularAssociation #:nodoc:
+    def macro
+      :has_one
+    end
+
+    def valid_options
+      valid = super + [:order, :as]
+      valid += [:through, :source, :source_type] if options[:through]
+      valid
+    end
+
+    def constructable?
+      !options[:through]
+    end
+
+    def configure_dependency
+      super unless options[:through]
+    end
+
+    def valid_dependent_options
+      [:destroy, :delete, :nullify, :restrict, :restrict_with_error, :restrict_with_exception]
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module ActiveRecord::Associations::Builder
+  class SingularAssociation < Association #:nodoc:
+    def valid_options
+      super + [:remote, :dependent, :counter_cache, :primary_key, :inverse_of]
+    end
+
+    def constructable?
+      true
+    end
+
+    def define_accessors
+      super
+      define_constructors if constructable?
+    end
+
+    def define_constructors
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def build_#{name}(*args, &block)
+          association(:#{name}).build(*args, &block)
+        end
+
+        def create_#{name}(*args, &block)
+          association(:#{name}).create(*args, &block)
+        end
+
+        def create_#{name}!(*args, &block)
+          association(:#{name}).create!(*args, &block)
+        end
+      CODE
+    end
+  end
+end