mongoid 7.1.0.rc0 → 7.2.0.rc1

data/spec/mongoid/copyable_spec.rb

@@ -195,7 +195,7 @@ describe Mongoid::Copyable do
           I18n.enforce_available_locales = false
           I18n.locale = 'pt_BR'
           person.addresses.type(ShipmentAddress).each { |address| address.shipping_name = "Título" }
-          person.save
+          person.save!
         end
 
         after do
@@ -353,6 +353,83 @@ describe Mongoid::Copyable do
             end
           end
         end
+
+        context "when using a custom discriminator_key" do
+          before do
+            Person.discriminator_key = "dkey"
+          end
+
+          after do
+            Person.discriminator_key = nil
+          end
+
+          let(:copy) do
+            person.send(method)
+          end
+
+          before do
+            person[:versions] = [ { number: 1 } ]
+          end
+
+          it "copys embeds many documents" do
+            expect(copy.addresses).to eq(person.addresses)
+          end
+
+          it "copys deep embeds many documents" do
+            expect(copy.name.translations).to eq(person.name.translations)
+          end
+
+          it "sets the embedded many documents as new" do
+            expect(copy.addresses.first).to be_new_record
+          end
+
+          it "sets the deep embedded many documents as new" do
+            expect(copy.name.translations.first).to be_new_record
+          end
+
+          it "creates new embeds many instances" do
+            expect(copy.addresses).to_not equal(person.addresses)
+          end
+
+          it "creates new deep embeds many instances" do
+            expect(copy.name.translations).to_not equal(person.name.translations)
+          end
+
+          it "copys embeds one documents" do
+            expect(copy.name).to eq(person.name)
+          end
+
+          it "flags the embeds one documents as new" do
+            expect(copy.name).to be_new_record
+          end
+
+          it "creates a new embeds one instance" do
+            expect(copy.name).to_not equal(person.name)
+          end
+
+          context "when saving the copy" do
+
+            let(:reloaded) do
+              copy.reload
+            end
+
+            before do
+              copy.save(validate: false)
+            end
+
+            it "persists the attributes" do
+              expect(reloaded.title).to eq("Sir")
+            end
+
+            it "persists the embeds many relation" do
+              expect(reloaded.addresses).to eq(person.addresses)
+            end
+
+            it "persists the embeds one relation" do
+              expect(reloaded.name).to eq(person.name)
+            end
+          end
+        end
       end
 
       context "when the document is not new" do
@@ -517,6 +594,81 @@ describe Mongoid::Copyable do
           end
         end
       end
+
+      context "when cloning a document with an embedded child class and a custom discriminator value" do
+
+        before do
+          ShipmentAddress.discriminator_value = "dvalue"
+        end
+
+        after do
+          ShipmentAddress.discriminator_value = nil
+        end
+
+        let!(:shipment_address) do
+          person.addresses.build({}, ShipmentAddress)
+        end
+
+        before do
+          person.save
+        end
+
+        let!(:from_db) do
+          Person.find(person.id)
+        end
+
+        let(:copy) do
+          from_db.send(method)
+        end
+
+        it "copys embeds many documents" do
+          expect(copy.addresses).to eq(person.addresses)
+        end
+      end
+
+      context 'when cloning a document with embedded child that uses inheritance' do
+        let(:original) do
+          CopyableSpec::A.new(influencers: [child_cls.new])
+        end
+
+        let(:copy) do
+          original.send(method)
+        end
+
+        context 'embedded child is root of hierarchy' do
+          let(:child_cls) do
+            CopyableSpec::Influencer
+          end
+
+          before do
+            # When embedded class is the root in hierarchy, their
+            # discriminator value is not explicitly stored.
+            child_cls.discriminator_mapping[child_cls.name].should be nil
+          end
+
+          it 'works' do
+            copy.class.should be original.class
+            copy.object_id.should_not == original.object_id
+          end
+        end
+
+        context 'embedded child is leaf of hierarchy' do
+          let(:child_cls) do
+            CopyableSpec::Youtuber
+          end
+
+          before do
+            # When embedded class is a leaf in hierarchy, their
+            # discriminator value is explicitly stored.
+            child_cls.discriminator_mapping[child_cls.name].should_not be nil
+          end
+
+          it 'works' do
+            copy.class.should be original.class
+            copy.object_id.should_not == original.object_id
+          end
+        end
+      end
     end
   end
 end

data/spec/mongoid/copyable_spec_models.rb

@@ -6,6 +6,7 @@ module CopyableSpec
     include Mongoid::Document
 
     embeds_many :locations
+    embeds_many :influencers
   end
 
   class Location
@@ -17,4 +18,17 @@ module CopyableSpec
   class Building
     include Mongoid::Document
   end
+
+  class Influencer
+    include Mongoid::Document
+
+    embeds_many :blurbs
+  end
+
+  class Youtuber < Influencer
+  end
+
+  class Blurb
+    include Mongoid::Document
+  end
 end

data/spec/mongoid/criteria/queryable/extensions/regexp_raw_spec.rb

@@ -3,7 +3,7 @@
 
 require "spec_helper"
 
-describe Mongoid::Criteria::Queryable::Extensions::Regexp::Raw do
+describe Mongoid::Criteria::Queryable::Extensions::Regexp::Raw_ do
 
   describe ".evolve" do
 

data/spec/mongoid/criteria/queryable/extensions/regexp_spec.rb

@@ -11,7 +11,7 @@ describe Mongoid::Criteria::Queryable::Extensions::Regexp do
     context "when provided a regexp" do
 
       let(:regexp) do
-        /^[123]/
+        /\A[123]/
       end
 
       let(:evolved) do
@@ -26,7 +26,7 @@ describe Mongoid::Criteria::Queryable::Extensions::Regexp do
     context "when provided a string" do
 
       let(:regexp) do
-        "^[123]"
+        "\\A[123]"
       end
 
       let(:evolved) do
@@ -34,7 +34,7 @@ describe Mongoid::Criteria::Queryable::Extensions::Regexp do
       end
 
       it "returns the converted regexp" do
-        expect(evolved).to eq(/^[123]/)
+        expect(evolved).to eq(/\A[123]/)
       end
     end
 
@@ -43,7 +43,7 @@ describe Mongoid::Criteria::Queryable::Extensions::Regexp do
       context "when the elements are regexps" do
 
         let(:regexp) do
-          /^[123]/
+          /\A[123]/
         end
 
         let(:array) do
@@ -66,7 +66,7 @@ describe Mongoid::Criteria::Queryable::Extensions::Regexp do
       context "when the elements are strings" do
 
         let(:regexp) do
-          "^[123]"
+          "\\A[123]"
         end
 
         let(:evolved) do
@@ -74,7 +74,7 @@ describe Mongoid::Criteria::Queryable::Extensions::Regexp do
         end
 
         it "returns the regexps" do
-          expect(evolved).to eq([ /^[123]/ ])
+          expect(evolved).to eq([ /\A[123]/ ])
         end
       end
     end
@@ -83,7 +83,7 @@ describe Mongoid::Criteria::Queryable::Extensions::Regexp do
   describe "#regexp?" do
 
     let(:regexp) do
-      /^[123]/
+      /\A[123]/
     end
 
     it "returns true" do

data/spec/mongoid/criteria/queryable/extensions/string_spec.rb

@@ -318,7 +318,7 @@ describe String do
     context "when provided a regex" do
 
       let(:regex) do
-        /^[123]/
+        /\A[123]/.freeze
       end
 
       let(:evolved) do

data/spec/mongoid/criteria/queryable/extensions/time_spec.rb

