mongoid_monkey 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f0da38ef748517309df870fa4d43e8f76a874659
-  data.tar.gz: f7383666ee6df0a7ebaa5f508a069da887004f16
+  metadata.gz: bbc718cd026b11dfad809f69e4827de71609036d
+  data.tar.gz: c0cee3e83c4283ee4df01eeb04a0f0b3c7adb7cf
 SHA512:
-  metadata.gz: 4e742d660af83f2b147a6fd58776802d14689fc13a06446f0195d99a3c78218d246b212c06cbf64b351590deb88a864b0214f934ae83cc6edc8f9a9786352162
-  data.tar.gz: 8a24211a8bf84e5f218a4525914d22fdcc2411f548c80569f22168bcb611ec64aef49c7099ea8d1223ad7dd2630d04ade35347b89ee6badf1fb23493e2ef10fd
+  metadata.gz: cd27fedca19eb03a3fc4f022e0c1beb8622b7cb72015bc8961d4b3333fb048245ae51e0283b75806a31dca12c7831aa0cc566305fc8de5b700dcfb954dba6611
+  data.tar.gz: 13d63146ced11e02fdb97ce0c447aa511f30f25edbf626927ae1e0f0520d96cc7d2313e0c167bd01685355703721640feecce2a75c0b066288d7c0bb196fe06a

data/README.md

