activerecord 5.0.7.2 → 5.1.0.beta1

data/lib/active_record/relation/merger.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/hash/keys'
+require "active_support/core_ext/hash/keys"
 
 module ActiveRecord
   class Relation
@@ -83,85 +83,81 @@ module ActiveRecord
 
       private
 
-      def merge_preloads
-        return if other.preload_values.empty? && other.includes_values.empty?
+        def merge_preloads
+          return if other.preload_values.empty? && other.includes_values.empty?
 
-        if other.klass == relation.klass
-          relation.preload!(*other.preload_values) unless other.preload_values.empty?
-          relation.includes!(other.includes_values) unless other.includes_values.empty?
-        else
-          reflection = relation.klass.reflect_on_all_associations.find do |r|
-            r.class_name == other.klass.name
-          end || return
+          if other.klass == relation.klass
+            relation.preload!(*other.preload_values) unless other.preload_values.empty?
+            relation.includes!(other.includes_values) unless other.includes_values.empty?
+          else
+            reflection = relation.klass.reflect_on_all_associations.find do |r|
+              r.class_name == other.klass.name
+            end || return
 
-          unless other.preload_values.empty?
-            relation.preload! reflection.name => other.preload_values
-          end
+            unless other.preload_values.empty?
+              relation.preload! reflection.name => other.preload_values
+            end
 
-          unless other.includes_values.empty?
-            relation.includes! reflection.name => other.includes_values
+            unless other.includes_values.empty?
+              relation.includes! reflection.name => other.includes_values
+            end
           end
         end
-      end
 
-      def merge_joins
-        return if other.joins_values.blank?
+        def merge_joins
+          return if other.joins_values.blank?
 
-        if other.klass == relation.klass
-          relation.joins!(*other.joins_values)
-        else
-          joins_dependency, rest = other.joins_values.partition do |join|
-            case join
-            when Hash, Symbol, Array
-              true
-            else
-              false
+          if other.klass == relation.klass
+            relation.joins!(*other.joins_values)
+          else
+            joins_dependency, rest = other.joins_values.partition do |join|
+              case join
+              when Hash, Symbol, Array
+                true
+              else
+                false
+              end
             end
-          end
-
-          join_dependency = ActiveRecord::Associations::JoinDependency.new(other.klass,
-                                                                           joins_dependency,
-                                                                           [])
-          relation.joins! rest
 
-          @relation = relation.joins join_dependency
-        end
-      end
+            join_dependency = ActiveRecord::Associations::JoinDependency.new(other.klass,
+                                                                             joins_dependency,
+                                                                             [])
+            relation.joins! rest
 
-      def merge_multi_values
-        if other.reordering_value
-          # override any order specified in the original relation
-          relation.reorder! other.order_values
-        elsif other.order_values
-          # merge in order_values from relation
-          relation.order! other.order_values
+            @relation = relation.joins join_dependency
+          end
         end
 
-        relation.extend(*other.extending_values) unless other.extending_values.blank?
-      end
+        def merge_multi_values
+          if other.reordering_value
+            # override any order specified in the original relation
+            relation.reorder! other.order_values
+          elsif other.order_values
+            # merge in order_values from relation
+            relation.order! other.order_values
+          end
 
-      def merge_single_values
-        if relation.from_clause.empty?
-          relation.from_clause = other.from_clause
+          relation.extend(*other.extending_values) unless other.extending_values.blank?
         end
-        relation.lock_value ||= other.lock_value
 
-        unless other.create_with_value.blank?
-          relation.create_with_value = (relation.create_with_value || {}).merge(other.create_with_value)
-        end
-      end
+        def merge_single_values
+          if relation.from_clause.empty?
+            relation.from_clause = other.from_clause
+          end
+          relation.lock_value ||= other.lock_value
 
-      CLAUSE_METHOD_NAMES = CLAUSE_METHODS.map do |name|
-        ["#{name}_clause", "#{name}_clause="]
-      end
+          unless other.create_with_value.blank?
+            relation.create_with_value = (relation.create_with_value || {}).merge(other.create_with_value)
+          end
+        end
 
-      def merge_clauses
-        CLAUSE_METHOD_NAMES.each do |(reader, writer)|
-          clause = relation.send(reader)
-          other_clause = other.send(reader)
-          relation.send(writer, clause.merge(other_clause))
+        def merge_clauses
+          CLAUSE_METHODS.each do |method|
+            clause = relation.get_value(method)
+            other_clause = other.get_value(method)
+            relation.set_value(method, clause.merge(other_clause))
+          end
         end
-      end
     end
   end
 end

data/lib/active_record/relation/predicate_builder.rb

@@ -1,13 +1,12 @@
 module ActiveRecord
   class PredicateBuilder # :nodoc:
