sskirby-activerecord 3.2.1

data/lib/active_record/associations/alias_tracker.rb

@@ -0,0 +1,79 @@
+require 'active_support/core_ext/string/conversions'
+
+module ActiveRecord
+  module Associations
+    # Keeps track of table aliases for ActiveRecord::Associations::ClassMethods::JoinDependency and
+    # ActiveRecord::Associations::ThroughAssociationScope
+    class AliasTracker # :nodoc:
+      attr_reader :aliases, :table_joins
+
+      # table_joins is an array of arel joins which might conflict with the aliases we assign here
+      def initialize(table_joins = [])
+        @aliases     = Hash.new { |h,k| h[k] = initial_count_for(k) }
+        @table_joins = table_joins
+      end
+
+      def aliased_table_for(table_name, aliased_name = nil)
+        table_alias = aliased_name_for(table_name, aliased_name)
+
+        if table_alias == table_name
+          Arel::Table.new(table_name)
+        else
+          Arel::Table.new(table_name).alias(table_alias)
+        end
+      end
+
+      def aliased_name_for(table_name, aliased_name = nil)
+        aliased_name ||= table_name
+
+        if aliases[table_name].zero?
+          # If it's zero, we can have our table_name
+          aliases[table_name] = 1
+          table_name
+        else
+          # Otherwise, we need to use an alias
+          aliased_name = connection.table_alias_for(aliased_name)
+
+          # Update the count
+          aliases[aliased_name] += 1
+
+          if aliases[aliased_name] > 1
+            "#{truncate(aliased_name)}_#{aliases[aliased_name]}"
+          else
+            aliased_name
+          end
+        end
+      end
+
+      private
+
+        def initial_count_for(name)
+          return 0 if Arel::Table === table_joins
+
+          # quoted_name should be downcased as some database adapters (Oracle) return quoted name in uppercase
+          quoted_name = connection.quote_table_name(name).downcase
+
+          counts = table_joins.map do |join|
+            if join.is_a?(Arel::Nodes::StringJoin)
+              # Table names + table aliases
+              join.left.downcase.scan(
+                /join(?:\s+\w+)?\s+(\S+\s+)?#{quoted_name}\son/
+              ).size
+            else
+              join.left.table_name == name ? 1 : 0
+            end
+          end
+
+          counts.sum
+        end
+
+        def truncate(name)
+          name.slice(0, connection.table_alias_length - 2)
+        end
+
+        def connection
+          ActiveRecord::Base.connection
+        end
+    end
+  end
+end

data/lib/active_record/associations/association.rb