@@ -38,6 +38,7 @@ If you would only like some of the patches, please copy and paste the code to yo
 | `instrument.rb` | Backport instrumentation change to Moped 1. | ● | ○ | ○ |
 | `reorder.rb` | Backport `Criteria#reorder` method from Mongoid 4. | ● | ○ | ○ |
 | `only_pluck_localized.rb` | Backport [PR #4299](https://github.com/mongodb/mongoid/pull/4299) from Mongoid 6 which fixes `#only`, `#without`, and `#pluck` with localized fields. | ● | × | × |
+| `push_each.rb` | Backport [PR #4460](https://github.com/mongodb/mongoid/pull/4460) to replace usage of $pushAll with $push + $each for MongoDB 3.6 support. | ● | × | × |
 | `embedded_touch.rb` (1) | Backport [Issue #3310](https://github.com/mongodb/mongoid/commit/a94c2f43573e58f973913c881ad9d11d62bf857c) from Mongoid 4 to add `:touch` option to `embedded_in`. | ● | ○ | ○ |
 | `embedded_touch.rb` (2) | Backport [PR #4392](https://github.com/mongodb/mongoid/pull/4392) from Mongoid 6 to fix an infinite loop issue related to `:touch` callbacks. | ● | ● | ● |
 | `index_options.rb` | Backport latest index valid index options from Mongoid 6. | ● | ● | ○ |

data/lib/mongoid_monkey.rb

@@ -2,6 +2,7 @@ require 'version'
 
 require 'patches/aggregate_cursor'
 require 'patches/atomic'
+require 'patches/push_each'
 require 'patches/big_decimal'
 require 'patches/db_commands'
 require 'patches/index_options'

data/lib/patches/atomic.rb

@@ -72,7 +72,7 @@ module Atomic
   # Uses $push + $each rather than $pushAll
   def push_all(*args)
     if args.length == 1 && args.first.is_a?(Hash)
-      query.update_all("$push" => collect_operations(args.first, true))
+      query.update_all("$push" => collect_each_operations(args.first))
     else
       query.update_all("$push" => { database_field_name(args[0]) => { "$each" => Array.wrap(args[1]) } })
     end
@@ -102,10 +102,15 @@ module Atomic
 
   private
 
-  def collect_operations(ops, use_each = false)
-    ops.inject({}) do |operations, (field, value)|
-      operations[database_field_name(field)] = use_each ? { '$each' => Array.wrap(value.mongoize) } : value.mongoize
-      operations
+  def collect_operations(ops)
+    ops.each_with_object({}) do |(field, value), operations|
+      operations[database_field_name(field)] = value.mongoize
+    end
+  end
+
+  def collect_each_operations(ops)
+    ops.each_with_object({}) do |(field, value), operations|
+      operations[database_field_name(field)] = { "$each" => Array.wrap(value).mongoize }
     end
   end
 end
@@ -344,30 +349,4 @@ end
 end
 end
 
-# Replace usage of $pushAll with $push + $each
-module Mongoid
-module Relations
-module Embedded
-module Batchable
-
-  def batch_insert(docs)
-    execute_batch_insert(docs, "$push", true)
-  end
-
-  def execute_batch_insert(docs, operation, use_each = false)
-    self.inserts_valid = true
-    inserts = pre_process_batch_insert(docs)
-    if insertable?
-      collection.find(selector).update(
-          positionally(selector, operation => { path => use_each ? { '$each' => Array.wrap(inserts) } : inserts })
-      )
-      post_process_batch_insert(docs)
-    end
-    inserts
-  end
-end
-end
-end
-end
-
 end

data/lib/patches/push_each.rb

@@ -0,0 +1,63 @@
+# Replace usage of $pushAll with $push + $each for MongoDB 3.6 support.
+# Note that some of this is done in the `atomic.rb` patch as well.
+
+if Mongoid::VERSION =~ /\A3\./
+
+module Mongoid
+module Relations
+module Embedded
+module Batchable
+  def batch_insert(docs)
+    execute_batch_insert(docs, "$push", true)
+  end
+
+  def execute_batch_insert(docs, operation, use_each = false)
+    self.inserts_valid = true
+    inserts = pre_process_batch_insert(docs)
+    if insertable?
+      collection.find(selector).update(
+          positionally(selector, operation => { path => use_each ? { '$each' => inserts } : inserts })
+      )
+      post_process_batch_insert(docs)
+    end
+    inserts
+  end
+end
+end
+end
+end
+
+module Mongoid
+module Atomic
+class Modifiers < Hash
+  def push(modifications)
+    modifications.each_pair do |field, value|
+      push_fields[field] = field
+      mods = push_conflict?(field) ? conflicting_pushes : pushes
+      add_each_operation(mods, field, value)
+    end
+  end
+
+  def add_each_operation(mods, field, value)
+    value = Array.wrap(value)
+    if mods.has_key?(field)
+      value.each do |val|
+        mods[field]["$each"].push(val)
+      end
+    else
+      mods[field] = { "$each" => value }
+    end
+  end
+
+  def conflicting_pushes
+    conflicts["$push"] ||= {}
+  end
+
+  def pushes
+    self["$push"] ||= {}
+  end
+end
+end
+end
+
+end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module MongoidMonkey
-  VERSION = '0.3.1'
+  VERSION = '0.3.2'
 end

data/spec/unit/push_each_spec.rb

@@ -0,0 +1,810 @@
+require "spec_helper"
+
+if Mongoid::VERSION =~ /\A3\./
+
+describe Mongoid::Atomic do
+
+  describe "#add_atomic_pull" do
+
+    let!(:person) do
+      Person.create
+    end
+
+    let(:address) do
+      person.addresses.create
+    end
+
+    let(:location) do
+      address.locations.create
+    end
+
+    before do
+      person.add_atomic_pull(address)
+    end
+
+    it "adds the document to the delayed atomic pulls" do
+      expect(person.delayed_atomic_pulls["addresses"]).to eq([ address ])
+    end
+
+    it "flags the document for destruction" do
+      expect(address).to be_flagged_for_destroy
+    end
+  end
+
+  describe "#add_atomic_unset" do
+
+    let!(:person) do
+      Person.new
+    end
+
+    let(:name) do
+      person.build_name
+    end
+
+    before do
+      person.add_atomic_unset(name)
+    end
+
+    it "adds the document to the delayed atomic unsets" do
+      expect(person.delayed_atomic_unsets["name"]).to eq([ name ])
+    end
+
+    it "flags the document for destruction" do
+      expect(name).to be_flagged_for_destroy
+    end
+  end
+
+  describe "#atomic_updates" do
+
+    context "when the document is persisted" do
+
+      let(:person) do
+        Person.create
+      end
+
+      context "when the document is modified" do
+
+        before do
+          person.title = "Sir"
+        end
+
+        it "returns the atomic updates" do
+          expect(person.atomic_updates).to eq({ "$set" => { "title" => "Sir" }})
+        end
+
+        context "when an embeds many child is added" do
+
+          let!(:address) do
+            person.addresses.build(street: "Oxford St")
+          end
+
+          it "returns a $set and $push for modifications" do
+            expect(person.atomic_updates).to eq(
+                                                 {
+                                                     "$set" => { "title" => "Sir" },
+                                                     "$push" => { "addresses" => { "$each" => [{ "_id" => address._id, "street" => "Oxford St" }] } }
+                                                 }
+                                             )
+          end
+        end
+
+        context "when an embeds one child is added" do
+
+          let!(:name) do
+            person.build_name(first_name: "Lionel")
+          end
+
+          it "returns a $set for modifications" do
+            expect(person.atomic_updates).to eq(
+                                                 {
+                                                     "$set" => {
+                                                         "title" => "Sir",
+                                                         "name" => { "_id" => name._id, "first_name" => "Lionel" }
+                                                     }
+                                                 }
+                                             )
+          end
+        end
+
+        context "when an existing embeds many gets modified" do
+
+          let!(:address) do
+            person.addresses.create(street: "Oxford St")
+          end
+
+          before do
+            address.street = "Bond St"
+          end
+
+          context "when asking for the updates from the root" do
+
+            it "returns the $set with correct position and modifications" do
+              expect(person.atomic_updates).to eq(
+                                                   { "$set" => { "title" => "Sir", "addresses.0.street" => "Bond St" }}
+                                               )
+            end
+          end
+
+          context "when asking for the updates from the child" do
+
+            it "returns the $set with correct position and modifications" do
+              expect(address.atomic_updates).to eq(
+                                                    { "$set" => { "addresses.0.street" => "Bond St" }}
+                                                )
+            end
+          end
+
+          context "when an existing 2nd level embedded child gets modified" do
+
+            let!(:location) do
+              address.locations.create(name: "Home")
+            end
+
+            before do
+              location.name = "Work"
+            end
+
+            context "when asking for the updates from the root" do
+
+              it "returns the $set with correct positions and modifications" do
+                expect(person.atomic_updates).to eq(
+                                                     { "$set" => {
+                                                         "title" => "Sir",
+                                                         "addresses.0.street" => "Bond St",
+                                                         "addresses.0.locations.0.name" => "Work" }
+                                                     }
+                                                 )
+              end
+            end
+
+            context "when asking for the updates from the 1st level child" do
+
+              it "returns the $set with correct positions and modifications" do
+                expect(address.atomic_updates).to eq(
+                                                      { "$set" => {
+                                                          "addresses.0.street" => "Bond St",
+                                                          "addresses.0.locations.0.name" => "Work" }
+                                                      }
+                                                  )
+              end
+            end
+
+            context "when asking for the updates from the 2nd level child" do
+
+              it "returns the $set with correct positions and modifications" do
+                expect(location.atomic_updates).to eq(
+                                                       { "$set" => {
+                                                           "addresses.0.locations.0.name" => "Work" }
+                                                       }
+                                                   )
+              end
+            end
+          end
+
+          context "when a 2nd level embedded child gets added" do
+
+            let!(:location) do
+              address.locations.build(name: "Home")
+            end
+
+            context "when asking for the updates from the root" do
+
+              it "returns the $set with correct positions and modifications" do
+                expect(person.atomic_updates).to eq(
+                                                     {
+                                                         "$set" => {
+                                                             "title" => "Sir",
+                                                             "addresses.0.street" => "Bond St"
+                                                         },
+                                                         conflicts: {
+                                                             "$push" => {
+                                                                 "addresses.0.locations" => { "$each" => [{ "_id" => location.id, "name" => "Home" }] }
+                                                             }
+                                                         }
+                                                     }
+                                                 )
+              end
+            end
+
+            context "when asking for the updates from the 1st level child" do
+
+              it "returns the $set with correct positions and modifications" do
+                expect(address.atomic_updates).to eq(
+                                                      {
+                                                          "$set" => {
+                                                              "addresses.0.street" => "Bond St"
+                                                          },
+                                                          conflicts: {
+                                                              "$push" => {
+                                                                  "addresses.0.locations" => { "$each" => [{ "_id" => location.id, "name" => "Home" }] }
+                                                              }
+                                                          }
+                                                      }
+                                                  )
+              end
+            end
+          end
+
+          context "when an embedded child gets unset" do
+
+            before do
+              person.attributes = { addresses: nil }
+            end
+
+            let(:updates) do
+              person.atomic_updates
+            end
+
+            it "returns the $set for the first level and $unset for other." do
+              expect(updates).to eq({
+                                        "$unset" => { "addresses" => true },
+                                        "$set" => { "title" => "Sir" }
+                                    })
+            end
+          end
+
+          context "when adding a new second level child" do
+
+            let!(:new_address) do
+              person.addresses.build(street: "Another")
+            end
+
+            let!(:location) do
+              new_address.locations.build(name: "Home")
+            end
+
+            context "when asking for the updates from the root document" do
+
+              it "returns the $set for 1st level and other for the 2nd level" do
+                expect(person.atomic_updates).to eq(
+                                                     {
+                                                         "$set" => {
+                                                             "title" => "Sir",
+                                                             "addresses.0.street" => "Bond St"
+                                                         },
+                                                         conflicts: {
+                                                             "$push" => {
+                                                                 "addresses" => { "$each" => [{
+                                                                                                  "_id" => new_address.id,
+                                                                                                  "street" => "Another",
+                                                                                                  "locations" => [
+                                                                                                      "_id" => location.id,
+                                                                                                      "name" => "Home"
+                                                                                                  ]
+                                                                                              }] }
+                                                             }
+                                                         }
+                                                     }
+                                                 )
+              end
+            end
+
+            context "when asking for the updates from the 1st level document" do
+
+              it "returns the $set for 1st level and other for the 2nd level" do
+                expect(address.atomic_updates).to eq(
+                                                      { "$set" => { "addresses.0.street" => "Bond St" }}
+                                                  )
+              end
+            end
+          end
+
+          context "when adding a new child beetween two existing and updating one of them" do
+
+            let!(:new_address) do
+              person.addresses.build(street: "Ipanema")
+            end
+
+            let!(:location) do
+              new_address.locations.build(name: "Home")
+            end
+
+            before do
+              person.addresses[0] = new_address
+              person.addresses[1] = address
+            end
+
+            it "returns the $set for 1st and 2nd level and other for the 3nd level" do
+              expect(person.atomic_updates).to eq(
+                                                   {
+                                                       "$set" => {
+                                                           "title" => "Sir"
+                                                       },
+                                                       "$push" => {
+                                                           "addresses" => { "$each" => [{
+                                                                                            "_id" => new_address.id,
+                                                                                            "street" => "Ipanema",
+                                                                                            "locations" => [
+                                                                                                "_id" => location.id,
+                                                                                                "name" => "Home"
+                                                                                            ]
+                                                                                        }] }
+                                                       },
+                                                       conflicts: {
+                                                           "$set" => { "addresses.0.street"=>"Bond St" }
+                                                       }
+                                                   }
+                                               )
+            end
+          end
+        end
+
+        context "when adding new embedded docs at multiple levels" do
+
+          let!(:address) do
+            person.addresses.build(street: "Another")
+          end
+
+          let!(:location) do
+            address.locations.build(name: "Home")
+          end
+
+          it "returns the proper $sets and $pushes for all levels" do
+            expect(person.atomic_updates).to eq(
+                                                 {
+                                                     "$set" => {
+                                                         "title" => "Sir",
+                                                     },
+                                                     "$push" => {
+                                                         "addresses" => { "$each" => [{
+                                                                                          "_id" => address.id,
+                                                                                          "street" => "Another",
+                                                                                          "locations" => [
+                                                                                              "_id" => location.id,
+                                                                                              "name" => "Home"
+                                                                                          ]
+                                                                                      }] }
+                                                     }
+                                                 }
+                                             )
+          end
+        end
+      end
+    end
+  end
+end
+
+describe Mongoid::Atomic::Modifiers do
+
+  let(:modifiers) do
+    described_class.new
+  end
+
+  describe "#add_to_set" do
+
+    context "when the unique adds are empty" do
+
+      before do
+        modifiers.add_to_set({})
+      end
+
+      it "does not contain any operations" do
+        expect(modifiers).to eq({})
+      end
+    end
+
+    context "when the adds are not empty" do
+
+      let(:adds) do
+        { "preference_ids" => [ "one", "two" ] }
+      end
+
+      context "when adding a single field" do
+
+        before do
+          modifiers.add_to_set(adds)
+        end
+
+        it "adds the add to set with each modifiers" do
+          expect(modifiers).to eq({
+                                      "$addToSet" => { "preference_ids" => { "$each" => [ "one", "two" ] }}
+                                  })
+        end
+      end
+
+      context "when adding to an existing field" do
+
+        let(:adds_two) do
+          { "preference_ids" => [ "three" ] }
+        end
+
+        before do
+          modifiers.add_to_set(adds)
+          modifiers.add_to_set(adds_two)
+        end
+
+        it "adds the add to set with each modifiers" do
+          expect(modifiers).to eq({
+                                      "$addToSet" =>
+                                          { "preference_ids" =>
+                                                { "$each" => [ "one", "two", "three" ] }
+                                          }
+                                  })
+        end
+      end
+    end
+  end
+
+  describe "#pull" do
+
+    context "when the pulls are empty" do
+
+      before do
+        modifiers.pull({})
+      end
+
+      it "does not contain any pull operations" do
+        expect(modifiers).to eq({})
+      end
+    end
+
+    context "when no conflicting modifications are present" do
+
+      context "when adding a single pull" do
+
+        let(:pulls) do
+          { "addresses" => { "_id" => { "$in" => [ "one" ]}} }
+        end
+
+        before do
+          modifiers.pull(pulls)
+        end
+
+        it "adds the push all modifiers" do
+          expect(modifiers).to eq(
+                                   { "$pull" => { "addresses" => { "_id" => { "$in" => [ "one" ]}}}}
+                               )
+        end
+      end
+
+      context "when adding to an existing pull" do
+
+        let(:pull_one) do
+          { "addresses" => { "_id" => { "$in" => [ "one" ]}} }
+        end
+
+        let(:pull_two) do
+          { "addresses" => { "_id" => { "$in" => [ "two" ]}} }
+        end
+
+        before do
+          modifiers.pull(pull_one)
+          modifiers.pull(pull_two)
+        end
+
+        it "overwrites the previous pulls" do
+          expect(modifiers).to eq(
+                                   { "$pull" => { "addresses" => { "_id" => { "$in" => [ "two" ]}}}}
+                               )
+        end
+      end
+    end
+  end
+
+  describe "#pull_all" do
+
+    context "when the pulls are empty" do
+
+      before do
+        modifiers.pull_all({})
+      end
+
+      it "does not contain any pull operations" do
+        expect(modifiers).to eq({})
+      end
+    end
+
+    context "when no conflicting modifications are present" do
+
+      context "when adding a single pull" do
+
+        let(:pulls) do
+          { "addresses" => [{ "_id" => "one" }] }
+        end
+
+        before do
+          modifiers.pull_all(pulls)
+        end
+
+        it "adds the push all modifiers" do
+          expect(modifiers).to eq(
+                                   { "$pullAll" =>
+                                         { "addresses" => [
+                                             { "_id" => "one" }
+                                         ]
+                                         }
+                                   }
+                               )
+        end
+      end
+
+      context "when adding to an existing pull" do
+
+        let(:pull_one) do
+          { "addresses" => [{ "street" => "Hobrechtstr." }] }
+        end
+
+        let(:pull_two) do
+          { "addresses" => [{ "street" => "Pflugerstr." }] }
+        end
+
+        before do
+          modifiers.pull_all(pull_one)
+          modifiers.pull_all(pull_two)
+        end
+
+        it "adds the pull all modifiers" do
+          expect(modifiers).to eq(
+                                   { "$pullAll" =>
+                                         { "addresses" => [
+                                             { "street" => "Hobrechtstr." },
+                                             { "street" => "Pflugerstr." }
+                                         ]
+                                         }
+                                   }
+                               )
+        end
+      end
+    end
+  end
+
+  describe "#push" do
+
+    context "when the pushes are empty" do
+
+      before do
+        modifiers.push({})
+      end
+
+      it "does not contain any push operations" do
+        expect(modifiers).to eq({})
+      end
+    end
+
+    context "when no conflicting modification is present" do
+
+      context "when adding a single push" do
+
+        let(:pushes) do
+          { "addresses" => { "street" => "Oxford St" } }
+        end
+
+        before do
+          modifiers.push(pushes)
+        end
+
+        it "adds the push all modifiers" do
+          expect(modifiers).to eq(
+                                   { "$push" =>
+                                         { "addresses" => { "$each" => [{ "street" => "Oxford St" }] } }
+                                   }
+                               )
+        end
+      end
+
+      context "when adding to an existing push" do
+
+        let(:push_one) do
+          { "addresses" => { "street" => "Hobrechtstr." } }
+        end
+
+        let(:push_two) do
+          { "addresses" => { "street" => "Pflugerstr." } }
+        end
+
+        before do
+          modifiers.push(push_one)
+          modifiers.push(push_two)
+        end
+
+        it "adds the push all modifiers" do
+          expect(modifiers).to eq(
+                                   { "$push" =>
+                                         { "addresses" => { "$each" => [
+                                             { "street" => "Hobrechtstr." },
+                                             { "street" => "Pflugerstr." }
+                                         ] }
+                                         }
+                                   }
+                               )
+        end
+      end
+    end
+
+    context "when a conflicting modification exists" do
+
+      context "when the conflicting modification is a set" do
+
+        let(:sets) do
+          { "addresses.0.street" => "Bond" }
+        end
+
+        let(:pushes) do
+          { "addresses" => { "street" => "Oxford St" } }
+        end
+
+        before do
+          modifiers.set(sets)
+          modifiers.push(pushes)
+        end
+
+        it "adds the push all modifiers to the conflicts hash" do
+          expect(modifiers).to eq(
+                                   { "$set" => { "addresses.0.street" => "Bond" },
+                                     conflicts: { "$push" =>
+                                                      { "addresses" => { "$each" => [{ "street" => "Oxford St" }] } }
+                                     }
+                                   }
+                               )
+        end
+      end
+
+      context "when the conflicting modification is a pull" do
+
+        let(:pulls) do
+          { "addresses" => { "street" => "Bond St" } }
+        end
+
+        let(:pushes) do
+          { "addresses" => { "street" => "Oxford St" } }
+        end
+
+        before do
+          modifiers.pull_all(pulls)
+          modifiers.push(pushes)
+        end
+
+        it "adds the push all modifiers to the conflicts hash" do
+          expect(modifiers).to eq(
+                                   { "$pullAll" => {
+                                       "addresses" => { "street" => "Bond St" }},
+                                     conflicts: { "$push" =>
+                                                      { "addresses" => { "$each" => [{ "street" => "Oxford St" }] } }
+                                     }
+                                   }
+                               )
+        end
+      end
+
+      context "when the conflicting modification is a push" do
+
+        let(:nested) do
+          { "addresses.0.locations" => { "street" => "Bond St" } }
+        end
+
+        let(:pushes) do
+          { "addresses" => { "street" => "Oxford St" } }
+        end
+
+        before do
+          modifiers.push(nested)
+          modifiers.push(pushes)
+        end
+
+        it "adds the push all modifiers to the conflicts hash" do
+          expect(modifiers).to eq(
+                                   { "$push" => {
+                                       "addresses.0.locations" => { "$each" => [{ "street" => "Bond St" }] } },
+                                     conflicts: { "$push" =>
+                                                      { "addresses" => { "$each" => [{ "street" => "Oxford St" }] } }
+                                     }
+                                   }
+                               )
+        end
+      end
+    end
+  end
+
+  describe "#set" do
+
+    describe "when adding to the root level" do
+
+      context "when no conflicting mods exist" do
+
+        context "when the sets have values" do
+
+          let(:sets) do
+            { "title" => "Sir" }
+          end
+
+          before do
+            modifiers.set(sets)
+          end
+
+          it "adds the sets to the modifiers" do
+            expect(modifiers).to eq({ "$set" => { "title" => "Sir" } })
+          end
+        end
+
+        context "when the sets contain an id" do
+
+          let(:sets) do
+            { "_id" => Moped::BSON::ObjectId.new }
+          end
+
+          before do
+            modifiers.set(sets)
+          end
+
+          it "does not include the id sets" do
+            expect(modifiers).to eq({})
+          end
+        end
+
+        context "when the sets are empty" do
+
+          before do
+            modifiers.set({})
+          end
+
+          it "does not contain set operations" do
+            expect(modifiers).to eq({})
+          end
+        end
+      end
+
+      context "when a conflicting modification exists" do
+
+        let(:pulls) do
+          { "addresses" => [{ "_id" => "one" }] }
+        end
+
+        let(:sets) do
+          { "addresses.0.title" => "Sir" }
+        end
+
+        before do
+          modifiers.pull_all(pulls)
+          modifiers.set(sets)
+        end
+
+        it "adds the set modifiers to the conflicts hash" do
+          expect(modifiers).to eq(
+                                   { "$pullAll" =>
+                                         { "addresses" => [
+                                             { "_id" => "one" }
+                                         ]
+                                         },
+                                     conflicts:
+                                         { "$set" => { "addresses.0.title" => "Sir" }}
+                                   }
+                               )
+        end
+      end
+    end
+  end
+
+  describe "#unset" do
+
+    describe "when adding to the root level" do
+
+      context "when the unsets have values" do
+
+        let(:unsets) do
+          [ "addresses" ]
+        end
+
+        before do
+          modifiers.unset(unsets)
+        end
+
+        it "adds the unsets to the modifiers" do
+          expect(modifiers).to eq({ "$unset" => { "addresses" => true } })
+        end
+      end
+
+      context "when the unsets are empty" do
+
+        before do
+          modifiers.unset([])
+        end
+
+        it "does not contain unset operations" do
+          expect(modifiers).to eq({})
+        end
+      end
+    end
+  end
+end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_monkey
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - johnnyshields
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-07 00:00:00.000000000 Z
+date: 2018-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -71,6 +71,7 @@ files:
 - lib/patches/index_options.rb
 - lib/patches/instrument.rb
 - lib/patches/only_pluck_localized.rb
+- lib/patches/push_each.rb
 - lib/patches/reorder.rb
 - lib/patches/write_concern.rb
 - lib/version.rb
@@ -139,6 +140,7 @@ files:
 - spec/unit/index_options_spec.rb
 - spec/unit/instrument_spec.rb
 - spec/unit/only_pluck_localized_spec.rb
+- spec/unit/push_each_spec.rb
 - spec/unit/reorder_spec.rb
 - spec/unit/write_concern_spec.rb
 homepage: https://github.com/johnnyshields/mongoid_monkey
@@ -231,5 +233,6 @@ test_files:
 - spec/unit/index_options_spec.rb
 - spec/unit/instrument_spec.rb
 - spec/unit/only_pluck_localized_spec.rb
+- spec/unit/push_each_spec.rb
 - spec/unit/reorder_spec.rb
 - spec/unit/write_concern_spec.rb