@@ -354,23 +354,35 @@ describe Time do
 
   describe "#__evolve_date__" do
 
-    let(:time) do
-      Time.new(2010, 1, 1, 12, 0, 0)
-    end
-
     let(:evolved) do
       time.__evolve_date__
     end
 
-    it "returns midnight utc" do
-      expect(evolved).to eq(Time.utc(2010, 1, 1, 0, 0, 0))
+    context 'beginning of day' do
+      let(:time) do
+        Time.new(2010, 1, 1, 0, 0, 1).freeze
+      end
+
+      it "returns midnight utc" do
+        expect(evolved).to eq(Time.utc(2010, 1, 1, 0, 0, 0))
+      end
+    end
+
+    context 'end of day' do
+      let(:time) do
+        Time.new(2010, 1, 1, 23, 59, 59).freeze
+      end
+
+      it "returns midnight utc" do
+        expect(evolved).to eq(Time.utc(2010, 1, 1, 0, 0, 0))
+      end
     end
   end
 
   describe "#__evolve_time__" do
 
     let(:time) do
-      Time.new(2010, 1, 1, 12, 0, 0)
+      Time.new(2010, 1, 1, 12, 0, 0).freeze
     end
 
     let(:evolved) do

data/spec/mongoid/criteria/queryable/extensions/time_with_zone_spec.rb

@@ -325,10 +325,37 @@ describe ActiveSupport::TimeWithZone do
     end
   end
 
+  describe "#__evolve_date__" do
+
+    let(:evolved) do
+      time.__evolve_date__
+    end
+
+    context 'beginning of day' do
+      let(:time) do
+        time_zone.local(2010, 1, 1, 0, 0, 1).freeze
+      end
+
+      it "returns midnight utc" do
+        expect(evolved).to eq(Time.utc(2010, 1, 1, 0, 0, 0))
+      end
+    end
+
+    context 'end of day' do
+      let(:time) do
+        time_zone.local(2010, 1, 1, 23, 59, 59).freeze
+      end
+
+      it "returns midnight utc" do
+        expect(evolved).to eq(Time.utc(2010, 1, 1, 0, 0, 0))
+      end
+    end
+  end
+
   describe "#__evolve_time__" do
 
     let(:date) do
-      time_zone.local(2010, 1, 1, 12, 0, 0)
+      time_zone.local(2010, 1, 1, 12, 0, 0).freeze
     end
 
     let(:evolved) do

data/spec/mongoid/criteria/queryable/mergeable_spec.rb

@@ -5,11 +5,11 @@ require "spec_helper"
 
 describe Mongoid::Criteria::Queryable::Mergeable do
 
-  describe "#intersect" do
+  let(:query) do
+    Mongoid::Query.new
+  end
 
-    let(:query) do
-      Mongoid::Query.new
-    end
+  describe "#intersect" do
 
     before do
       query.intersect
@@ -22,10 +22,6 @@ describe Mongoid::Criteria::Queryable::Mergeable do
 
   describe "#override" do
 
-    let(:query) do
-      Mongoid::Query.new
-    end
-
     before do
       query.override
     end
@@ -37,10 +33,6 @@ describe Mongoid::Criteria::Queryable::Mergeable do
 
   describe "#union" do
 
-    let(:query) do
-      Mongoid::Query.new
-    end
-
     before do
       query.union
     end
@@ -49,4 +41,45 @@ describe Mongoid::Criteria::Queryable::Mergeable do
       expect(query.strategy).to eq(:__union__)
     end
   end
+
+  describe '#_mongoid_expand_keys' do
+    it 'expands simple keys' do
+      query.send(:_mongoid_expand_keys, {a: 1}).should == {a: 1}
+    end
+
+    let(:gt) do
+      Mongoid::Criteria::Queryable::Key.new("age", :__override__, "$gt")
+    end
+
+    let(:gtp) do
+      Mongoid::Criteria::Queryable::Key.new("age", :__override__, "$gt")
+    end
+
+    let(:lt) do
+      Mongoid::Criteria::Queryable::Key.new("age", :__override__, "$lt")
+    end
+
+    it 'expands Key instances' do
+      query.send(:_mongoid_expand_keys, {gt => 42}).should == {'age' => {'$gt' => 42}}
+    end
+
+    it 'expands multiple Key instances on the same field' do
+      query.send(:_mongoid_expand_keys, {gt => 42, lt => 50}).should == {
+        'age' => {'$gt' => 42, '$lt' => 50}}
+    end
+
+    it 'expands simple and Key instances on the same field' do
+      query.send(:_mongoid_expand_keys, {'age' => 42, lt => 50}).should == {
+        'age' => {'$eq' => 42, '$lt' => 50}}
+    end
+
+    it 'expands Key and simple instances on the same field' do
+      query.send(:_mongoid_expand_keys, {gt => 42, 'age' => 50}).should == {
+        'age' => {'$gt' => 42, '$eq' => 50}}
+    end
+
+    it 'Ruby does not allow same symbol operator with different values' do
+      {gt => 42, gtp => 50}.should == {gtp => 50}
+    end
+  end
 end

data/spec/mongoid/criteria/queryable/selectable_logical_spec.rb

@@ -16,110 +16,12 @@ describe Mongoid::Criteria::Queryable::Selectable do
     end
   end
 
-  shared_examples_for 'a non-combining logical operation' do
+  # Hoisting means the operator can be elided, for example
+  # Foo.and(a: 1) produces simply {'a' => 1}.
+  shared_examples_for 'a hoisting logical operation' do
 
-    context 'when there is a single predicate' do
-      let(:query) do
-        Mongoid::Query.new.send(tested_method, hello: 'world')
-      end
-
-      it 'adds the predicate' do
-        expect(query.selector).to eq(expected_operator => [{'hello' => 'world'}])
-      end
-    end
-
-    context 'when the single predicate is wrapped in an array' do
-      let(:query) do
-        Mongoid::Query.new.send(tested_method, [{hello: 'world'}])
-      end
-
-      it 'adds the predicate' do
-        expect(query.selector).to eq(expected_operator => [{'hello' => 'world'}])
-      end
-    end
-
-    context 'when argument is a Criteria' do
-      let(:query) do
-        Mongoid::Query.new.where(hello: 'world')
-      end
-
-      let(:other) do
-        Mongoid::Query.new.where(foo: 'bar')
-      end
-
-      let(:result) { query.send(tested_method, other) }
-
-      it 'combines' do
-        # This is used for $or / $nor, the two conditions should remain
-        # as separate hashes
-        expect(result.selector).to eq(expected_operator => [{'hello' => 'world'}, {'foo' => 'bar'}])
-      end
-    end
-
-    context 'when argument is a mix of Criteria and hashes' do
-      let(:query) do
-        Mongoid::Query.new.where(hello: 'world')
-      end
-
-      let(:other1) do
-        Mongoid::Query.new.where(foo: 'bar')
-      end
-
-      let(:other2) do
-        {bar: 42}
-      end
-
-      let(:other3) do
-        Mongoid::Query.new.where(a: 2)
-      end
-
-      let(:result) { query.send(tested_method, other1, other2, other3) }
-
-      it 'combines' do
-        expect(result.selector).to eq(expected_operator => [
-          {'hello' => 'world'},
-          {'foo' => 'bar'},
-          {'bar' => 42},
-          {'a' => 2},
-        ])
-      end
-    end
-  end
-
-  describe "#and" do
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.and
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it_behaves_like 'returns a cloned query'
-    end
-
-    context "when provided nil" do
-
-      let(:selection) do
-        query.and(nil)
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it_behaves_like 'returns a cloned query'
+    let(:query) do
+      Mongoid::Query.new
     end
 
     context "when provided a single criterion" do