@@ -0,0 +1,239 @@
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/object/inclusion'
+
+module ActiveRecord
+  module Associations
+    # = Active Record Associations
+    #
+    # This is the root class of all associations ('+ Foo' signifies an included module Foo):
+    #
+    #   Association
+    #     SingularAssociation
+    #       HasOneAssociation
+    #         HasOneThroughAssociation + ThroughAssociation
+    #       BelongsToAssociation
+    #         BelongsToPolymorphicAssociation
+    #     CollectionAssociation
+    #       HasAndBelongsToManyAssociation
+    #       HasManyAssociation
+    #         HasManyThroughAssociation + ThroughAssociation
+    class Association #:nodoc:
+      attr_reader :owner, :target, :reflection
+
+      delegate :options, :to => :reflection
+
+      def initialize(owner, reflection)
+        reflection.check_validity!
+
+        @target = nil
+        @owner, @reflection = owner, reflection
+        @updated = false
+
+        reset
+        reset_scope
+      end
+
+      # Returns the name of the table of the related class:
+      #
+      #   post.comments.aliased_table_name # => "comments"
+      #
+      def aliased_table_name
+        reflection.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
+      end
+
+      # Reloads the \target and returns +self+ on success.
+      def reload
+        reset
+        reset_scope
+        load_target
+        self unless target.nil?
+      end
+
+      # Has the \target been already \loaded?
+      def loaded?
+        @loaded
+      end
+
+      # Asserts the \target has been loaded setting the \loaded flag to +true+.
+      def loaded!
+        @loaded      = true
+        @stale_state = stale_state
+      end
+
+      # The target is stale if the target no longer points to the record(s) that the
+      # relevant foreign_key(s) refers to. If stale, the association accessor method
+      # on the owner will reload the target. It's up to subclasses to implement the
+      # state_state method if relevant.
+      #
+      # Note that if the target has not been loaded, it is not considered stale.
+      def stale_target?
+        loaded? && @stale_state != stale_state
+      end
+
+      # Sets the target of this association to <tt>\target</tt>, and the \loaded flag to +true+.
+      def target=(target)
+        @target = target
+        loaded!
+      end
+
+      def scoped
+        target_scope.merge(association_scope)
+      end
+
+      # The scope for this association.
+      #
+      # Note that the association_scope is merged into the target_scope only when the
+      # scoped method is called. This is because at that point the call may be surrounded
+      # by scope.scoping { ... } or with_scope { ... } etc, which affects the scope which
+      # actually gets built.
+      def association_scope
+        if klass
+          @association_scope ||= AssociationScope.new(self).scope
+        end
+      end
+
+      def reset_scope
+        @association_scope = nil
+      end
+
+      # Set the inverse association, if possible
+      def set_inverse_instance(record)
+        if record && invertible_for?(record)
+          inverse = record.association(inverse_reflection_for(record).name)
+          inverse.target = owner
+        end
+      end
+
+      # This class of the target. belongs_to polymorphic overrides this to look at the
+      # polymorphic_type field on the owner.
+      def klass
+        reflection.klass
+      end
+
+      # Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the
+      # through association's scope)
+      def target_scope
+        klass.scoped
+      end
+
+      # Loads the \target if needed and returns it.
+      #
+      # 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 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 find_target?
+          begin
+            if IdentityMap.enabled? && association_class && association_class.respond_to?(:base_class)
+              @target = IdentityMap.get(association_class, owner[reflection.foreign_key])
+            end
+          rescue NameError
+            nil
+          ensure
+            @target ||= find_target
+          end
+        end
+        loaded! unless loaded?
+        target
+      rescue ActiveRecord::RecordNotFound
+        reset
+      end
+
+      def interpolate(sql, record = nil)
+        if sql.respond_to?(:to_proc)
+          owner.send(:instance_exec, record, &sql)
+        else
+          sql
+        end
+      end
+
+      private
+
+        def find_target?
+          !loaded? && (!owner.new_record? || foreign_key_present?) && klass
+        end
+
+        def creation_attributes
+          attributes = {}
+
+          if reflection.macro.in?([:has_one, :has_many]) && !options[:through]
+            attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
+
+            if reflection.options[:as]
+              attributes[reflection.type] = owner.class.base_class.name
+            end
+          end
+
+          attributes
+        end
+
+        # Sets the owner attributes on the given record
+        def set_owner_attributes(record)
+          creation_attributes.each { |key, value| record[key] = value }
+        end
+
+        # Should be true if there is a foreign key present on the owner which
+        # references the target. This is used to determine whether we can load
+        # the target if the owner is currently a new record (and therefore
+        # without a key).
+        #
+        # Currently implemented by belongs_to (vanilla and polymorphic) and
+        # has_one/has_many :through associations which go through a belongs_to
+        def foreign_key_present?
+          false
+        end
+
+        # Raises ActiveRecord::AssociationTypeMismatch unless +record+ is of
+        # the kind of the class of the associated objects. Meant to be used as
+        # a sanity check when you are about to assign an associated record.
+        def raise_on_type_mismatch(record)
+          unless record.is_a?(reflection.klass) || record.is_a?(reflection.class_name.constantize)
+            message = "#{reflection.class_name}(##{reflection.klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
+            raise ActiveRecord::AssociationTypeMismatch, message
+          end
+        end
+
+        # Can be redefined by subclasses, notably polymorphic belongs_to
+        # The record parameter is necessary to support polymorphic inverses as we must check for
+        # the association in the specific class of the record.
+        def inverse_reflection_for(record)
+          reflection.inverse_of
+        end
+
+        # Is this association invertible? Can be redefined by subclasses.
+        def invertible_for?(record)
+          inverse_reflection_for(record)
+        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,
+        # 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|
+            record.assign_attributes(create_scope.except(*record.changed), :without_protection => true)
+          end
+        end
+    end
+  end
+end

data/lib/active_record/associations/association_scope.rb

@@ -0,0 +1,119 @@
+module ActiveRecord
+  module Associations
+    class AssociationScope #:nodoc:
+      include JoinHelper
+
+      attr_reader :association, :alias_tracker
+
+      delegate :klass, :owner, :reflection, :interpolate, :to => :association
+      delegate :chain, :conditions, :options, :source_options, :active_record, :to => :reflection
+
+      def initialize(association)
+        @association   = association
+        @alias_tracker = AliasTracker.new
+      end
+
+      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))
+
+        if options[:through] && !options[:include]
+          scope = scope.includes(source_options[:include])
+        end
+
+        scope = scope.uniq if options[:uniq]
+
+        add_constraints(scope)
+      end
+
+      private
+
+      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(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
+
+          conditions = self.conditions[i]
+
+          if reflection == chain.last
+            scope = scope.where(table[key].eq(owner[foreign_key]))
+
+            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 = { table.name => condition }
+              end
+
+              scope = scope.where(interpolate(condition))
+            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))
+
+            unless conditions.empty?
+              scope = scope.where(sanitize(conditions, table))
+            end
+          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
+
+    end
+  end
+end

data/lib/active_record/associations/belongs_to_association.rb

@@ -0,0 +1,79 @@
+module ActiveRecord
+  # = Active Record Belongs To Associations
+  module Associations
+    class BelongsToAssociation < SingularAssociation #:nodoc:
+      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 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)
+          record.nil? && owner[reflection.foreign_key] ||
+          record && record.id != owner[reflection.foreign_key]
+        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].to_s
+        end
+    end
+  end
+end