activerecord 3.2.22.5 → 4.2.11.3

data/lib/active_record/relation/spawn_methods.rb

@@ -1,180 +1,79 @@
-require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/hash/slice'
+require 'active_record/relation/merger'
 
 module ActiveRecord
   module SpawnMethods
-    def merge(r)
-      return self unless r
-      return to_a & r if r.is_a?(Array)
 
-      merged_relation = clone
-
-      r = r.with_default_scope if r.default_scoped? && r.klass != klass
-
-      Relation::ASSOCIATION_METHODS.each do |method|
-        value = r.send(:"#{method}_values")
-
-        unless value.empty?
-          if method == :includes
-            merged_relation = merged_relation.includes(value)
-          else
-            merge_relation_method(merged_relation, method, value)
-          end
-        end
-      end
-
-      (Relation::MULTI_VALUE_METHODS - [:joins, :where, :order]).each do |method|
-        value = r.send(:"#{method}_values")
-        merge_relation_method(merged_relation, method, value) if value.present?
-      end
-
-      merge_joins(merged_relation, r)
-
-      merged_wheres = @where_values + r.where_values
-
-      unless @where_values.empty?
-        # Remove duplicate ARel attributes. Last one wins.
-        seen = Hash.new { |h,table| h[table] = {} }
-        merged_wheres = merged_wheres.reverse.reject { |w|
-          nuke = false
-          if w.respond_to?(:operator) && w.operator == :== &&
-            w.left.respond_to?(:relation)
-            name              = w.left.name
-            table             = w.left.relation.name
-            nuke              = seen[table][name]
-            seen[table][name] = true
-          end
-          nuke
-        }.reverse
-      end
-
-      merged_relation.where_values = merged_wheres
+    # This is overridden by Associations::CollectionProxy
+    def spawn #:nodoc:
+      clone
+    end
 
-      (Relation::SINGLE_VALUE_METHODS - [:lock, :create_with, :reordering]).each do |method|
-        value = r.send(:"#{method}_value")
-        merged_relation.send(:"#{method}_value=", value) unless value.nil?
+    # Merges in the conditions from <tt>other</tt>, if <tt>other</tt> is an <tt>ActiveRecord::Relation</tt>.
+    # Returns an array representing the intersection of the resulting records with <tt>other</tt>, if <tt>other</tt> is an array.
+    #
+    #   Post.where(published: true).joins(:comments).merge( Comment.where(spam: false) )
+    #   # Performs a single join query with both where conditions.
+    #
+    #   recent_posts = Post.order('created_at DESC').first(5)
+    #   Post.where(published: true).merge(recent_posts)
+    #   # Returns the intersection of all published posts with the 5 most recently created posts.
+    #   # (This is just an example. You'd probably want to do this with a single query!)
+    #
+    # Procs will be evaluated by merge:
+    #
+    #   Post.where(published: true).merge(-> { joins(:comments) })
+    #   # => Post.where(published: true).joins(:comments)
+    #
+    # This is mainly intended for sharing common conditions between multiple associations.
+    def merge(other)
+      if other.is_a?(Array)
+        to_a & other
+      elsif other
+        spawn.merge!(other)
+      else
+        self
       end
+    end
 
-      merged_relation.lock_value = r.lock_value unless merged_relation.lock_value
-
-      merged_relation = merged_relation.create_with(r.create_with_value) unless r.create_with_value.empty?
-
-      if (r.reordering_value)
-        # override any order specified in the original relation
-        merged_relation.reordering_value = true
-        merged_relation.order_values = r.order_values
+    def merge!(other) # :nodoc:
+      if other.is_a?(Hash)
+        Relation::HashMerger.new(self, other).merge
+      elsif other.is_a?(Relation)
+        Relation::Merger.new(self, other).merge
+      elsif other.respond_to?(:to_proc)
+        instance_exec(&other)
       else
-        # merge in order_values from r
-        merged_relation.order_values += r.order_values
+        raise ArgumentError, "#{other.inspect} is not an ActiveRecord::Relation"
       end
-
-      # Apply scope extension modules
-      merged_relation.send :apply_modules, r.extensions
-
-      merged_relation
     end
 
     # Removes from the query the condition(s) specified in +skips+.
     #
-    # Example:
-    #
     #   Post.order('id asc').except(:order)                  # discards the order condition
     #   Post.where('id > 10').order('id asc').except(:where) # discards the where condition but keeps the order
-    #
     def except(*skips)
-      result = self.class.new(@klass, table)
-      result.default_scoped = default_scoped
-
-      ((Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS) - skips).each do |method|
-        result.send(:"#{method}_values=", send(:"#{method}_values"))
-      end
-
-      (Relation::SINGLE_VALUE_METHODS - skips).each do |method|
-        result.send(:"#{method}_value=", send(:"#{method}_value"))
-      end
-
-      # Apply scope extension modules
-      result.send(:apply_modules, extensions)
-
-      result
+      relation_with values.except(*skips)
     end
 
     # Removes any condition from the query other than the one(s) specified in +onlies+.
     #
-    # Example:
-    #
     #   Post.order('id asc').only(:where)         # discards the order condition
     #   Post.order('id asc').only(:where, :order) # uses the specified order
-    #
     def only(*onlies)
-      result = self.class.new(@klass, table)
-      result.default_scoped = default_scoped
-
-      ((Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS) & onlies).each do |method|
-        result.send(:"#{method}_values=", send(:"#{method}_values"))
-      end
-
-      (Relation::SINGLE_VALUE_METHODS & onlies).each do |method|
-        result.send(:"#{method}_value=", send(:"#{method}_value"))
+      if onlies.any? { |o| o == :where }
+        onlies << :bind
       end
-
-      # Apply scope extension modules
-      result.send(:apply_modules, extensions)
-
-      result
-    end
-
-    VALID_FIND_OPTIONS = [ :conditions, :include, :joins, :limit, :offset, :extend,
-                           :order, :select, :readonly, :group, :having, :from, :lock ]
-
-    def apply_finder_options(options)
-      relation = clone
-      return relation unless options
-
-      options.assert_valid_keys(VALID_FIND_OPTIONS)
-      finders = options.dup
-      finders.delete_if { |key, value| value.nil? && key != :limit }
-
-      ([:joins, :select, :group, :order, :having, :limit, :offset, :from, :lock, :readonly] & finders.keys).each do |finder|
-        relation = relation.send(finder, finders[finder])
-      end
-
-      relation = relation.where(finders[:conditions]) if options.has_key?(:conditions)
-      relation = relation.includes(finders[:include]) if options.has_key?(:include)
-      relation = relation.extending(finders[:extend]) if options.has_key?(:extend)
-
-      relation
+      relation_with values.slice(*onlies)
     end
 
     private
 
-      def merge_joins(relation, other)
-        values = other.joins_values
-        return if values.blank?
-
-        if other.klass >= relation.klass
-          relation.joins_values += values
-        else
-          joins_dependency, rest = values.partition do |join|
-            case join
-            when Hash, Symbol, Array
-              true
-            else
-              false
-            end
-          end
-
-          join_dependency = ActiveRecord::Associations::JoinDependency.new(
-            other.klass,
-            joins_dependency,
-            []
-          )
-
-          relation.joins_values += join_dependency.join_associations + rest
-        end
-      end
-
-      def merge_relation_method(relation, method, value)
-        relation.send(:"#{method}_values=", relation.send(:"#{method}_values") + value)
+      def relation_with(values) # :nodoc:
+        result = Relation.create(klass, table, values)
+        result.extend(*extending_values) if extending_values.any?
+        result
       end
   end
 end