@@ -127,23 +29,23 @@ describe Mongoid::Criteria::Queryable::Selectable do
       shared_examples_for 'adds the conditions to top level' do
 
         it "adds the conditions to top level" do
-          expect(selection.selector).to eq({
+          expect(selection.selector).to eq(
             "field" => [ 1, 2 ]
-          })
+          )
         end
 
         it_behaves_like 'returns a cloned query'
       end
 
       let(:selection) do
-        query.and(field: [ 1, 2 ])
+        query.send(tested_method, field: [ 1, 2 ])
       end
 
       it_behaves_like 'adds the conditions to top level'
 
       context 'when the criterion is wrapped in an array' do
         let(:selection) do
-          query.and([{field: [ 1, 2 ] }])
+          query.send(tested_method, [{field: [ 1, 2 ] }])
         end
 
         it_behaves_like 'adds the conditions to top level'
@@ -151,20 +53,39 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
       context 'when the criterion is wrapped in a deep array with nil elements' do
         let(:selection) do
-          query.and([[[{field: [ 1, 2 ] }]], [nil]])
+          query.send(tested_method, [[[{field: [ 1, 2 ] }]], [nil]])
         end
 
         it_behaves_like 'adds the conditions to top level'
       end
     end
 
+    context 'when argument is a Criteria' do
+      let(:base) do
+        query.where(hello: 'world')
+      end
+
+      let(:other) do
+        query.where(foo: 'bar')
+      end
+
+      let(:result) { base.send(tested_method, other) }
+
+      it 'combines' do
+        expect(result.selector).to eq(
+          'hello' => 'world',
+          'foo' => 'bar',
+        )
+      end
+    end
+
     context "when provided a single criterion that is handled via Key" do
 
       shared_examples_for 'adds the conditions to top level' do
 
         it "adds the conditions to top level" do
           expect(selection.selector).to eq({
-            "field" => {'$gt' => 3 },
+            "field" => {'$gt' => 3},
           })
         end
 
@@ -172,14 +93,14 @@ describe Mongoid::Criteria::Queryable::Selectable do
       end
 
       let(:selection) do
-        query.and(:field.gt => 3)
+        query.send(tested_method, :field.gt => 3)
       end
 
       it_behaves_like 'adds the conditions to top level'
 
       context 'when the criterion is wrapped in an array' do
         let(:selection) do
-          query.and([{ :field.gt => 3 }])
+          query.send(tested_method, [{ :field.gt => 3 }])
         end
 
         it_behaves_like 'adds the conditions to top level'
@@ -187,81 +108,74 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
       context 'when the criterion is wrapped in a deep array with nil elements' do
         let(:selection) do
-          query.and([[[{ :field.gt => 3 }]], [nil]])
+          query.send(tested_method, [[[{ :field.gt => 3 }]], [nil]])
         end
 
         it_behaves_like 'adds the conditions to top level'
       end
-    end
-
-    context "when provided a nested criterion" do
-
-      let(:selection) do
-        query.and(:test.elem_match => { :field.in => [ 1, 2 ] })
-      end
-
-      it "builds the correct selector" do
-        expect(selection.selector).to eq({
-          "test" => { "$elemMatch" => { "field" => { "$in" => [ 1, 2 ] }}}
-        })
-      end
-
-      it_behaves_like 'returns a cloned query'
-    end
-
-    context "when provided multiple criteria" do
-
-      context "when the criteria is already included" do
 
+      context 'when the criterion is a time' do
         let(:selection) do
-          query.and({ first: [ 1, 2 ] }).and({ first: [ 1, 2 ] })
+          query.send(tested_method, :field.gte => Time.new(2020, 1, 1))
         end
 
-        it "adds all conditions" do
+        it 'adds the conditions' do
           expect(selection.selector).to eq({
-            'first' => [1, 2],
-            "$and" => [
-              { "first" => [ 1, 2 ] }
-            ]
+            "field" => {'$gte' => Time.new(2020, 1, 1)},
           })
         end
 
-        it_behaves_like 'returns a cloned query'
+        it 'keeps argument type' do
+          selection.selector['field']['$gte'].should be_a(Time)
+        end
       end
 
-      context "when the new criterion is for different fields" do
-
+      context 'when the criterion is a datetime' do
         let(:selection) do
-          query.and({ first: [ 1, 2 ] }, { second: [ 3, 4 ] })
+          query.send(tested_method, :field.gte => DateTime.new(2020, 1, 1))
         end
 
-        it "adds all conditions to top level" do
+        it 'adds the conditions' do
           expect(selection.selector).to eq({
-            "first" => [ 1, 2 ],
-            "second" => [ 3, 4 ],
+            "field" => {'$gte' => Time.utc(2020, 1, 1)},
           })
         end
 
-        it_behaves_like 'returns a cloned query'
+        it 'converts argument to a time' do
+          selection.selector['field']['$gte'].should be_a(Time)
+        end
       end
 
-      context "when the new criterion is for the same field" do
-
+      context 'when the criterion is a date' do
         let(:selection) do
-          query.and({ first: [ 1, 2 ] }, { first: [ 3, 4 ] })
+          query.send(tested_method, :field.gte => Date.new(2020, 1, 1))
         end
 
-        it "combines via $and operator" do
+        it 'adds the conditions' do
           expect(selection.selector).to eq({
-            "first" => [ 1, 2 ],
-            "$and" => [
-              { "first" => [ 3, 4 ] }
-            ]
+            "field" => {'$gte' => Time.utc(2020, 1, 1)},
           })
         end
 
-        it_behaves_like 'returns a cloned query'
+        it 'converts argument to a time' do
+          selection.selector['field']['$gte'].should be_a(Time)
+        end
+      end
+    end
+
+    context "when provided a nested criterion" do
+
+      let(:selection) do
+        query.send(tested_method, :test.elem_match => { :field.in => [ 1, 2 ] })
+      end
+
+      it "builds the correct selector" do
+        expect(selection.selector).to eq({
+          "test" => { "$elemMatch" => { "field" => { "$in" => [ 1, 2 ] }}}
+        })
       end
+
+      it_behaves_like 'returns a cloned query'
     end
 
     context "when chaining the criteria" do
@@ -269,7 +183,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
       context "when the criteria are for different fields" do
 
         let(:selection) do
-          query.and(first: [ 1, 2 ]).and(second: [ 3, 4 ])
+          query.and(first: [ 1, 2 ]).send(tested_method, second: [ 3, 4 ])
         end
 
         it "adds the conditions to top level" do
@@ -285,7 +199,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
       context "when the criteria are on the same field" do
 
         let(:selection) do
-          query.and(first: [ 1, 2 ]).and(first: [ 3, 4 ])
+          query.and(first: [ 1, 2 ]).send(tested_method, first: [ 3, 4 ])
         end
 
         it "combines via $and operator" do
@@ -300,34 +214,47 @@ describe Mongoid::Criteria::Queryable::Selectable do
         it_behaves_like 'returns a cloned query'
       end
     end
+  end
 
-    context 'when argument is a Criteria' do
+  # Non-hoisting means the operator is always present, for example
+  # Foo.or(a: 1) produces {'$or' => [{'a' => 1}]}.
+  shared_examples_for 'a non-hoisting logical operation' do
+
+    context 'when there is a single predicate' do
       let(:query) do
-        Mongoid::Query.new.where(hello: 'world')
+        Mongoid::Query.new.send(tested_method, hello: 'world')
       end
 
