mongoid_monkey 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 35ce26c7c1fa842774c1c8724d3060e63d14bcc3
+  data.tar.gz: 73b16e660f5088a4ef8f7a07b0ad37a1731ead1c
+SHA512:
+  metadata.gz: 1b98576cffc2d498853d06b1dbffaef9a5ea53d5c184c6884e7fe146261a5da5cea89a90b2d633d0d7d0264edea9cfd1b3d2a49bcf63a2fa34319e1e045cad55
+  data.tar.gz: f07e78cc1905d110a4042dac8f8f15448dc5d8d39dd7412c1ad1f8a693c59d5f39e12ffebe449a0da7030651fad95500308bd156970f5fec3e07b4846b6fc38b

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Johnny Shields
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+# Mongoid Monkey
+
+### Monkey Patches for Mongoid
+
+Mongoid Monkey is a collection of monkey patches for Mongoid 3, 4, 5, including feature
+backports, fixes, and forward compatibility.
+
+### Warning
+
+The patches in this gem will change/override the behavior of Mongoid. While effort has been
+made to be as backward compatible as possible, use at your own risk.
+
+### Installation
+
+In your Gemfile, require this gem **after** requiring `mongoid`.
+
+### Version Requirement
+
+* Works with Mongoid 3, 4, 5
+* Due to the `list_collections` patch, this gem requires **at least MongoDB 3.0.** Other patches will work on older MongoDB versions.
+
+### Patch List
+
+Installing this gem will apply all monkey patches for the Mongoid version you are using.
+If you would only like some of the patches, please copy and paste the code to your app directly
+(e.g. `/config/initializers` if using Rails.)
+
+| File | Description | 3 | 4 | 5 |
+| --- | --- | --- | --- | --- |
+| `atomic.rb` | Backport syntax change of atomic query methods. | ● | | |
+| `big_decimal.rb` | Fixes buggy BigDecimal behavior. | ● | ● | ● |
+| `instrument.rb` | Backport instrumentation change to Moped 1. | ● | | |
+| `list_collections.rb` | Fetch collections via `listCollections` command; required for WiredTiger. | ● | ● | |
+| `reorder.rb` | Backport `Criteria#reorder` method. | ● | | |
+
+### License
+
+* This project is licensed under the MIT License.
+* Some code in this repo is adapted from the fantastic work of Durran Jordan, et. al. on Mongoid.
+* (c) Copyright 2016 Johnny Shields.

data/lib/mongoid_monkey.rb

@@ -0,0 +1,15 @@
+require 'version'
+
+if Mongoid::VERSION =~ /\A3\./
+  require 'patches/atomic'
+  require 'patches/reorder'
+end
+
+if Mongoid::VERSION =~ /\A[345]\./
+  require 'patches/big_decimal'
+end
+
+if defined?(Moped)
+  require 'patches/instrument' if Moped::VERSION =~ /\A1\./
+  require 'patches/list_collections'
+end

data/lib/patches/atomic.rb

