activerecord 3.2.22.4 → 4.0.13

data/lib/active_record/relation/predicate_builder.rb

@@ -1,63 +1,106 @@
 module ActiveRecord
   class PredicateBuilder # :nodoc:
-    def self.build_from_hash(engine, attributes, default_table, allow_table_name = true)
-      predicates = attributes.map do |column, value|
-        table = default_table
+    def self.build_from_hash(klass, attributes, default_table)
+      queries = []
 
-        if allow_table_name && value.is_a?(Hash)
-          table = Arel::Table.new(column, engine)
+      attributes.each do |column, value|
+        table = default_table
 
+        if value.is_a?(Hash)
           if value.empty?
-            '1 = 2'
+            queries << '1=0'
           else
-            build_from_hash(engine, value, table, false)
+            table       = Arel::Table.new(column, default_table.engine)
+            association = klass.reflect_on_association(column.to_sym)
+
+            value.each do |k, v|
+              queries.concat expand(association && association.klass, table, k, v)
+            end
           end
         else
           column = column.to_s
 
-          if allow_table_name && column.include?('.')
+          if column.include?('.')
             table_name, column = column.split('.', 2)
-            table = Arel::Table.new(table_name, engine)
+            table = Arel::Table.new(table_name, default_table.engine)
           end
 
-          attribute = table[column]
-
-          case value
-          when ActiveRecord::Relation
-            value = value.select(value.klass.arel_table[value.klass.primary_key]) if value.select_values.empty?
-            attribute.in(value.arel.ast)
-          when Array, ActiveRecord::Associations::CollectionProxy
-            values = value.to_a.map {|x| x.is_a?(ActiveRecord::Base) ? x.id : x}
-            ranges, values = values.partition {|v| v.is_a?(Range) || v.is_a?(Arel::Relation)}
-
-            array_predicates = ranges.map {|range| attribute.in(range)}
-
-            if values.include?(nil)
-              values = values.compact
-              if values.empty?
-                array_predicates << attribute.eq(nil)
-              else
-                array_predicates << attribute.in(values.compact).or(attribute.eq(nil))
-              end
+          queries.concat expand(klass, table, column, value)
+        end
+      end
+
+      queries
+    end
+
+    def self.expand(klass, table, column, value)
+      queries = []
+
+      # Find the foreign key when using queries such as:
+      # Post.where(author: author)
+      #
+      # For polymorphic relationships, find the foreign key and type:
+      # PriceEstimate.where(estimate_of: treasure)
+      if klass && value.class < Base && reflection = klass.reflect_on_association(column.to_sym)
+        if reflection.polymorphic?
+          queries << build(table[reflection.foreign_type], value.class.base_class)
+        end
+
+        column = reflection.foreign_key
+      end
+
+      queries << build(table[column], value)
+      queries
+    end
+
+    def self.references(attributes)
+      attributes.map do |key, value|
+        if value.is_a?(Hash)
+          key
+        else
+          key = key.to_s
+          key.split('.').first if key.include?('.')
+        end
+      end.compact
+    end
+
+    private
+      def self.build(attribute, value)
+        case value
+        when Array
+          values = value.to_a.map {|x| x.is_a?(Base) ? x.id : x}
+          ranges, values = values.partition {|v| v.is_a?(Range)}
+
+          values_predicate = if values.include?(nil)
+            values = values.compact
+
+            case values.length
+            when 0
+              attribute.eq(nil)
+            when 1
+              attribute.eq(values.first).or(attribute.eq(nil))
             else
-              array_predicates << attribute.in(values)
+              attribute.in(values).or(attribute.eq(nil))
             end
-
-            array_predicates.inject {|composite, predicate| composite.or(predicate)}
-          when Range, Arel::Relation
-            attribute.in(value)
-          when ActiveRecord::Base
-            attribute.eq(value.id)
-          when Class
-            # FIXME: I think we need to deprecate this behavior
-            attribute.eq(value.name)
           else
-            attribute.eq(value)
+            attribute.in(values)
           end
+
+          array_predicates = ranges.map { |range| attribute.in(range) }
+          array_predicates << values_predicate
+          array_predicates.inject { |composite, predicate| composite.or(predicate) }
+        when ActiveRecord::Relation
+          value = value.select(value.klass.arel_table[value.klass.primary_key]) if value.select_values.empty?
+          attribute.in(value.arel.ast)
+        when Range
+          attribute.in(value)
+        when ActiveRecord::Base
+          attribute.eq(value.id)
+        when Class
+          # FIXME: I think we need to deprecate this behavior
+          attribute.eq(value.name)
+        else
+          attribute.eq(value)
         end
       end
-
-      predicates.flatten
-    end
   end
 end