-      let(:result) { query.and(other) }
+      it 'adds the predicate' do
+        expect(query.selector).to eq(expected_operator => [{'hello' => 'world'}])
+      end
+    end
 
-      context 'different fields' do
+    context 'when the single predicate is wrapped in an array' do
+      let(:query) do
+        Mongoid::Query.new.send(tested_method, [{hello: 'world'}])
+      end
 
-        let(:other) do
-          Mongoid::Query.new.where(foo: 'bar')
-        end
+      it 'adds the predicate' do
+        expect(query.selector).to eq(expected_operator => [{'hello' => 'world'}])
+      end
+    end
 
-        it 'combines both fields at top level' do
-          expect(result.selector).to eq('hello' => 'world', 'foo' => 'bar')
-        end
+    context 'when argument is a Criteria' do
+      let(:query) do
+        Mongoid::Query.new.where(hello: 'world')
       end
 
-      context 'same field' do
+      let(:other) do
+        Mongoid::Query.new.where(foo: 'bar')
+      end
 
-        let(:other) do
-          Mongoid::Query.new.where(hello: /bar/)
-        end
+      let(:result) { query.send(tested_method, other) }
 
-        it 'combines fields with $and' do
-          expect(result.selector).to eq('hello' => 'world', '$and' => [{'hello' => /bar/}])
-        end
+      it 'combines' do
+        # This is used for $or / $nor, the two conditions should remain
+        # as separate hashes
+        expect(result.selector).to eq(expected_operator => [{'hello' => 'world'}, {'foo' => 'bar'}])
       end
     end
 
@@ -348,40 +275,344 @@ describe Mongoid::Criteria::Queryable::Selectable do
         Mongoid::Query.new.where(a: 2)
       end
 
-      let(:result) { query.and(other1, other2, other3) }
+      let(:result) { query.send(tested_method, other1, other2, other3) }
 
       it 'combines' do
-        expect(result.selector).to eq('hello' => 'world',
-          'foo' => 'bar',
-          'bar' => 42,
-          'a' => 2,
-        )
+        expect(result.selector).to eq(expected_operator => [
+          {'hello' => 'world'},
+          {'foo' => 'bar'},
+          {'bar' => 42},
+          {'a' => 2},
+        ])
       end
     end
+  end
 
-    context 'when Key instances are used and types involved have serializers' do
-      let(:time) { Time.now }
+  describe "#and" do
 
-      let(:query) do
-        Band.all.and(:created_at.gt => time)
+    let(:tested_method) { :and }
+    let(:expected_operator) { '$and' }
+
+    it_behaves_like 'a hoisting logical operation'
+
+    context "when provided no criterion" do
+
+      let(:selection) do
+        query.and
       end
 
-      let(:expected) do
-        {'created_at' => {'$gt' => time.utc}}
+      it "does not add any criterion" do
+        expect(selection.selector).to eq({})
       end
 
-      it 'combines and evolves' do
-        expect(query.selector).to eq(expected)
+      it "returns the query" do
+        expect(selection).to eq(query)
       end
+
+      it_behaves_like 'returns a cloned query'
     end
 
-    describe 'query shape' do
-      shared_examples_for 'adds most recent criterion as $and' do
-        let(:selector) { scope.selector }
+    context "when provided nil" do
 
-        it 'adds most recent criterion as $and' do
-          expect(selector).to eq('foo' => 1, '$and' => [{'foo' => 2}])
-        end
+      let(:selection) do
+        query.and(nil)
+      end
+
+      it "does not add any criterion" do
+        expect(selection.selector).to eq({})
+      end
+
+      it "returns the query" do
+        expect(selection).to eq(query)
+      end
+
+      it_behaves_like 'returns a cloned query'
+    end
+
+    context "when provided multiple criteria" do
+
+      context "when the criterion is already included" do
+
+        context 'simple criterion' do
+          let(:selection) do
+            query.and({ first: [ 1, 2 ] }).and({ first: [ 1, 2 ] })
+          end
+
+          it "adds all conditions" do
+            expect(selection.selector).to eq({
+              'first' => [1, 2],
+              "$and" => [
+                { "first" => [ 1, 2 ] }
+              ]
+            })
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        context 'Key criterion' do
+          let(:selection) do
+            query.and({ first: [ 1, 2 ] }).and(:first.gt => 3)
+          end
+
+          it "adds all conditions" do
+            expect(selection.selector).to eq({
+              'first' => [1, 2],
+              "$and" => [
+                { "first" => {'$gt' => 3} }
+              ]
+            })
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        context 'Key criterion when existing criterion is an operator' do
+          let(:selection) do
+            query.and(:first.lt => 5).and(:first.gt => 3)
+          end
+
+          it "adds all conditions" do
+            expect(selection.selector).to eq({
+              'first' => {'$lt' => 5, '$gt' => 3},
+            })
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+      end
+
+      context "when the new criteria are for different fields" do
+
+        let(:selection) do
+          query.and({ first: [ 1, 2 ] }, { second: [ 3, 4 ] })
+        end
+
+        it "adds all conditions to top level" do
+          expect(selection.selector).to eq({
+            "first" => [ 1, 2 ],
+            "second" => [ 3, 4 ],
+          })
+        end
+
+        it_behaves_like 'returns a cloned query'
+      end
+
+      context "when the new criteria are for the same field" do
+
+        context 'when criteria are simple' do
+          let(:selection) do
+            query.and({ first: [ 1, 2 ] }, { first: [ 3, 4 ] })
+          end
+
+          it "combines via $and operator" do
+            expect(selection.selector).to eq({
+              "first" => [ 1, 2 ],
+              "$and" => [
+                { "first" => [ 3, 4 ] }
+              ]
+            })
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        context 'when criteria are handled via Key' do
+          shared_examples_for 'adds the conditions to top level' do
+
+            it "adds the conditions to top level" do
+              expect(selection.selector).to eq({
+                "field" => {'$gt' => 3, '$lt' => 5},
+              })
+            end
+
+            it_behaves_like 'returns a cloned query'
+          end
+
+          context 'criteria are provided in the same hash' do
+            let(:selection) do
+              query.send(tested_method, :field.gt => 3, :field.lt => 5)
+            end
+
+            it_behaves_like 'adds the conditions to top level'
+          end
+
+          context 'criteria are provided in separate hashes' do
+            let(:selection) do
+              query.send(tested_method, {:field.gt => 3}, {:field.lt => 5})
+            end
+
+            it_behaves_like 'adds the conditions to top level'
+          end
+
+          context 'when the criterion is wrapped in an array' do
+            let(:selection) do
+              query.send(tested_method, [:field.gt => 3], [:field.lt => 5])
+            end
+
+            it_behaves_like 'adds the conditions to top level'
+          end
+        end
+
+        context 'when criteria are simple and handled via Key' do
+          shared_examples_for 'combines conditions with $and' do
+
+            it "combines conditions with $and" do
+              expect(selection.selector).to eq({
+                "field" => 3,
+                '$and' => ['field' => {'$lt' => 5}],
+              })
+            end
+
+            it_behaves_like 'returns a cloned query'
+          end
+
+          context 'criteria are provided in the same hash' do
+            let(:selection) do
+              query.send(tested_method, :field => 3, :field.lt => 5)
+            end
+
+            it_behaves_like 'combines conditions with $and'
+          end
+
+          context 'criteria are provided in separate hashes' do
+            let(:selection) do
+              query.send(tested_method, {:field => 3}, {:field.lt => 5})
+            end
+
+            it_behaves_like 'combines conditions with $and'
+          end
+
+          context 'when the criterion is wrapped in an array' do
+            let(:selection) do
+              query.send(tested_method, [:field => 3], [:field.lt => 5])
+            end
+
+            it_behaves_like 'combines conditions with $and'
+          end
+        end
+
+        context 'when criteria are handled via Key and simple' do
+          shared_examples_for 'combines conditions with $and' do
+
+            it "combines conditions with $and" do
+              expect(selection.selector).to eq({
+                "field" => {'$gt' => 3},
+                '$and' => ['field' => 5],
+              })
+            end
+
+            it_behaves_like 'returns a cloned query'
+          end
+
+          context 'criteria are provided in the same hash' do
+            let(:selection) do
+              query.send(tested_method, :field.gt => 3, :field => 5)
+            end
+
+            it_behaves_like 'combines conditions with $and'
+          end
+
+          context 'criteria are provided in separate hashes' do
+            let(:selection) do
+              query.send(tested_method, {:field.gt => 3}, {:field => 5})
+            end
+
+            it_behaves_like 'combines conditions with $and'
+          end
+
+          context 'when the criterion is wrapped in an array' do
+            let(:selection) do
+              query.send(tested_method, [:field.gt => 3], [:field => 5])
+            end
+
+            it_behaves_like 'combines conditions with $and'
+          end
+        end
+      end
+    end
+
+    context 'when argument is a Criteria' do
+      let(:query) do
+        Mongoid::Query.new.where(hello: 'world')
+      end
+
+      let(:result) { query.and(other) }
+
+      context 'different fields' do
+
+        let(:other) do
+          Mongoid::Query.new.where(foo: 'bar')
+        end
+
+        it 'combines both fields at top level' do
+          expect(result.selector).to eq('hello' => 'world', 'foo' => 'bar')
+        end
+      end
+
+      context 'same field' do
+
+        let(:other) do
+          Mongoid::Query.new.where(hello: /bar/)
+        end
+
+        it 'combines fields with $and' do
+          expect(result.selector).to eq('hello' => 'world', '$and' => [{'hello' => /bar/}])
+        end
+      end
+    end
+
+    context 'when argument is a mix of Criteria and hashes' do
+      let(:query) do
+        Mongoid::Query.new.where(hello: 'world')
+      end
+
+      let(:other1) do
+        Mongoid::Query.new.where(foo: 'bar')
+      end
+
+      let(:other2) do
+        {bar: 42}
+      end
+
+      let(:other3) do
+        Mongoid::Query.new.where(a: 2)
+      end
+
+      let(:result) { query.and(other1, other2, other3) }
+
+      it 'combines' do
+        expect(result.selector).to eq('hello' => 'world',
+          'foo' => 'bar',
+          'bar' => 42,
+          'a' => 2,
+        )
+      end
+    end
+
+    context 'when Key instances are used and types involved have serializers' do
+      let(:time) { Time.now }
+
+      let(:query) do
+        Band.all.and(:created_at.gt => time)
+      end
+
+      let(:expected) do
+        {'created_at' => {'$gt' => time.utc}}
+      end
+
+      it 'combines and evolves' do
+        expect(query.selector).to eq(expected)
+      end
+    end
+
+    describe 'query shape' do
+      shared_examples_for 'adds most recent criterion as $and' do
+        let(:selector) { scope.selector }
+
+        it 'adds most recent criterion as $and' do
+          expect(selector).to eq('foo' => 1, '$and' => [{'foo' => 2}])
+        end
       end
 
       context 'and/and' do
