MONGOID-5122 Mongoize embedded fields in the criteria selector (#5184)

* MONGOID-5122 mongoize embedded fields on query

* MONGOID-5122 add comment for get_serializer

* MONGOID-5122 fix tests

* MONGOID-5122 fix matcher and optional tests

* MONGOID-5122 evolve object on else

* MONGOID-5122 add evolve_range method

* MONGOID-5122 refactors + comments

* add comment

* MONGOID-5122 change to key arg

* MONGOID-5122 add @api private

Author: neilshweky

lib/mongoid/criteria.rb

@@ -230,7 +230,7 @@ def initialize(klass)
       @klass = klass
       @embedded = nil
       @none = nil
-      klass ? super(klass.aliased_fields, klass.fields) : super({}, {})
+      klass ? super(klass.aliased_fields, klass.fields, klass.relations) : super({}, {}, {})
     end
 
     # Merges another object with this +Criteria+ and returns a new criteria.

lib/mongoid/criteria/queryable.rb

@@ -59,11 +59,14 @@ def ==(other)
       #
       # @param [ Hash ] aliases The optional field aliases.
       # @param [ Hash ] serializers The optional field serializers.
+      # @param [ Hash ] associations The optional associations.
       # @param [ Symbol ] driver The driver being used.
-      def initialize(aliases = {}, serializers = {}, driver = :mongo)
+      #
+      # @api private
+      def initialize(aliases = {}, serializers = {}, associations = {}, driver = :mongo)
         @aliases, @driver, @serializers = aliases, driver.to_sym, serializers
         @options = Options.new(aliases, serializers)
-        @selector = Selector.new(aliases, serializers)
+        @selector = Selector.new(aliases, serializers, associations)
         @pipeline = Pipeline.new(aliases)
         @aggregating = nil
         yield(self) if block_given?

lib/mongoid/criteria/queryable/extensions/range.rb

@@ -43,13 +43,21 @@ def __evolve_time__
           # @example Evolve the range.
           #   (11231312..213123131).__evolve_range__
           #
+          # @param [ Object ] serializer The optional serializer for the field.
+          #
           # @return [ Hash ] The $gte/$lte range query.
-          def __evolve_range__
+          #
+          # @api private
+          def __evolve_range__(serializer: nil)
             __evolve_range_naive__.transform_values! do |value|
-              case value
-              when Time, DateTime then value.__evolve_time__
-              when Date then value.__evolve_date__
-              else value
+              if serializer
+                serializer.evolve(value)
+              else
+                case value
+                when Time, DateTime then value.__evolve_time__
+                when Date then value.__evolve_date__
+                else value
+                end
               end
             end
           end

lib/mongoid/criteria/queryable/selector.rb

@@ -139,6 +139,8 @@ def evolve(serializer, value)
             evolve_hash(serializer, value)
           when Array
             evolve_array(serializer, value)
+          when Range
+            evolve_range(serializer, value)
           else
             (serializer || value.class).evolve(value)
           end
@@ -182,6 +184,18 @@ def evolve_hash(serializer, value)
           end
         end
 
+        # Evolve a single key selection with range values.
+        #
+        # @param [ Object ] serializer The optional serializer for the field.
+        # @param [ Range ] value The Range to serialize.
+        #
+        # @return [ Range ] The serialized Range.
+        #
+        # @api private
+        def evolve_range(serializer, value)
+          value.__evolve_range__(serializer: serializer)
+        end
+
         # Determines if the selection is a multi-select, like an $and or $or or $nor
         # selection.
         #

lib/mongoid/criteria/queryable/smash.rb

@@ -8,8 +8,13 @@ module Queryable
       class Smash < Hash
 
         # @attribute [r] aliases The aliases.
+        attr_reader :aliases
+
         # @attribute [r] serializers The serializers.
-        attr_reader :aliases, :serializers
+        attr_reader :serializers
+
+        # @attribute [r] associations The associations.
+        attr_reader :associations
 
         # Perform a deep copy of the smash.
         #
@@ -18,7 +23,7 @@ class Smash < Hash
         #
         # @return [ Smash ] The copied hash.
         def __deep_copy__
-          self.class.new(aliases, serializers) do |copy|
+          self.class.new(aliases, serializers, associations) do |copy|
             each_pair do |key, value|
               copy.store(key, value.__deep_copy__)
             end
@@ -36,8 +41,8 @@ def __deep_copy__
         #   responsible for serializing values. The keys of the hash must be
         #   strings that match the field name, and the values must respond to
         #   #localized? and #evolve(object).
-        def initialize(aliases = {}, serializers = {})
-          @aliases, @serializers = aliases, serializers
+        def initialize(aliases = {}, serializers = {}, associations = {})
+          @aliases, @serializers, @associations = aliases, serializers, associations
           yield(self) if block_given?
         end
 
@@ -87,7 +92,39 @@ def localized_key(name, serializer)
         def storage_pair(key)
           field = key.to_s
           name = aliases[field] || field
-          [ name, serializers[name] ]
+          [ name, get_serializer(name) ]
+        end
+
+        private
+
+        # Retrieves the serializer for the given name. If the name exists in
+        # the serializers hash then return that immediately, otherwise
+        # recursively look through the associations and find the appropriate
+        # field.
+        #
+        # @param [ String ] name The name of the db field.
+        #
+        # @return [ Object ] The serializer.
+        def get_serializer(name)
+          if s = serializers[name]
+            s
+          else
+            klass = nil
+            serializer = nil
+            name.split('.').each do |meth|
+              fs = klass ? klass.fields : serializers
+              if field = fs[meth]
+                serializer = field
+              else
+                serializer = nil
+                rs = klass ? klass.associations : associations
+                if rel = rs[meth]
+                  klass = rel.klass
+                end
+              end
+            end
+            serializer
+          end
         end
       end
     end

spec/integration/matcher_examples_spec.rb

@@ -652,10 +652,12 @@
 
     describe 'range match on array element' do
 
+      let(:record) do
+        Record.new(producers: [123, 456])
+      end
+
       let!(:band) do
-        Band.create!(records: [
-          Record.new(producers: [123, 456]),
-        ])
+        Band.create!(records: [ record ])
       end
 
       describe 'MongoDB query' do
@@ -687,10 +689,8 @@
           band.records.where(producers: 100..200).first
         end
 
-        it 'raises InvalidQuery' do
-          lambda do
-            found_record
-          end.should raise_error(Mongoid::Errors::InvalidQuery)
+        it 'finds' do
+          expect(found_record).to eq(record)
         end
       end
     end

spec/mongoid/criteria/queryable/optional_spec.rb

@@ -146,7 +146,7 @@
       context "when using the mongo-1.x driver syntax" do
 
         let(:query) do
-          Mongoid::Query.new({}, {}, :mongo1x)
+          Mongoid::Query.new({}, {}, {}, :mongo1x)
         end
 
         context "when provided symbols" do
@@ -419,7 +419,7 @@
       context "when using the mongo-1.x driver syntax" do
 
         let(:query) do
-          Mongoid::Query.new({}, {}, :mongo1x)
+          Mongoid::Query.new({}, {}, {}, :mongo1x)
         end
 
         context "when provided symbols" do
@@ -1176,7 +1176,7 @@
       context "when using the mongo-1.x driver syntax" do
 
         let(:query) do
-          Mongoid::Query.new({}, {}, :mongo1x)
+          Mongoid::Query.new({}, {}, {}, :mongo1x)
         end
 
         context "when provided a hash" do

spec/mongoid/criteria_spec.rb

@@ -3967,6 +3967,14 @@ def self.ages; self; end
         expect(dup_criteria.selector).to eq({ "_id" => _id })
       end
     end
+
+    context "when querying an embedded field" do
+      let(:criteria) { Band.where("label.name": 12345) }
+
+      it "mongoizes the embedded field in the selector" do
+        expect(criteria.selector).to eq("label.name" => "12345")
+      end
+    end
   end
 
   describe "#for_js" do