Merge branch 'master' into set_binds

* master: (2794 commits)
  doc, API example on how to use `Model#exists?` with multiple IDs. [ci skip]
  Restore DATABASE_URL even if it's nil in connection_handler test
  [ci skip] - error_messages_for has been deprecated since 2.3.8 - lets reduce any confusion for users
  Ensure Active Record connection consistency
  Revert "ask the fixture set for the sql statements"
  Check `respond_to` before delegation due to: https://github.com/ruby/ruby/commit/d781caaf313b8649948c107bba277e5ad7307314
  Adding Hash#compact and Hash#compact! methods
  MySQL version 4.1 was EOL on December 31, 2009 We should at least recommend modern versions of MySQL to users.
  clear cache on body close so that cache remains during rendering
  add a more restricted codepath for templates fixes #13390
  refactor generator tests to use block form of Tempfile
  Fix typo [ci skip]
  Move finish_template as the last public method in the generator
  Minor typos fix [ci skip]
  make `change_column_null` reversible. Closes #13576.
  create/drop test and development databases only if RAILS_ENV is nil
  Revert "Speedup String#to"
  typo fix in test name. [ci skip].
  `core_ext/string/access.rb` test what we are documenting.
  Fix typo in image_tag documentation
  ...

Conflicts:
	activerecord/lib/active_record/associations/join_dependency/join_association.rb
	activerecord/lib/active_record/relation/query_methods.rb

1 files changed, 57 insertions, 42 deletions

diff --git a/activerecord/lib/active_record/relation/predicate_builder.rb b/activerecord/lib/active_record/relation/predicate_builder.rb
index b7609c97b5..1252af7635 100644
--- a/activerecord/lib/active_record/relation/predicate_builder.rb
+++ b/activerecord/lib/active_record/relation/predicate_builder.rb
@@ -1,15 +1,26 @@
 module ActiveRecord
   class PredicateBuilder # :nodoc:
+    @handlers = []
+
+    autoload :RelationHandler, 'active_record/relation/predicate_builder/relation_handler'
+    autoload :ArrayHandler, 'active_record/relation/predicate_builder/array_handler'
+
+    def self.resolve_column_aliases(klass, hash)
+      hash = hash.dup
+      hash.keys.grep(Symbol) do |key|
+        if klass.attribute_alias? key
+          hash[klass.attribute_alias(key)] = hash.delete key
+        end
+      end
+      hash
+    end
+
     def self.build_from_hash(klass, attributes, default_table)
       queries = []
 
       attributes.each do |column, value|
         table = default_table
 
-        if column.is_a?(Symbol) && klass.attribute_aliases.key?(column.to_s)
-          column = klass.attribute_aliases[column.to_s]
-        end
-
         if value.is_a?(Hash)
           if value.empty?
             queries << '1=0'
@@ -44,9 +55,9 @@ module ActiveRecord
       #
       # 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)
+      if klass && reflection = klass.reflect_on_association(column.to_sym)
+        if reflection.polymorphic? && base_class = polymorphic_base_class_from_value(value)
+          queries << build(table[reflection.foreign_type], base_class)
         end
 
         column = reflection.foreign_key
@@ -56,6 +67,18 @@ module ActiveRecord
       queries
     end
 
+    def self.polymorphic_base_class_from_value(value)
+      case value
+      when Relation
+        value.klass.base_class
+      when Array
+        val = value.compact.first
+        val.class.base_class if val.is_a?(Base)
+      when Base
+        value.class.base_class
+      end
+    end
+
     def self.references(attributes)
       attributes.map do |key, value|
         if value.is_a?(Hash)
@@ -67,44 +90,36 @@ module ActiveRecord
       end.compact
     end
 
+    # Define how a class is converted to Arel nodes when passed to +where+.
+    # The handler can be any object that responds to +call+, and will be used
+    # for any value that +===+ the class given. For example:
+    #
+    #     MyCustomDateRange = Struct.new(:start, :end)
+    #     handler = proc do |column, range|
+    #       Arel::Nodes::Between.new(column,
+    #         Arel::Nodes::And.new([range.start, range.end])
+    #       )
+    #     end
+    #     ActiveRecord::PredicateBuilder.register_handler(MyCustomDateRange, handler)
+    def self.register_handler(klass, handler)
+      @handlers.unshift([klass, handler])
+    end
+
+    register_handler(BasicObject, ->(attribute, value) { attribute.eq(value) })
+    # FIXME: I think we need to deprecate this behavior
+    register_handler(Class, ->(attribute, value) { attribute.eq(value.name) })
+    register_handler(Base, ->(attribute, value) { attribute.eq(value.id) })
+    register_handler(Range, ->(attribute, value) { attribute.in(value) })
+    register_handler(Relation, RelationHandler.new)
+    register_handler(Array, ArrayHandler.new)
+
     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
-              attribute.in(values).or(attribute.eq(nil))
-            end
-          else
-            attribute.in(values)
-          end
+        handler_for(value).call(attribute, value)
+      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
+      def self.handler_for(object)
+        @handlers.detect { |klass, _| klass === object }.last
       end
   end
 end