@@ -405,38 +636,463 @@ describe Mongoid::Criteria::Queryable::Selectable do
           Band.and(foo: 1).where(foo: 2)
         end
 
-        it_behaves_like 'adds most recent criterion as $and'
+        it_behaves_like 'adds most recent criterion as $and'
+      end
+
+      context 'where/and' do
+        let(:scope) do
+          Band.where(foo: 1).and(foo: 2)
+        end
+
+        it_behaves_like 'adds most recent criterion as $and'
+      end
+
+      context 'where/where' do
+        let(:scope) do
+          Band.where(foo: 1).where(foo: 2)
+        end
+
+        it_behaves_like 'adds most recent criterion as $and'
+      end
+    end
+
+    context 'when conditions already exist in criteria' do
+      let(:base_selection) do
+        query.where(foo: 'bar')
+      end
+
+      context 'when hash conditions are given' do
+        let(:selection) do
+          base_selection.and(hello: 'world')
+        end
+
+        it 'adds new conditions to top level' do
+          selection.selector.should == {
+            'foo' => 'bar',
+            'hello' => 'world',
+          }
+        end
+      end
+
+      context 'when criteria conditions are given' do
+        let(:selection) do
+          base_selection.and(query.where(hello: 'world'))
+        end
+
+        it 'adds new conditions to top level' do
+          selection.selector.should == {
+            'foo' => 'bar',
+            'hello' => 'world',
+          }
+        end
+      end
+
+      context 'when complex criteria conditions are given' do
+        let(:selection) do
+          base_selection.and(query.or([one: 'one'], [two: 'two']))
+        end
+
+        it 'adds new conditions to top level' do
+          selection.selector.should == {
+            'foo' => 'bar',
+            '$or' => [
+              {'one' => 'one'},
+              {'two' => 'two'},
+            ],
+          }
+        end
+      end
+    end
+  end
+
+  shared_examples '$or/$nor' do
+
+    it_behaves_like 'a non-hoisting logical operation'
+
+    context "when provided no arguments" do
+
+      let(:selection) do
+        query.send(tested_method)
+      end
+
+      it_behaves_like 'returns a cloned query'
+
+      it "does not add any criteria" do
+        expect(selection.selector).to eq({})
+      end
+
+      it "returns the query" do
+        expect(selection).to eq(query)
+      end
+    end
+
+    context "when provided nil" do
+
+      let(:selection) do
+        query.send(tested_method, nil)
+      end
+
+      it_behaves_like 'returns a cloned query'
+
+      it "does not add any criteria" do
+        expect(selection.selector).to eq({})
+      end
+
+      it "returns the query" do
+        expect(selection).to eq(query)
+      end
+    end
+
+    context "when provided a single criterion" do
+
+      let(:selection) do
+        query.send(tested_method, field: [ 1, 2 ])
+      end
+
+      it_behaves_like 'returns a cloned query'
+
+      it "adds the $or/$nor selector" do
+        expect(selection.selector).to eq({
+          expected_operator => [{ "field" => [ 1, 2 ] }]
+        })
+      end
+
+      context 'when the criterion is wrapped in array' do
+
+        let(:selection) do
+          query.send(tested_method, [{ field: [ 1, 2 ] }])
+        end
+
+        it_behaves_like 'returns a cloned query'
+
+        it "adds the $or/$nor selector" do
+          expect(selection.selector).to eq({
+            expected_operator => [{ "field" => [ 1, 2 ] }]
+          })
+        end
+
+        context 'when the array has nil as one of the elements' do
+
+          let(:selection) do
+            query.send(tested_method, [{ field: [ 1, 2 ] }, nil])
+          end
+
+          it_behaves_like 'returns a cloned query'
+
+          it "adds the $or/$nor selector ignoring the nil element" do
+            expect(selection.selector).to eq({
+              expected_operator => [{ "field" => [ 1, 2 ] }]
+            })
+          end
+        end
+      end
+
+      context 'when query already has a condition on another field' do
+
+        let(:selection) do
+          query.where(foo: 'bar').send(tested_method, field: [ 1, 2 ])
+        end
+
+        it 'moves original conditions under $or/$nor' do
+          expect(selection.selector).to eq({
+            expected_operator => [{'foo' => 'bar'}, { "field" => [ 1, 2 ] }]
+          })
+        end
+      end
+
+      context 'when query already has an $or/$nor condition and another condition' do
+
+        let(:selection) do
+          query.send(tested_method, field: [ 1, 2 ]).where(foo: 'bar').send(tested_method, test: 1)
+        end
+
+        it 'unions existing conditions' do
+          expect(selection.selector).to eq(
+            expected_operator => [
+              {
+                expected_operator => [{ "field" => [ 1, 2 ] }],
+                'foo' => 'bar',
+              },
+              {'test' => 1},
+            ]
+          )
+        end
+      end
+    end
+
+    context "when provided multiple criteria" do
+
+      context "when the criteria are for different fields" do
+
+        let(:selection) do
+          query.send(tested_method, { first: [ 1, 2 ] }, { second: [ 3, 4 ] })
+        end
+
+        it_behaves_like 'returns a cloned query'
+
+        it "adds the $or/$nor selector" do
+          expect(selection.selector).to eq({
+            expected_operator => [
+              { "first" => [ 1, 2 ] },
+              { "second" => [ 3, 4 ] }
+            ]
+          })
+        end
+      end
+
+      context "when the criteria uses a Key instance" do
+
+        let(:selection) do
+          query.send(tested_method, { first: [ 1, 2 ] }, { :second.gt => 3 })
+        end
+
+        it "adds the $or/$nor selector" do
+          expect(selection.selector).to eq({
+            expected_operator => [
+              { "first" => [ 1, 2 ] },
+              { "second" => { "$gt" => 3 }}
+            ]
+          })
+        end
+
+        it_behaves_like 'returns a cloned query'
+
+        context 'when the criterion is a time' do
+          let(:selection) do
+            query.send(tested_method, :field.gte => Time.new(2020, 1, 1))
+          end
+
+          it 'adds the conditions' do
+            expect(selection.selector).to eq(expected_operator => [
+              "field" => {'$gte' => Time.new(2020, 1, 1)},
+            ])
+          end
+
+          it 'keeps the type' do
+            selection.selector[expected_operator].first['field']['$gte'].should be_a(Time)
+          end
+        end
+
+        context 'when the criterion is a datetime' do
+          let(:selection) do
+            query.send(tested_method, :field.gte => DateTime.new(2020, 1, 1))
+          end
+
+          it 'adds the conditions' do
+            expect(selection.selector).to eq(expected_operator => [
+              "field" => {'$gte' => Time.utc(2020, 1, 1)},
+            ])
+          end
+
+          it 'converts argument to a time' do
+            selection.selector[expected_operator].first['field']['$gte'].should be_a(Time)
+          end
+        end
+
+        context 'when the criterion is a date' do
+          let(:selection) do
+            query.send(tested_method, :field.gte => Date.new(2020, 1, 1))
+          end
+
+          it 'adds the conditions' do
+            expect(selection.selector).to eq(expected_operator => [
+              "field" => {'$gte' => Time.utc(2020, 1, 1)},
+            ])
+          end
+
+          it 'converts argument to a time' do
+            selection.selector[expected_operator].first['field']['$gte'].should be_a(Time)
+          end
+        end
+      end
+
+      context "when a criterion has an aliased field" do
+
+        let(:selection) do
+          query.send(tested_method, { id: 1 })
+        end
+
+        it "adds the $or/$nor selector and aliases the field" do
+          expect(selection.selector).to eq({
+            expected_operator => [ { "_id" => 1 } ]
+          })
+        end
+
+        it_behaves_like 'returns a cloned query'
+      end
+
+      context "when a criterion is wrapped in an array" do
+
+        let(:selection) do
+          query.send(tested_method, [{ first: [ 1, 2 ] }, { :second.gt => 3 }])
+        end
+
+        it_behaves_like 'returns a cloned query'
+
+        it "adds the $or/$nor selector" do
+          expect(selection.selector).to eq({
+            expected_operator => [
+              { "first" => [ 1, 2 ] },
+              { "second" => { "$gt" => 3 }}
+            ]
+          })
+        end
+      end
+
+      context "when the criteria are on the same field" do
+
+        context 'simple criteria' do
+          let(:selection) do
+            query.send(tested_method, { first: [ 1, 2 ] }, { first: [ 3, 4 ] })
+          end
+
+          it_behaves_like 'returns a cloned query'
+
+          it "appends both $or/$nor expressions" do
+            expect(selection.selector).to eq({
+              expected_operator => [
+                { "first" => [ 1, 2 ] },
+                { "first" => [ 3, 4 ] }
+              ]
+            })
+          end
+        end
+
+        context 'Key criteria as one argument' do
+          let(:selection) do
+            query.send(tested_method, :first.gt => 3, :first.lt => 5)
+          end
+
+          it_behaves_like 'returns a cloned query'
+
+          it "adds all criteria" do
+            expect(selection.selector).to eq({
+              expected_operator => [
+                { "first" => {'$gt' => 3, '$lt' => 5} },
+              ]
+            })
+          end
+        end
+
+        context 'Key criteria as multiple arguments' do
+          let(:selection) do
+            query.send(tested_method, {:first.gt => 3}, {:first.lt => 5})
+          end
+
+          it_behaves_like 'returns a cloned query'
+
+          it "adds all criteria" do
+            expect(selection.selector).to eq({
+              expected_operator => [
+                { "first" => {'$gt' => 3} },
+                { "first" => {'$lt' => 5} },
+              ]
+            })
+          end
+        end
+      end
+    end
+
+    context "when chaining the criterion" do
+
+      context "when the criterion are for different fields" do
+
+        let(:selection) do
+          query.send(tested_method, first: [ 1, 2 ]).send(tested_method, second: [ 3, 4 ])
+        end
+
+        it_behaves_like 'returns a cloned query'
+
+        it "adds the $or/$nor selectors" do
+          expect(selection.selector).to eq({
+            expected_operator => [
+              { "first" => [ 1, 2 ] },
+              { "second" => [ 3, 4 ] }
+            ]
+          })
+        end
+      end
+
+      context "when the criterion are on the same field" do
+
+        let(:selection) do
+          query.send(tested_method, first: [ 1, 2 ]).send(tested_method, first: [ 3, 4 ])
+        end
+
+        it_behaves_like 'returns a cloned query'
+
+        it "appends both $or/$nor expressions" do
+          expect(selection.selector).to eq({
+            expected_operator => [
+              { "first" => [ 1, 2 ] },
+              { "first" => [ 3, 4 ] }
+            ]
+          })
+        end
+      end
+    end
+  end
+
+  describe "#or" do
+
+    let(:tested_method) { :or }
+    let(:expected_operator) { '$or' }
+
+    it_behaves_like '$or/$nor'
+  end
+
+  describe "#nor" do
+
+    let(:tested_method) { :nor }
+    let(:expected_operator) { '$nor' }
+
+    it_behaves_like '$or/$nor'
+  end
+
+  describe "#any_of" do
+
+    let(:tested_method) { :any_of }
+    let(:expected_operator) { '$or' }
+
+    it_behaves_like 'a hoisting logical operation'
+
+    # When multiple arguments are given to any_of, it behaves differently
+    # from and.
+    context 'when argument is a mix of Criteria and hashes' do
+      let(:query) do
+        Mongoid::Query.new.where(hello: 'world')
+      end
+
+      let(:other1) do
+        Mongoid::Query.new.where(foo: 'bar')
       end
 
