mongoid 3.1.7 → 4.0.0.alpha1

data/lib/rack/mongoid.rb

@@ -1,2 +0,0 @@
-# encoding: utf-8
-require "rack/mongoid/middleware/identity_map"

data/lib/rack/mongoid/middleware/identity_map.rb

@@ -1,39 +0,0 @@
-# encoding: utf-8
-module Rack
-  module Mongoid
-    module Middleware
-
-      # This middleware contains the behaviour needed to properly use the
-      # identity map in Rack based applications. This middleware will properly
-      # handle Rails or Rack streaming responses.
-      class IdentityMap
-
-        # Initialize the new middleware.
-        #
-        # @example Init the middleware.
-        #   IdentityMap.new(app)
-        #
-        # @param [ Object ] app The application.
-        #
-        # @since 2.1.0
-        def initialize(app)
-          @app = app
-        end
-
-        # Make the request with the provided environment.
-        #
-        # @example Make the request.
-        #   identity_map.call(env)
-        #
-        # @param [ Object ] env The environment.
-        #
-        # @return [ Array ] The status, headers, and response.
-        #
-        # @since 2.1.0
-        def call(env)
-          ::Mongoid.unit_of_work { @app.call(env) }
-        end
-      end
-    end
-  end
-end

data/lib/rails/generators/mongoid/observer/observer_generator.rb

@@ -1,17 +0,0 @@
-# encoding: utf-8
-require "rails/generators/mongoid_generator"
-
-module Mongoid
-  module Generators
-    class ObserverGenerator < Base
-
-      check_class_collision suffix: "Observer"
-
-      def create_observer_file
-        template 'observer.rb.tt', File.join('app/models', class_path, "#{file_name}_observer.rb")
-      end
-
-      hook_for :test_framework
-    end
-  end
-end

data/lib/rails/generators/mongoid/observer/templates/observer.rb.tt

@@ -1,4 +0,0 @@
-<% module_namespacing do -%>
-class <%= class_name %>Observer < Mongoid::Observer
-end
-<% end -%>

data/spec/app/models/actor_observer.rb

@@ -1,15 +0,0 @@
-class ActorObserver < Mongoid::Observer
-  attr_reader :last_after_create_record
-
-  def after_create(record)
-    @last_after_create_record = record
-  end
-
-  def after_custom(record)
-    record.after_custom_count += 1
-  end
-
-  def before_custom(record)
-    @after_custom_called = true
-  end
-end

data/spec/app/models/callback_recorder.rb

@@ -1,25 +0,0 @@
-class CallbackRecorder < Mongoid::Observer
-  observe :actor
-
-  attr_reader :last_callback, :call_count, :last_record
-
-  def initialize
-    reset
-    super
-  end
-
-  def reset
-    @last_callback = nil
-    @call_count = Hash.new(0)
-    @last_record = {}
-  end
-
-  Mongoid::Callbacks.observables.each do |callback|
-    define_method(callback) do |record, &block|
-      @last_callback = callback
-      @call_count[callback] += 1
-      @last_record[callback] = record
-      block ? block.call : true
-    end
-  end
-end

data/spec/app/models/draft.rb

@@ -1,9 +0,0 @@
-class Draft
-  include Mongoid::Document
-
-  field :text
-
-  recursively_embeds_one
-
-  index text: 1
-end

data/spec/app/models/paranoid_phone.rb

@@ -1,25 +0,0 @@
-class ParanoidPhone
-  include Mongoid::Document
-  include Mongoid::Paranoia
-
-  attr_accessor :after_destroy_called, :before_destroy_called
-
-  field :number, type: String
-
-  embedded_in :person
-
-  before_destroy :before_destroy_stub, :halt_me
-  after_destroy :after_destroy_stub
-
-  def before_destroy_stub
-    self.before_destroy_called = true
-  end
-
-  def after_destroy_stub
-    self.after_destroy_called = true
-  end
-
-  def halt_me
-    person.age == 42 ? false : true
-  end
-end

data/spec/app/models/paranoid_post.rb

@@ -1,36 +0,0 @@
-class ParanoidPost
-  include Mongoid::Document
-  include Mongoid::Versioning
-  include Mongoid::Paranoia
-
-  max_versions 2
-
-  field :title, type: String
-
-  attr_accessor :after_destroy_called, :before_destroy_called
-
-  belongs_to :person
-
-  has_and_belongs_to_many :tags
-  has_many :authors, dependent: :delete
-  has_many :titles, dependent: :restrict
-
-  scope :recent, where(created_at: { "$lt" => Time.now, "$gt" => 30.days.ago })
-
-  before_destroy :before_destroy_stub
-  after_destroy :after_destroy_stub
-
-  def before_destroy_stub
-    self.before_destroy_called = true
-  end
-
-  def after_destroy_stub
-    self.after_destroy_called = true
-  end
-
-  class << self
-    def old
-      where(created_at: { "$lt" => 30.days.ago })
-    end
-  end
-end

data/spec/app/models/phone_observer.rb

@@ -1,6 +0,0 @@
-class PhoneObserver < Mongoid::Observer
-
-  def after_save(phone)
-    phone.number_in_observer = phone.number
-  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