-    require 'active_record/relation/predicate_builder/array_handler'
-    require 'active_record/relation/predicate_builder/association_query_handler'
-    require 'active_record/relation/predicate_builder/base_handler'
-    require 'active_record/relation/predicate_builder/basic_object_handler'
-    require 'active_record/relation/predicate_builder/class_handler'
-    require 'active_record/relation/predicate_builder/polymorphic_array_handler'
-    require 'active_record/relation/predicate_builder/range_handler'
-    require 'active_record/relation/predicate_builder/relation_handler'
+    require "active_record/relation/predicate_builder/array_handler"
+    require "active_record/relation/predicate_builder/association_query_handler"
+    require "active_record/relation/predicate_builder/base_handler"
+    require "active_record/relation/predicate_builder/basic_object_handler"
+    require "active_record/relation/predicate_builder/polymorphic_array_handler"
+    require "active_record/relation/predicate_builder/range_handler"
+    require "active_record/relation/predicate_builder/relation_handler"
 
     delegate :resolve_column_aliases, to: :table
 
@@ -15,11 +14,10 @@ module ActiveRecord
       @table = table
       @handlers = []
 
-      register_handler(BasicObject, BasicObjectHandler.new(self))
-      register_handler(Class, ClassHandler.new(self))
+      register_handler(BasicObject, BasicObjectHandler.new)
       register_handler(Base, BaseHandler.new(self))
-      register_handler(Range, RangeHandler.new(self))
-      register_handler(RangeHandler::RangeWithBinds, RangeHandler.new(self))
+      register_handler(Range, RangeHandler.new)
+      register_handler(RangeHandler::RangeWithBinds, RangeHandler.new)
       register_handler(Relation, RelationHandler.new)
       register_handler(Array, ArrayHandler.new(self))
       register_handler(AssociationQueryValue, AssociationQueryHandler.new(self))
@@ -36,23 +34,13 @@ module ActiveRecord
       create_binds_for_hash(attributes)
     end
 
-    def expand(column, value)
-      # 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)
-      value = AssociationQueryHandler.value_for(table, column, value) if table.associated_with?(column)
-      build(table.arel_attribute(column), value)
-    end
-
     def self.references(attributes)
       attributes.map do |key, value|
         if value.is_a?(Hash)
           key
         else
           key = key.to_s
-          key.split('.'.freeze).first if key.include?('.'.freeze)
+          key.split(".".freeze).first if key.include?(".".freeze)
         end
       end.compact
     end
@@ -76,93 +64,108 @@ module ActiveRecord
       handler_for(value).call(attribute, value)
     end
 
+    # TODO Change this to private once we've dropped Ruby 2.2 support.
+    # Workaround for Ruby 2.2 "private attribute?" warning.
     protected
 
-    attr_reader :table
+      attr_reader :table
 
-    def expand_from_hash(attributes)
-      return ["1=0"] if attributes.empty?
+      def expand_from_hash(attributes)
+        return ["1=0"] if attributes.empty?
 
-      attributes.flat_map do |key, value|
-        if value.is_a?(Hash)
-          associated_predicate_builder(key).expand_from_hash(value)
-        else
-          expand(key, value)
+        attributes.flat_map do |key, value|
+          if value.is_a?(Hash) && !table.has_column?(key)
+            associated_predicate_builder(key).expand_from_hash(value)
+          else
+            build(table.arel_attribute(key), value)
+          end
         end
       end
-    end
-
-
-    def create_binds_for_hash(attributes)
-      result = attributes.dup
-      binds = []
 
-      attributes.each do |column_name, value|
-        case value
-        when Hash
-          attrs, bvs = associated_predicate_builder(column_name).create_binds_for_hash(value)
-          result[column_name] = attrs
-          binds += bvs
-        when Relation
-          binds += value.bound_attributes
-        when Range
-          first = value.begin
-          last = value.end
-          unless first.respond_to?(:infinite?) && first.infinite?
-            binds << build_bind_param(column_name, first)
-            first = Arel::Nodes::BindParam.new
-          end
-          unless last.respond_to?(:infinite?) && last.infinite?
-            binds << build_bind_param(column_name, last)
-            last = Arel::Nodes::BindParam.new
+      def create_binds_for_hash(attributes)
+        result = attributes.dup
+        binds = []
+
+        attributes.each do |column_name, value|
+          case
+          when value.is_a?(Hash) && !table.has_column?(column_name)
+            attrs, bvs = associated_predicate_builder(column_name).create_binds_for_hash(value)
+            result[column_name] = attrs
+            binds += bvs
+            next
+          when value.is_a?(Relation)
+            binds += value.bound_attributes
+          when value.is_a?(Range) && !table.type(column_name).respond_to?(:subtype)
+            first = value.begin
+            last = value.end
+            unless first.respond_to?(:infinite?) && first.infinite?
+              binds << build_bind_param(column_name, first)
+              first = Arel::Nodes::BindParam.new
+            end
+            unless last.respond_to?(:infinite?) && last.infinite?
+              binds << build_bind_param(column_name, last)
+              last = Arel::Nodes::BindParam.new
+            end
+
+            result[column_name] = RangeHandler::RangeWithBinds.new(first, last, value.exclude_end?)
+          else
+            if can_be_bound?(column_name, value)
+              result[column_name] = Arel::Nodes::BindParam.new
+              binds << build_bind_param(column_name, value)
+            end
           end
 
