mongoid 4.0.2 → 5.0.0

data/lib/mongoid/sessions/validators.rb

@@ -1,2 +0,0 @@
-# encoding: utf-8
-require "mongoid/sessions/validators/storage"

data/lib/mongoid/sessions.rb

@@ -1,125 +0,0 @@
-# encoding: utf-8
-require "mongoid/sessions/factory"
-require "mongoid/sessions/validators"
-require "mongoid/sessions/storage_options"
-require "mongoid/sessions/thread_options"
-require "mongoid/sessions/options"
-
-module Mongoid
-  module Sessions
-    extend ActiveSupport::Concern
-    include StorageOptions
-    include ThreadOptions
-    include Options
-
-    class << self
-      # Clear all sessions from the current thread.
-      #
-      # @example Clear all sessions.
-      #   Mongoid::Sessions.clear
-      #
-      # @return [ Array ] The empty sessions.
-      #
-      # @since 3.0.0
-      def clear
-        Threaded.sessions.clear
-      end
-
-      # Get the default session.
-      #
-      # @example Get the default session.
-      #   Mongoid::Sessions.default
-      #
-      # @return [ Moped::Session ] The default session.
-      #
-      # @since 3.0.0
-      def default
-        Threaded.sessions[:default] ||= Sessions::Factory.default
-      end
-
-      # Disconnect all active sessions.
-      #
-      # @example Disconnect all active sessions.
-      #   Mongoid::Sessions.disconnect
-      #
-      # @return [ true ] True.
-      #
-      # @since 3.1.0
-      def disconnect
-        Threaded.sessions.values.each do |session|
-          session.disconnect
-        end
-      end
-
-      # Get a session with the provided name.
-      #
-      # @example Get a session with the name.
-      #   Mongoid::Sessions.with_name(:replica)
-      #
-      # @param [ Symbol ] name The name of the session.
-      #
-      # @return [ Moped::Session ] The named session.
-      #
-      # @since 3.0.0
-      def with_name(name)
-        Threaded.sessions[name.to_sym] ||= Sessions::Factory.create(name)
-      end
-    end
-
-    # Get the collection for this model from the session. Will check for an
-    # overridden collection name from the store_in macro or the collection
-    # with a pluralized model name.
-    #
-    # @example Get the model's collection.
-    #   Model.collection
-    #
-    # @return [ Moped::Collection ] The collection.
-    #
-    # @since 3.0.0
-    def collection
-      mongo_session[collection_name]
-    end
-
-    def mongo_session
-      super || self.class.mongo_session
-    end
-
-    def collection_name
-      super || self.class.collection_name
-    end
-
-    module ClassMethods
-
-      # Get the session for this model. This is determined in the following order:
-      #
-      #   1. Any custom configuration provided by the 'store_in' macro.
-      #   2. The 'default' session as provided in the mongoid.yml
-      #
-      # @example Get the session.
-      #   Model.mongo_session
-      #
-      # @return [ Moped::Session ] The default moped session.
-      #
-      # @since 3.0.0
-      def mongo_session
-        session = Sessions.with_name(session_name)
-        session.use(database_name)
-        self.persistence_options ? session.with(self.persistence_options) : session
-      end
-
-      # Get the collection for this model from the session. Will check for an
-      # overridden collection name from the store_in macro or the collection
-      # with a pluralized model name.
-      #
-      # @example Get the model's collection.
-      #   Model.collection
-      #
-      # @return [ Moped::Collection ] The collection.
-      #
-      # @since 3.0.0
-      def collection
-        mongo_session[collection_name]
-      end
-    end
-  end
-end

data/lib/mongoid/support/query_counter.rb

@@ -1,23 +0,0 @@
-module Mongoid
-
-  class QueryCounter
-    attr_reader :events
-
-    def initialize
-      @events = []
-    end
-
-    def instrument
-      subscriber = ActiveSupport::Notifications.subscribe('query.moped') do |*args|
-        @events << ActiveSupport::Notifications::Event.new(*args)
-      end
-      yield
-    ensure
-      ActiveSupport::Notifications.unsubscribe(subscriber)
-    end
-
-    def inspect
-      @events.map { |e| e.payload[:ops].map(&:log_inspect) }.join("\n")
-    end
-  end
-end

data/spec/helpers.rb

@@ -1,18 +0,0 @@
-require 'mongoid/support/query_counter'
-
-module Mongoid
-  module SpecHelpers
-    def expect_query(number, &block)
-      query_counter = Mongoid::QueryCounter.new
-      query_counter.instrument(&block)
-      expect(query_counter.events.size).to(eq(number), %[
-Expected to receive #{number} queries, it received #{query_counter.events.size}
-#{query_counter.inspect}
-])
-    end
-
-    def expect_no_queries(&block)
-      expect_query(0, &block)
-    end
-  end
-end

data/spec/mongoid/#atomic_spec.rb#

@@ -1,365 +0,0 @@
-require "spec_helper"
-
-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 $pushAll for modifications" do
-            expect(person.atomic_updates).to eq(
-              {
-                "$set" => { "title" => "Sir" },
-                "$pushAll" => { "addresses" => [
-                    { "_id" => "oxford-st", "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" => "Lionel-", "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: {
-                      "$pushAll" => {
-                        "addresses.0.locations" => [{ "_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: {
-                      "$pushAll" => {
-                        "addresses.0.locations" => [{ "_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: {
-                      "$pushAll" => {
-                        "addresses" => [{
-                          "_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"
-                  },
-                  "$pushAll" => {
-                    "addresses" => [{
-                      "_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 $pushAlls for all levels" do
-            expect(person.atomic_updates).to eq(
-              {
-                "$set" => {
-                  "title" => "Sir",
-                },
-                "$pushAll" => {
-                  "addresses" => [{
-                    "_id" => address.id,
-                    "street" => "Another",
-                    "locations" => [
-                      "_id" => location.id,
-                      "name" => "Home"
-                    ]
-                  }]
-                }
-              }
-            )
-          end
-        end
-      end
-    end
-  end
-end