-      context 'where/and' do
-        let(:scope) do
-          Band.where(foo: 1).and(foo: 2)
-        end
+      let(:other2) do
+        {bar: 42}
+      end
 
-        it_behaves_like 'adds most recent criterion as $and'
+      let(:other3) do
+        Mongoid::Query.new.where(a: 2)
       end
 
-      context 'where/where' do
-        let(:scope) do
-          Band.where(foo: 1).where(foo: 2)
-        end
+      let(:result) { query.send(tested_method, other1, other2, other3) }
 
-        it_behaves_like 'adds most recent criterion as $and'
+      it 'combines' do
+        expect(result.selector).to eq(
+          'hello' => 'world',
+          expected_operator => [
+            {'foo' => 'bar'},
+            {'bar' => 42},
+            {'a' => 2},
+          ],
+        )
       end
     end
-  end
-
-  describe "#or" do
-
-    let(:tested_method) { :or }
-    let(:expected_operator) { '$or' }
-
-    it_behaves_like 'a non-combining logical operation'
 
     context "when provided no arguments" do
 
       let(:selection) do
-        query.or
+        query.any_of
       end
 
       it_behaves_like 'returns a cloned query'
@@ -453,7 +1109,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
     context "when provided nil" do
 
       let(:selection) do
-        query.or(nil)
+        query.any_of(nil)
       end
 
       it_behaves_like 'returns a cloned query'