-          result[column_name] = RangeHandler::RangeWithBinds.new(first, last, value.exclude_end?)
-        else
-          if can_be_bound?(column_name, value)
-            result[column_name] = Arel::Nodes::BindParam.new
-            binds << build_bind_param(column_name, value)
+          # 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 table.associated_with?(column_name)
+            result[column_name] = AssociationQueryHandler.value_for(table, column_name, value)
           end
         end
-      end
 
-      [result, binds]
-    end
+        [result, binds]
+      end
 
     private
 
-    def associated_predicate_builder(association_name)
-      self.class.new(table.associated_table(association_name))
-    end
-
-    def convert_dot_notation_to_hash(attributes)
-      dot_notation = attributes.select do |k, v|
-        k.include?(".".freeze) && !v.is_a?(Hash)
+      def associated_predicate_builder(association_name)
+        self.class.new(table.associated_table(association_name))
       end
 
-      dot_notation.each_key do |key|
-        table_name, column_name = key.split(".".freeze)
-        value = attributes.delete(key)
-        attributes[table_name] ||= {}
+      def convert_dot_notation_to_hash(attributes)
+        dot_notation = attributes.select do |k, v|
+          k.include?(".".freeze) && !v.is_a?(Hash)
+        end
 
-        attributes[table_name] = attributes[table_name].merge(column_name => value)
-      end
+        dot_notation.each_key do |key|
+          table_name, column_name = key.split(".".freeze)
+          value = attributes.delete(key)
+          attributes[table_name] ||= {}
 
-      attributes
-    end
+          attributes[table_name] = attributes[table_name].merge(column_name => value)
+        end
 
-    def handler_for(object)
-      @handlers.detect { |klass, _| klass === object }.last
-    end
+        attributes
+      end
 
-    def can_be_bound?(column_name, value)
-      !value.nil? &&
-        handler_for(value).is_a?(BasicObjectHandler) &&
-        !table.associated_with?(column_name)
-    end
+      def handler_for(object)
+        @handlers.detect { |klass, _| klass === object }.last
+      end
 
-    def build_bind_param(column_name, value)
-      Relation::QueryAttribute.new(column_name.to_s, value, table.type(column_name))
-    end
+      def can_be_bound?(column_name, value)
+        return if table.associated_with?(column_name)
+        case value
+        when Array, Range
+          table.type(column_name).respond_to?(:subtype)
+        else
+          !value.nil? && handler_for(value).is_a?(BasicObjectHandler)
+        end
+      end
+
+      def build_bind_param(column_name, value)
+        Relation::QueryAttribute.new(column_name.to_s, value, table.type(column_name))
+      end
   end
 end

data/lib/active_record/relation/predicate_builder/array_handler.rb

@@ -29,15 +29,17 @@ module ActiveRecord
         array_predicates.inject { |composite, predicate| composite.or(predicate) }
       end
 
+      # TODO Change this to private once we've dropped Ruby 2.2 support.
+      # Workaround for Ruby 2.2 "private attribute?" warning.
       protected
 
-      attr_reader :predicate_builder
+        attr_reader :predicate_builder
 
-      module NullPredicate # :nodoc:
-        def self.or(other)
-          other
+        module NullPredicate # :nodoc:
+          def self.or(other)
+            other
+          end
         end
-      end
     end
   end
 end

data/lib/active_record/relation/predicate_builder/association_query_handler.rb

@@ -2,13 +2,14 @@ module ActiveRecord
   class PredicateBuilder
     class AssociationQueryHandler # :nodoc:
       def self.value_for(table, column, value)
-        klass = if table.associated_table(column).polymorphic_association? && ::Array === value && value.first.is_a?(Base)
+        associated_table = table.associated_table(column)
+        klass = if associated_table.polymorphic_association? && ::Array === value && value.first.is_a?(Base)
           PolymorphicArrayValue
         else
           AssociationQueryValue
         end
 
-        klass.new(table.associated_table(column), value)
+        klass.new(associated_table, value)
       end
 
       def initialize(predicate_builder)
@@ -27,9 +28,11 @@ module ActiveRecord
         predicate_builder.build_from_hash(queries)
       end
 
+      # TODO Change this to private once we've dropped Ruby 2.2 support.
+      # Workaround for Ruby 2.2 "private attribute?" warning.
       protected
 
-      attr_reader :predicate_builder
+        attr_reader :predicate_builder
     end
 
     class AssociationQueryValue # :nodoc:
@@ -59,30 +62,27 @@ module ActiveRecord
 
       private
 
-      def primary_key
-        associated_table.association_primary_key(base_class)
-      end
+        def primary_key
+          associated_table.association_primary_key(base_class)
+        end
 
-      def polymorphic_base_class_from_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
+        def polymorphic_base_class_from_value
+          case value
+          when Relation
+            value.klass.base_class
+          when Base
+            value.class.base_class
+          end
         end
-      end
 
-      def convert_to_id(value)
-        case value
-        when Base
-          value._read_attribute(primary_key)
-        else
-          value
+        def convert_to_id(value)
+          case value
+          when Base
+            value._read_attribute(primary_key)
+          else
+            value
+          end
         end
-      end
     end
   end
 end