@@ -0,0 +1,109 @@
+module Mongoid
+module Contextual
+module Atomic
+
+  def add_to_set_with_mongoid4(*args)
+    if args.length == 1 && args.first.is_a?(Hash)
+      query.update_all("$addToSet" => collect_operations(args.first))
+    else
+      add_to_set_without_mongoid4(*args)
+    end
+  end
+  alias_method_chain :add_to_set, :mongoid4
+
+  def bit_with_mongoid4(*args)
+    if args.length == 1 && args.first.is_a?(Hash)
+      query.update_all("$bit" => collect_operations(args.first))
+    else
+      bit_without_mongoid4(*args)
+    end
+  end
+  alias_method_chain :bit, :mongoid4
+
+  def inc_with_mongoid4(*args)
+    if args.length == 1 && args.first.is_a?(Hash)
+      query.update_all("$inc" => collect_operations(args.first))
+    else
+      inc_without_mongoid4(*args)
+    end
+  end
+  alias_method_chain :inc, :mongoid4
+
+  def pop_with_mongoid4(*args)
+    if args.length == 1 && args.first.is_a?(Hash)
+      query.update_all("$pop" => collect_operations(args.first))
+    else
+      pop_without_mongoid4(*args)
+    end
+  end
+  alias_method_chain :pop, :mongoid4
+
+  def pull_with_mongoid4(*args)
+    if args.length == 1 && args.first.is_a?(Hash)
+      query.update_all("$pull" => collect_operations(args.first))
+    else
+      pull_without_mongoid4(*args)
+    end
+  end
+  alias_method_chain :pull, :mongoid4
+
+  def pull_all_with_mongoid4(*args)
+    if args.length == 1 && args.first.is_a?(Hash)
+      query.update_all("$pullAll" => collect_operations(args.first))
+    else
+      pull_all_without_mongoid4(*args)
+    end
+  end
+  alias_method_chain :pull_all, :mongoid4
+
+  def push_with_mongoid4(*args)
+    if args.length == 1 && args.first.is_a?(Hash)
+      query.update_all("$push" => collect_operations(args.first))
+    else
+      push_without_mongoid4(*args)
+    end
+  end
+  alias_method_chain :push, :mongoid4
+
+  def push_all_with_mongoid4(*args)
+    if args.length == 1 && args.first.is_a?(Hash)
+      query.update_all("$pushAll" => collect_operations(args.first))
+    else
+      push_all_without_mongoid4(*args)
+    end
+  end
+  alias_method_chain :push_all, :mongoid4
+
+  def rename_with_mongoid4(*args)
+    if args.length == 1 && args.first.is_a?(Hash)
+      operations = args.first.inject({}) do |ops, (old_name, new_name)|
+        ops[old_name] = new_name.to_s
+        ops
+      end
+      query.update_all("$rename" => collect_operations(operations))
+    else
+      rename_without_mongoid4(*args)
+    end
+  end
+  alias_method_chain :rename, :mongoid4
+
+  def set_with_mongoid4(*args)
+    if args.length == 1 && args.first.is_a?(Hash)
+      query.update_all("$set" => collect_operations(args.first))
+    else
+      set_without_mongoid4(*args)
+    end
+  end
+  alias_method_chain :set, :mongoid4
+
+  private
+
+  def collect_operations(ops)
+    ops.inject({}) do |operations, (field, value)|
+      operations[database_field_name(field)] = value.mongoize
+      operations
+    end
+  end
+end
+end
+end

data/lib/patches/big_decimal.rb

@@ -0,0 +1,38 @@
+# Fixes inconsistent behavior of BigDecimal. This can be removed after
+# https://github.com/mongodb/mongoid/pull/4164 is merged, planned for Mongoid 6.
+
+module MongoidMonkey
+  module Mongoid
+    module Extensions
+      module BigDecimal
+
+        def numeric?
+          true
+        end
+
+        module ClassMethods
+
+          def demongoize(object)
+            object && object.numeric? ? ::BigDecimal.new(object.to_s) : nil
+          end
+
+          def mongoize(object)
+            object && object.numeric? ? object.to_s : nil
+          end
+        end
+      end
+
+      module String
+
+        def numeric?
+          true if Float(self) rescue (self =~ /^NaN|\-?Infinity$/)
+        end
+      end
+    end
+  end
+end
+
+::BigDecimal.__send__(:include, MongoidMonkey::Mongoid::Extensions::BigDecimal)
+::BigDecimal.extend(MongoidMonkey::Mongoid::Extensions::BigDecimal::ClassMethods)
+
+::String.__send__(:include, MongoidMonkey::Mongoid::Extensions::String)

data/lib/patches/instrument.rb

@@ -0,0 +1,45 @@
+# Instrument Moped 1.x same as Moped 2.x.
+# Useful for integration with third-party services.
+
+module Moped
+  module Instrumentable
+    class Noop
+
+      class << self
+
+        # Do not instrument anything.
+        def instrument(name, payload = {})
+          yield payload if block_given?
+        end
+      end
+    end
+  end
+end
+
+module Moped
+  module Instrumentable
+
+    TOPIC = "query.moped"
+
+    def instrumenter
+      @instrumenter ||= Moped::Instrumentable::Noop
+    end
+
+    def instrument(name, payload = {}, &block)
+      instrumenter.instrument(name, payload, &block)
+    end
+  end
+end
+
+module Moped
+  class Node
+    include Moped::Instrumentable
+
+    def logging_with_instrument(operations, &block)
+      instrument(TOPIC, prefix: "  MOPED: #{resolved_address}", ops: operations) do
+        logging_without_instrument(operations, &block)
+      end
+    end
+    alias_method_chain :logging, :instrument
+  end
+end