@@ -470,75 +1126,92 @@ describe Mongoid::Criteria::Queryable::Selectable do
     context "when provided a single criterion" do
 
       let(:selection) do
-        query.or(field: [ 1, 2 ])
+        query.any_of(field: [ 1, 2 ])
       end
 
       it_behaves_like 'returns a cloned query'
 
       it "adds the $or selector" do
-        expect(selection.selector).to eq({
-          "$or" => [{ "field" => [ 1, 2 ] }]
-        })
+        expect(selection.selector).to eq(
+          "field" => [ 1, 2 ],
+        )
       end
 
       context 'when the criterion is wrapped in array' do
 
         let(:selection) do
-          query.or([{ field: [ 1, 2 ] }])
+          query.any_of([{ field: [ 1, 2 ] }])
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "adds the $or selector" do
-          expect(selection.selector).to eq({
-            "$or" => [{ "field" => [ 1, 2 ] }]
-          })
+        it "adds the condition" do
+          expect(selection.selector).to eq(
+            "field" => [ 1, 2 ],
+          )
         end
 
         context 'when the array has nil as one of the elements' do
 
           let(:selection) do
-            query.or([{ field: [ 1, 2 ] }, nil])
+            query.any_of([{ field: [ 1, 2 ] }, nil])
           end
 
           it_behaves_like 'returns a cloned query'
 
           it "adds the $or selector ignoring the nil element" do
-            expect(selection.selector).to eq({
-              "$or" => [{ "field" => [ 1, 2 ] }]
-            })
+            expect(selection.selector).to eq(
+              "field" => [ 1, 2 ],
+            )
           end
         end
       end
 
       context 'when query already has a condition on another field' do
 
-        let(:selection) do
-          query.where(foo: 'bar').or(field: [ 1, 2 ])
+        context 'when there is one argument' do
+
+          let(:selection) do
+            query.where(foo: 'bar').any_of(field: [ 1, 2 ])
+          end
+
+          it 'adds the new condition' do
+            expect(selection.selector).to eq(
+              'foo' => 'bar',
+              'field' => [1, 2],
+            )
+          end
         end
 
-        it 'moves original conditions under $or' do
-          expect(selection.selector).to eq({
-            "$or" => [{'foo' => 'bar'}, { "field" => [ 1, 2 ] }]
-          })
+        context 'when there are multiple arguments' do
+
+          let(:selection) do
+            query.where(foo: 'bar').any_of({field: [ 1, 2 ]}, {hello: 'world'})
+          end
+
+          it 'adds the new condition' do
+            expect(selection.selector).to eq(
+              'foo' => 'bar',
+              '$or' => [
+                {'field' => [1, 2]},
+                {'hello' => 'world'},
+              ],
+            )
+          end
         end
       end
 
       context 'when query already has an $or condition and another condition' do
 
         let(:selection) do
-          query.or(field: [ 1, 2 ]).where(foo: 'bar').or(test: 1)
+          query.or(field: [ 1, 2 ]).where(foo: 'bar').any_of(test: 1)
         end
 
-        it 'unions existing conditions' do
+        it 'adds the new condition' do
           expect(selection.selector).to eq(
-            '$or' => [
-              {
-                "$or" => [{ "field" => [ 1, 2 ] }],
-                'foo' => 'bar',
-              },
-              {'test' => 1},
-            ]
+            '$or' => [{'field' => [1, 2]}],
+            'foo' => 'bar',
+            'test' => 1,
           )
         end
       end
@@ -549,7 +1222,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
       context "when the criteria are for different fields" do
 
         let(:selection) do
-          query.or({ first: [ 1, 2 ] }, { second: [ 3, 4 ] })
+          query.any_of({ first: [ 1, 2 ] }, { second: [ 3, 4 ] })
         end
 
         it_behaves_like 'returns a cloned query'
@@ -567,7 +1240,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
       context "when the criteria uses a Key instance" do
 
         let(:selection) do
-          query.or({ first: [ 1, 2 ] }, { :second.gt => 3 })
+          query.any_of({ first: [ 1, 2 ] }, { :second.gt => 3 })
         end
 
         it "adds the $or selector" do
@@ -582,229 +1255,196 @@ describe Mongoid::Criteria::Queryable::Selectable do
         it_behaves_like 'returns a cloned query'
       end
 
-      context "when a criterion has an aliased field" do
+      context 'when criteria are simple and handled via Key' do
+        shared_examples_for 'adds conditions with $or' do
 
-        let(:selection) do
-          query.or({ id: 1 })
-        end
+          it "adds conditions with $or" do
+            expect(selection.selector).to eq({
+              '$or' => [
+                {'field' => 3},
+                {'field' => {'$lt' => 5}},
+              ],
+            })
+          end
 
-        it "adds the $or selector and aliases the field" do
-          expect(selection.selector).to eq({
-            "$or" => [ { "_id" => 1 } ]
-          })
+          it_behaves_like 'returns a cloned query'
         end
 
-        it_behaves_like 'returns a cloned query'
-      end
+        shared_examples_for 'adds one condition' do
 
-      context "when a criterion is wrapped in an array" do
+          it "adds one condition" do
+            expect(selection.selector).to eq({
+              'field' => 3,
+              '$and' => [
+                {'field' => {'$lt' => 5}},
+              ],
+            })
+          end
 
-        let(:selection) do
-          query.or([{ first: [ 1, 2 ] }, { :second.gt => 3 }])
+          it_behaves_like 'returns a cloned query'
         end
 
-        it_behaves_like 'returns a cloned query'
+        context 'criteria are provided in the same hash' do
+          let(:selection) do
+            query.send(tested_method, :field => 3, :field.lt => 5)
+          end
 
-        it "adds the $or selector" do
-          expect(selection.selector).to eq({
-            "$or" => [
-              { "first" => [ 1, 2 ] },
-              { "second" => { "$gt" => 3 }}
-            ]
-          })
+          it_behaves_like 'adds one condition'
         end
-      end
 
-      context "when the criteria are on the same field" do
+        context 'criteria are provided in separate hashes' do
+          let(:selection) do
+            query.send(tested_method, {:field => 3}, {:field.lt => 5})
+          end
 
-        let(:selection) do
-          query.or({ first: [ 1, 2 ] }, { first: [ 3, 4 ] })
+          it_behaves_like 'adds conditions with $or'
         end
 
-        it_behaves_like 'returns a cloned query'
+        context 'when the criterion is wrapped in an array' do
+          let(:selection) do
+            query.send(tested_method, [:field => 3], [:field.lt => 5])
+          end
 
-        it "appends both $or expressions" do
-          expect(selection.selector).to eq({
-            "$or" => [
-              { "first" => [ 1, 2 ] },
-              { "first" => [ 3, 4 ] }
-            ]
-          })
+          it_behaves_like 'adds conditions with $or'
         end
       end
-    end
 
-    context "when chaining the criterion" do
+      context 'when criteria are handled via Key and simple' do
+        shared_examples_for 'adds conditions with $or' do
 
-      context "when the criterion are for different fields" do
+          it "adds conditions with $or" do
+            expect(selection.selector).to eq({
+              '$or' => [
+                {'field' => {'$gt' => 3}},
+                {'field' => 5},
+              ],
+            })
+          end
 
-        let(:selection) do
-          query.or(first: [ 1, 2 ]).or(second: [ 3, 4 ])
+          it_behaves_like 'returns a cloned query'
         end
 
-        it_behaves_like 'returns a cloned query'
-
-        it "adds the $or selectors" do
-          expect(selection.selector).to eq({
-            "$or" => [
-              { "first" => [ 1, 2 ] },
-              { "second" => [ 3, 4 ] }
-            ]
-          })
-        end
-      end
+        shared_examples_for 'adds one condition' do
 
-      context "when the criterion are on the same field" do
+          it "adds one condition" do
+            expect(selection.selector).to eq({
+              'field' => {'$gt' => 3},
+              '$and' => ['field' => 5],
+            })
+          end
 
-        let(:selection) do
-          query.or(first: [ 1, 2 ]).or(first: [ 3, 4 ])
+          it_behaves_like 'returns a cloned query'
         end
 
-        it_behaves_like 'returns a cloned query'
+        context 'criteria are provided in the same hash' do
+          let(:selection) do
+            query.send(tested_method, :field.gt => 3, :field => 5)
+          end
 
-        it "appends both $or expressions" do
-          expect(selection.selector).to eq({
-            "$or" => [
-              { "first" => [ 1, 2 ] },
-              { "first" => [ 3, 4 ] }
-            ]
-          })
+          it_behaves_like 'adds one condition'
         end
-      end
-    end
-  end
-
-  describe "#nor" do
-
-    let(:tested_method) { :nor }
-    let(:expected_operator) { '$nor' }
-
-    it_behaves_like 'a non-combining logical operation'
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.nor
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it_behaves_like 'returns a cloned query'
-    end
 
-    context "when provided nil" do
+        context 'criteria are provided in separate hashes' do
+          let(:selection) do
+            query.send(tested_method, {:field.gt => 3}, {:field => 5})
+          end
 
-      let(:selection) do
-        query.nor(nil)
-      end
+          it_behaves_like 'adds conditions with $or'
+        end
 
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
+        context 'when the criterion is wrapped in an array' do
+          let(:selection) do
+            query.send(tested_method, [:field.gt => 3], [:field => 5])
+          end
 
-      it "returns the query" do
-        expect(selection).to eq(query)
+          it_behaves_like 'adds conditions with $or'
+        end
       end
 
-      it_behaves_like 'returns a cloned query'
-    end
+      context "when a criterion has an aliased field" do
 
-    context "when provided a single criterion" do
+        let(:selection) do
+          query.any_of({ id: 1 })
+        end
 
-      let(:selection) do
-        query.nor(field: [ 1, 2 ])
-      end
+        it "adds the $or selector and aliases the field" do
+          expect(selection.selector).to eq(
+            "_id" => 1,
+          )
+        end
 
-      it "adds the $nor selector" do
-        expect(selection.selector).to eq({
-          "$nor" => [{"field" => [ 1, 2 ] }]
-        })
+        it_behaves_like 'returns a cloned query'
       end
 
-      it_behaves_like 'returns a cloned query'
-    end
-
-    context "when provided multiple criterion" do
-
-      context "when the criterion are fnor different fields" do
+      context "when a criterion is wrapped in an array" do
 
         let(:selection) do
-          query.nor({ first: [ 1, 2 ] }, { second: [ 3, 4 ] })
+          query.any_of([{ first: [ 1, 2 ] }, { :second.gt => 3 }])
         end
 
-        it "adds the $nor selector" do
+        it_behaves_like 'returns a cloned query'
+
+        it "adds the $or selector" do
           expect(selection.selector).to eq({
-            "$nor" => [
+            "$or" => [
               { "first" => [ 1, 2 ] },
-              { "second" => [ 3, 4 ] }
+              { "second" => { "$gt" => 3 }}
             ]
           })
         end
-
-        it_behaves_like 'returns a cloned query'
       end
 
-      context "when the criterion are on the same field" do
+      context "when the criteria are on the same field" do
 
         let(:selection) do
-          query.nor({ first: [ 1, 2 ] }, { first: [ 3, 4 ] })
+          query.any_of({ first: [ 1, 2 ] }, { first: [ 3, 4 ] })
         end
 
-        it "appends both $nor expressions" do
+        it_behaves_like 'returns a cloned query'
+
+        it "appends both $or expressions" do
           expect(selection.selector).to eq({
-            "$nor" => [
+            "$or" => [
               { "first" => [ 1, 2 ] },
               { "first" => [ 3, 4 ] }
             ]
           })
         end
-
-        it_behaves_like 'returns a cloned query'
       end
     end
 
-    context "when chaining the criterion" do
+    context "when chaining the criteria" do
 
-      context "when the criterion are fnor different fields" do
+      context "when the criteria are for different fields" do
 
         let(:selection) do
-          query.nor(first: [ 1, 2 ]).nor(second: [ 3, 4 ])
-        end
-
-        it "adds the $nor selectors" do
-          expect(selection.selector).to eq({
-            "$nor" => [
-              { "first" => [ 1, 2 ] },
-              { "second" => [ 3, 4 ] }
-            ]
-          })
+          query.any_of(first: [ 1, 2 ]).any_of(second: [ 3, 4 ])
         end
 
         it_behaves_like 'returns a cloned query'
+
+        it "adds the conditions separately" do
+          expect(selection.selector).to eq(
+            "first" => [ 1, 2 ],
+            "second" => [ 3, 4 ],
+          )
+        end
       end
 
-      context "when the criterion are on the same field" do
+      context "when the criteria are on the same field" do
 
         let(:selection) do
-          query.nor(first: [ 1, 2 ]).nor(first: [ 3, 4 ])
-        end
-
-        it "appends both $nor expressions" do
-          expect(selection.selector).to eq({
-            "$nor" => [
-              { "first" => [ 1, 2 ] },
-              { "first" => [ 3, 4 ] }
-            ]
-          })
+          query.any_of(first: [ 1, 2 ]).any_of(first: [ 3, 4 ])
         end
 
         it_behaves_like 'returns a cloned query'
+
+        it "adds the conditions separately" do
+          expect(selection.selector).to eq(
+            "first" => [ 1, 2 ],
+            '$and' => [{"first" => [ 3, 4 ]}],
+          )
+        end
       end
     end
   end
@@ -894,6 +1534,25 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
       end
 
+      context "when the criteria uses Key" do
+
+        let(:selection) do
+          query.not(:age.gt => 50)
+        end
+
+        it "negates the gt selection" do
+          expect(selection.selector).to eq(
+            '$and' => ['$nor' => ['age' => {'$gt' => 50}]]
+          )
+        end
+
+        it_behaves_like 'returns a cloned query'
+
+        it "removes the negation on the clone" do
+          expect(selection).to_not be_negating
+        end
+      end
+
       context "when the following criteria is a where" do
 
         let(:selection) do