data/lib/patches/list_collections.rb

@@ -0,0 +1,14 @@
+# Get collection_names via for MongoDB 3.0+ listCollections command.
+# Required to use Moped (Mongoid 3/4) with WiredTiger.
+
+module Moped
+  class Database
+
+    def collection_names
+      namespaces = Collection.new(self, "$cmd").find(listCollections: 1, filter: { name: { "$not" => /system\.|\$/ } }).first
+      namespaces["cursor"]["firstBatch"].map do |doc|
+        doc["name"]
+      end
+    end
+  end
+end

data/lib/patches/reorder.rb

@@ -0,0 +1,11 @@
+# Backport of Criteria#reorder method from Mongoid 4 to Mongoid 3.
+
+module Origin
+  module Optional
+
+    def reorder(*spec)
+      options.delete(:sort)
+      order_by(*spec)
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module MongoidMonkey
+  VERSION = '0.1.0'
+end

data/spec/config/mongodb-mmapv1.conf

@@ -0,0 +1,2 @@
+storage:
+  engine: mmapv1

data/spec/config/mongodb-wiredtiger.conf

@@ -0,0 +1,2 @@
+storage:
+  engine: wiredTiger

data/spec/gemfile/mongoid3.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec path: "../../"
+
+gem 'mongoid', '~> 3'

data/spec/gemfile/mongoid4.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec path: "../../"
+
+gem 'mongoid', '~> 4'

data/spec/gemfile/mongoid5.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec path: "../../"
+
+gem 'mongoid', '~> 5'

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'mongoid'
+require 'mongoid_monkey'
+require 'rspec'
+
+Mongoid.configure do |config|
+  config.connect_to 'mongoid_monkey_test'
+end
+
+Mongoid.logger.level = Logger::INFO
+Mongo::Logger.logger.level = Logger::INFO unless Mongoid::VERSION =~ /\A[34]\./
+
+RSpec.configure do |config|
+  config.after(:all) do
+    if Mongoid::VERSION =~ /\A[34]\./
+      Mongoid.default_session.drop
+    else
+      Mongoid::Clients.default.database.drop
+    end
+  end
+end

data/spec/unit/atomic_spec.rb

@@ -0,0 +1,1067 @@
+require "spec_helper"
+
+if Mongoid::VERSION =~ /\A3\./
+
+  class Band
+    include Mongoid::Document
+    field :name, type: String
+    field :genres, type: Array
+    field :mems, as: :members, type: Array
+    field :likes, type: Integer
+    field :y, as: :years, type: Integer
+  end
+
+  # Mongoid 3
+  describe Mongoid::Contextual::Atomic do
+
+    describe "#add_to_set" do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave" ])
+      end
+
+      let!(:new_order) do
+        Band.create(members: [ "Peter" ])
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      context "when the criteria has no sorting" do
+
+        let(:criteria) do
+          Band.all
+        end
+
+        let(:context) do
+          Mongoid::Contextual::Mongo.new(criteria)
+        end
+
+        before do
+          context.add_to_set(:members, "Dave")
+        end
+
+        it "does not add duplicates" do
+          depeche_mode.reload.members.should eq([ "Dave" ])
+        end
+
+        it "adds unique values" do
+          new_order.reload.members.should eq([ "Peter", "Dave" ])
+        end
+
+        it "adds to non initialized fields" do
+          smiths.reload.members.should eq([ "Dave" ])
+        end
+      end
+
+      context "when the criteria has sorting" do
+
+        let(:criteria) do
+          Band.asc(:name)
+        end
+
+        let(:context) do
+          Mongoid::Contextual::Mongo.new(criteria)
+        end
+
+        before do
+          context.add_to_set(:members, "Dave")
+        end
+
+        it "does not add duplicates" do
+          depeche_mode.reload.members.should eq([ "Dave" ])
+        end
+
+        it "adds unique values" do
+          new_order.reload.members.should eq([ "Peter", "Dave" ])
+        end
+
+        it "adds to non initialized fields" do
+          smiths.reload.members.should eq([ "Dave" ])
+        end
+      end
+    end
+
+    describe "#bit" do
+
+      let!(:depeche_mode) do
+        Band.create(likes: 60)
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      context "when performing a bitwise and" do
+
+        before do
+          context.bit(:likes, { and: 13 })
+        end
+
+        it "performs the bitwise operation on initialized fields" do
+          depeche_mode.reload.likes.should eq(12)
+        end
+
+        it "does not error on non initialized fields" do
+          smiths.reload.likes.should eq(0)
+        end
+      end
+
+      context "when performing a bitwise or" do
+
+        before do
+          context.bit(:likes, { or: 13 })
+        end
+
+        it "performs the bitwise operation on initialized fields" do
+          depeche_mode.reload.likes.should eq(61)
+        end
+
+        it "does not error on non initialized fields" do
+          smiths.reload.likes.should eq(13)
+        end
+      end
+
+      context "when chaining bitwise operations" do
+
+        before do
+          context.bit(:likes, { and: 13, or: 10 })
+        end
+
+        it "performs the bitwise operation on initialized fields" do
+          depeche_mode.reload.likes.should eq(14)
+        end
+
+        it "does not error on non initialized fields" do
+          smiths.reload.likes.should eq(10)
+        end
+      end
+    end
+
+    describe "#inc" do
+
+      let!(:depeche_mode) do
+        Band.create(likes: 60)
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let!(:beatles) do
+        Band.create(years: 2)
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.inc(:likes, 10)
+      end
+
+      context "when the field exists" do
+
+        it "incs the value" do
+          depeche_mode.reload.likes.should eq(70)
+        end
+      end
+
+      context "when the field does not exist" do
+
+        it "does not error on the inc" do
+          smiths.likes.should be_nil
+        end
+      end
+
+      context "when using the alias" do
+
+        before do
+          context.inc(:years, 1)
+        end
+
+        it "incs the value and read from alias" do
+          beatles.reload.years.should eq(3)
+        end
+
+        it "incs the value and read from field" do
+          beatles.reload.y.should eq(3)
+        end
+      end
+    end
+
+    describe "#pop" do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave", "Martin" ])
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      context "when popping from the front" do
+
+        before do
+          context.pop(:members, -1)
+        end
+
+        it "pops the first element off the array" do
+          depeche_mode.reload.members.should eq([ "Martin" ])
+        end
+
+        it "does not error on uninitialized fields" do
+          smiths.reload.members.should be_nil
+        end
+      end
+
+      context "when popping from the rear" do
+
+        before do
+          context.pop(:members, 1)
+        end
+
+        it "pops the last element off the array" do
+          depeche_mode.reload.members.should eq([ "Dave" ])
+        end
+
+        it "does not error on uninitialized fields" do
+          smiths.reload.members.should be_nil
+        end
+      end
+    end
+
+    describe "#pull" do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave", "Alan" ])
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.pull(:members, "Alan")
+      end
+
+      it "pulls when the value is found" do
+        depeche_mode.reload.members.should eq([ "Dave" ])
+      end
+
+      it "does not error on non existant fields" do
+        smiths.reload.members.should be_nil
+      end
+    end
+
+    describe "#pull_all" do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave", "Alan", "Fletch" ])
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.pull_all(:members, [ "Alan", "Dave" ])
+      end
+
+      it "pulls when the values are found" do
+        depeche_mode.reload.members.should eq([ "Fletch" ])
+      end
+
+      it "does not error on non existant fields" do
+        smiths.reload.members.should be_nil
+      end
+    end
+
+    describe "#push" do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave" ])
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.push(:members, "Alan")
+      end
+
+      it "pushes the value to existing arrays" do
+        depeche_mode.reload.members.should eq([ "Dave", "Alan" ])
+      end
+
+      it "pushes to non existant fields" do
+        smiths.reload.members.should eq([ "Alan" ])
+      end
+    end
+
+    describe "#push_all" do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave" ])
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.push_all(:members, [ "Alan", "Fletch" ])
+      end
+
+      it "pushes the values to existing arrays" do
+        depeche_mode.reload.members.should eq([ "Dave", "Alan", "Fletch" ])
+      end
+
+      it "pushes to non existant fields" do
+        smiths.reload.members.should eq([ "Alan", "Fletch" ])
+      end
+    end
+
+    describe "#rename" do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave" ])
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.rename(:members, :artists)
+      end
+
+      it "renames existing fields" do
+        depeche_mode.reload.artists.should eq([ "Dave" ])
+      end
+
+      it "does not rename non existant fields" do
+        smiths.reload.should_not respond_to(:artists)
+      end
+    end
+
+    describe "#set" do
+
+      let!(:depeche_mode) do
+        Band.create(name: "Depeche Mode")
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.set(:name, "Recoil")
+      end
+
+      it "sets existing fields" do
+        depeche_mode.reload.name.should eq("Recoil")
+      end
+
+      it "sets non existant fields" do
+        smiths.reload.name.should eq("Recoil")
+      end
+    end
+
+    describe "#unset" do
+
+      context "when unsetting a single field" do
+
+        let!(:depeche_mode) do
+          Band.create(name: "Depeche Mode", years: 10)
+        end
+
+        let!(:new_order) do
+          Band.create(name: "New Order", years: 10)
+        end
+
+        let(:criteria) do
+          Band.all
+        end
+
+        let(:context) do
+          Mongoid::Contextual::Mongo.new(criteria)
+        end
+
+        context "when the field is not aliased" do
+
+          before do
+            context.unset(:name)
+          end
+
+          it "unsets the first existing field" do
+            depeche_mode.reload.name.should be_nil
+          end
+
+          it "unsets the last existing field" do
+            new_order.reload.name.should be_nil
+          end
+        end
+
+        context "when the field is aliased" do
+
+          before do
+            context.unset(:years)
+          end
+
+          it "unsets the first existing field" do
+            depeche_mode.reload.years.should be_nil
+          end
+
+          it "unsets the last existing field" do
+            new_order.reload.years.should be_nil
+          end
+        end
+      end
+
+      context "when unsetting multiple fields" do
+
+        let!(:new_order) do
+          Band.create(name: "New Order", genres: [ "electro", "dub" ], years: 10)
+        end
+
+        let(:criteria) do
+          Band.all
+        end
+
+        let(:context) do
+          Mongoid::Contextual::Mongo.new(criteria)
+        end
+
+        context "when the field is not aliased" do
+
+          before do
+            context.unset(:name, :genres)
+          end
+
+          it "unsets name field" do
+            new_order.reload.name.should be_nil
+          end
+
+          it "unsets genres field" do
+            new_order.reload.genres.should be_nil
+          end
+        end
+
+        context "when the field is aliased" do
+
+          before do
+            context.unset(:name, :years)
+          end
+
+          it "unsets the unaliased field" do
+            new_order.reload.name.should be_nil
+          end
+
+          it "unsets the aliased field" do
+            new_order.reload.years.should be_nil
+          end
+        end
+      end
+    end
+  end
+
+  # Mongoid 4
+  describe Mongoid::Contextual::Atomic do
+
+    describe "#add_to_set" do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave" ])
+      end
+
+      let!(:new_order) do
+        Band.create(members: [ "Peter" ])
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      context "when the criteria has no sorting" do
+
+        let(:criteria) do
+          Band.all
+        end
+
+        let(:context) do
+          Mongoid::Contextual::Mongo.new(criteria)
+        end
+
+        before do
+          context.add_to_set(members: "Dave")
+        end
+
+        it "does not add duplicates" do
+          expect(depeche_mode.reload.members).to eq([ "Dave" ])
+        end
+
+        it "adds unique values" do
+          expect(new_order.reload.members).to eq([ "Peter", "Dave" ])
+        end
+
+        it "adds to non initialized fields" do
+          expect(smiths.reload.members).to eq([ "Dave" ])
+        end
+      end
+
+      context "when the criteria has sorting" do
+
+        let(:criteria) do
+          Band.asc(:name)
+        end
+
+        let(:context) do
+          Mongoid::Contextual::Mongo.new(criteria)
+        end
+
+        before do
+          context.add_to_set(members: "Dave", genres: "Electro")
+        end
+
+        it "does not add duplicates" do
+          expect(depeche_mode.reload.members).to eq([ "Dave" ])
+        end
+
+        it "adds multiple operations" do
+          expect(depeche_mode.reload.genres).to eq([ "Electro" ])
+        end
+
+        it "adds unique values" do
+          expect(new_order.reload.members).to eq([ "Peter", "Dave" ])
+        end
+
+        it "adds to non initialized fields" do
+          expect(smiths.reload.members).to eq([ "Dave" ])
+        end
+      end
+    end
+
+    describe "#bit" do
+
+      let!(:depeche_mode) do
+        Band.create(likes: 60)
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      context "when performing a bitwise and" do
+
+        before do
+          context.bit(likes: { and: 13 })
+        end
+
+        it "performs the bitwise operation on initialized fields" do
+          expect(depeche_mode.reload.likes).to eq(12)
+        end
+
+        it "does not error on non initialized fields" do
+          expect(smiths.reload.likes).to eq(0)
+        end
+      end
+
+      context "when performing a bitwise or" do
+
+        before do
+          context.bit(likes: { or: 13 })
+        end
+
+        it "performs the bitwise operation on initialized fields" do
+          expect(depeche_mode.reload.likes).to eq(61)
+        end
+
+        it "does not error on non initialized fields" do
+          expect(smiths.reload.likes).to eq(13)
+        end
+      end
+
+      context "when chaining bitwise operations" do
+
+        before do
+          context.bit(likes: { and: 13, or: 10 })
+        end
+
+        it "performs the bitwise operation on initialized fields" do
+          expect(depeche_mode.reload.likes).to eq(14)
+        end
+
+        it "does not error on non initialized fields" do
+          expect(smiths.reload.likes).to eq(10)
+        end
+      end
+    end
+
+    describe "#inc" do
+
+      let!(:depeche_mode) do
+        Band.create(likes: 60)
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let!(:beatles) do
+        Band.create(years: 2)
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.inc(likes: 10)
+      end
+
+      context "when the field exists" do
+
+        it "incs the value" do
+          expect(depeche_mode.reload.likes).to eq(70)
+        end
+      end
+
+      context "when the field does not exist" do
+
+        it "does not error on the inc" do
+          expect(smiths.likes).to be_nil
+        end
+      end
+
+      context "when using the alias" do
+
+        before do
+          context.inc(years: 1)
+        end
+
+        it "incs the value and read from alias" do
+          expect(beatles.reload.years).to eq(3)
+        end
+
+        it "incs the value and read from field" do
+          expect(beatles.reload.y).to eq(3)
+        end
+      end
+    end
+
+    describe "#pop" do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave", "Martin" ])
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      context "when popping from the front" do
+
+        before do
+          context.pop(members: -1)
+        end
+
+        it "pops the first element off the array" do
+          expect(depeche_mode.reload.members).to eq([ "Martin" ])
+        end
+
+        it "does not error on uninitialized fields" do
+          expect(smiths.reload.members).to be_nil
+        end
+      end
+
+      context "when popping from the rear" do
+
+        before do
+          context.pop(members: 1)
+        end
+
+        it "pops the last element off the array" do
+          expect(depeche_mode.reload.members).to eq([ "Dave" ])
+        end
+
+        it "does not error on uninitialized fields" do
+          expect(smiths.reload.members).to be_nil
+        end
+      end
+    end
+
+    describe "#pull" do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave", "Alan" ])
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.pull(members: "Alan")
+      end
+
+      it "pulls when the value is found" do
+        expect(depeche_mode.reload.members).to eq([ "Dave" ])
+      end
+
+      it "does not error on non existant fields" do
+        expect(smiths.reload.members).to be_nil
+      end
+    end
+
+    describe "#pull_all" do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave", "Alan", "Fletch" ])
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.pull_all(members: [ "Alan", "Dave" ])
+      end
+
+      it "pulls when the values are found" do
+        expect(depeche_mode.reload.members).to eq([ "Fletch" ])
+      end
+
+      it "does not error on non existant fields" do
+        expect(smiths.reload.members).to be_nil
+      end
+    end
+
+    describe "#push" do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave" ])
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.push(members: "Alan")
+      end
+
+      it "pushes the value to existing arrays" do
+        expect(depeche_mode.reload.members).to eq([ "Dave", "Alan" ])
+      end
+
+      it "pushes to non existant fields" do
+        expect(smiths.reload.members).to eq([ "Alan" ])
+      end
+    end
+
+    describe "#push_all" do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave" ])
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.push_all(members: [ "Alan", "Fletch" ])
+      end
+
+      it "pushes the values to existing arrays" do
+        expect(depeche_mode.reload.members).to eq([ "Dave", "Alan", "Fletch" ])
+      end
+
+      it "pushes to non existant fields" do
+        expect(smiths.reload.members).to eq([ "Alan", "Fletch" ])
+      end
+    end
+
+    describe "#rename" do
+
+      let!(:depeche_mode) do
+        Band.create(members: [ "Dave" ])
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.rename(members: :artists)
+      end
+
+      it "renames existing fields" do
+        expect(depeche_mode.reload.artists).to eq([ "Dave" ])
+      end
+
+      it "does not rename non existant fields" do
+        expect(smiths.reload).to_not respond_to(:artists)
+      end
+    end
+
+    describe "#set" do
+
+      let!(:depeche_mode) do
+        Band.create(name: "Depeche Mode")
+      end
+
+      let!(:smiths) do
+        Band.create
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        Mongoid::Contextual::Mongo.new(criteria)
+      end
+
+      before do
+        context.set(name: "Recoil")
+      end
+
+      it "sets existing fields" do
+        expect(depeche_mode.reload.name).to eq("Recoil")
+      end
+
+      it "sets non existant fields" do
+        expect(smiths.reload.name).to eq("Recoil")
+      end
+    end
+
+    describe "#unset" do
+
+      context "when unsetting a single field" do
+
+        let!(:depeche_mode) do
+          Band.create(name: "Depeche Mode", years: 10)
+        end
+
+        let!(:new_order) do
+          Band.create(name: "New Order", years: 10)
+        end
+
+        let(:criteria) do
+          Band.all
+        end
+
+        let(:context) do
+          Mongoid::Contextual::Mongo.new(criteria)
+        end
+
+        context "when the field is not aliased" do
+
+          before do
+            context.unset(:name)
+          end
+
+          it "unsets the first existing field" do
+            expect(depeche_mode.reload.name).to be_nil
+          end
+
+          it "unsets the last existing field" do
+            expect(new_order.reload.name).to be_nil
+          end
+        end
+
+        context "when the field is aliased" do
+
+          before do
+            context.unset(:years)
+          end
+
+          it "unsets the first existing field" do
+            expect(depeche_mode.reload.years).to be_nil
+          end
+
+          it "unsets the last existing field" do
+            expect(new_order.reload.years).to be_nil
+          end
+        end
+      end
+
+      context "when unsetting multiple fields" do
+
+        let!(:new_order) do
+          Band.create(name: "New Order", genres: [ "electro", "dub" ], years: 10)
+        end
+
+        let(:criteria) do
+          Band.all
+        end
+
+        let(:context) do
+          Mongoid::Contextual::Mongo.new(criteria)
+        end
+
+        context "when the field is not aliased" do
+
+          before do
+            context.unset(:name, :genres)
+          end
+
+          it "unsets name field" do
+            expect(new_order.reload.name).to be_nil
+          end
+
+          it "unsets genres field" do
+            expect(new_order.reload.genres).to be_nil
+          end
+        end
+
+        context "when the field is aliased" do
+
+          before do
+            context.unset(:name, :years)
+          end
+
+          it "unsets the unaliased field" do
+            expect(new_order.reload.name).to be_nil
+          end
+
+          it "unsets the aliased field" do
+            expect(new_order.reload.years).to be_nil
+          end
+        end
+      end
+    end
+  end
+end