mongoid 3.1.6 → 4.0.2

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/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/attributes/processing_spec.rb

@@ -1,149 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Attributes::Processing do
-
-  describe "#process_attributes" do
-
-    let(:building) do
-      Building.new
-    end
-
-    context "when setting embedded documents via the parent" do
-
-      let(:attributes) do
-        {
-          building_address: { city: "Berlin" },
-          contractors: [{ name: "Joe" }]
-        }
-      end
-
-      context "when providing a role" do
-
-        context "when creating new documents" do
-
-          before do
-            building.process_attributes(attributes, :admin, true)
-          end
-
-          let(:building_address) do
-            building.building_address
-          end
-
-          let(:contractor) do
-            building.contractors.first
-          end
-
-          context "when the child fields are accessible to the role" do
-
-            it "sets the fields on the 1-1 child" do
-              building_address.city.should eq("Berlin")
-            end
-
-            it "sets the fields on the 1-n child" do
-              contractor.name.should eq("Joe")
-            end
-          end
-
-          context "when updating the document" do
-
-            let(:updates) do
-              {
-                building_address: { city: "Kiew" },
-                contractors: [{ name: "Jim" }]
-              }
-            end
-
-            before do
-              building.process_attributes(updates, :admin, true)
-            end
-
-            it "updates the 1-1 child" do
-              building_address.city.should eq("Kiew")
-            end
-
-            it "updates the 1-n child" do
-              contractor.name.should eq("Jim")
-            end
-          end
-        end
-      end
-
-      context "when turning off mass assignment" do
-
-        context "when creating new documents" do
-
-          before do
-            building.process_attributes(attributes, :default, false)
-          end
-
-          let(:building_address) do
-            building.building_address
-          end
-
-          let(:contractor) do
-            building.contractors.first
-          end
-
-          context "when the child fields are accessible to the role" do
-
-            it "sets the fields on the 1-1 child" do
-              building_address.city.should eq("Berlin")
-            end
-
-            it "sets the fields on the 1-n child" do
-              contractor.name.should eq("Joe")
-            end
-          end
-
-          context "when updating the document" do
-
-            let(:updates) do
-              {
-                building_address: { city: "Kiew" },
-                contractors: [{ name: "Jim" }]
-              }
-            end
-
-            before do
-              building.process_attributes(updates, :default, false)
-            end
-
-            it "updates the 1-1 child" do
-              building_address.city.should eq("Kiew")
-            end
-
-            it "updates the 1-n child" do
-              contractor.name.should eq("Jim")
-            end
-
-            context "with a key that is not a valid ruby identifier" do
-              let(:dynamic_updates) do
-                {
-                  building_address: { :"postal-code" => "V8N 1A1" },
-                  contractors: [{ :"license number" => "12345" }]
-                }
-              end
-
-              before do
-                building.process_attributes(dynamic_updates, :default, false)
-              end
-
-              it "updates the 1-1 child" do
-                building_address['postal-code'].should eq("V8N 1A1")
-              end
-
-              it "updates the 1-n child" do
-                contractor['license number'].should eq("12345")
-              end
-
-              it "correctly handles a second call to #process_attributes" do
-                building.process_attributes(dynamic_updates, :default, false)
-              end
-            end
-
-          end
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/criterion/destructive_spec.rb

@@ -1,101 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Criteria do
-
-  let(:name) do
-    Name.new(first_name: "Durran")
-  end
-
-  let(:address_one) do
-    Address.new(street: "Forsterstr")
-  end
-
-  let(:address_two) do
-    Address.new(street: "Hobrechtstr")
-  end
-
-  before do
-    Person.create(title: "Madam")
-    2.times do |n|
-      Person.create(
-        title: "Sir",
-        name: name,
-        addresses: [ address_one, address_two ]
-      )
-    end
-  end
-
-  [ :delete, :delete_all, :destroy, :destroy_all ].each do |method|
-
-    describe "##{method}" do
-
-      context "when removing root documents" do
-
-        let(:criteria) do
-          Person.where(title: "Sir", :age.gt => 5)
-        end
-
-        let!(:removed) do
-          criteria.send(method)
-        end
-
-        it "deletes the removes the documents from the database" do
-          Person.count.should eq(1)
-        end
-
-        it "returns the number removed" do
-          removed.should eq(2)
-        end
-      end
-
-      context "when removing embedded documents" do
-
-        context "when removing a single document" do
-
-          let(:person) do
-            Person.where(title: "Sir").first
-          end
-
-          let(:criteria) do
-            person.addresses.where(street: "Forsterstr")
-          end
-
-          let!(:removed) do
-            criteria.send(method)
-          end
-
-          it "deletes the removes the documents from the database" do
-            person.addresses.count.should eq(1)
-          end
-
-          it "returns the number removed" do
-            removed.should eq(1)
-          end
-        end
-
-        context "when removing multiple documents" do
-
-          let(:person) do
-            Person.where(title: "Sir").first
-          end
-
-          let(:criteria) do
-            person.addresses.where(city: nil)
-          end
-
-          let!(:removed) do
-            criteria.send(method)
-          end
-
-          it "deletes the removes the documents from the database" do
-            person.addresses.count.should eq(0)
-          end
-
-          it "returns the number removed" do
-            removed.should eq(2)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/criterion/modifiable_spec.rb

@@ -1,409 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Criterion::Modifiable do
-
-  describe ".find_or_create_by" do
-
-    context "when the document is found" do
-
-      context "when providing an attribute" do
-
-        let!(:person) do
-          Person.create(title: "Senior")
-        end
-
-        it "returns the document" do
-          Person.find_or_create_by(title: "Senior").should eq(person)
-        end
-      end
-
-      context "when providing a document" do
-
-        context "with an owner with a BSON identity type" do
-
-          let!(:person) do
-            Person.create
-          end
-
-          let!(:game) do
-            Game.create(person: person)
-          end
-
-          context "when providing the object directly" do
-
-            let(:from_db) do
-              Game.find_or_create_by(person: person)
-            end
-
-            it "returns the document" do
-              from_db.should eq(game)
-            end
-          end
-
-          context "when providing the proxy relation" do
-
-            let(:from_db) do
-              Game.find_or_create_by(person: game.person)
-            end
-
-            it "returns the document" do
-              from_db.should eq(game)
-            end
-          end
-        end
-
-        context "with an owner with an Integer identity type" do
-
-          let!(:jar) do
-            Jar.create
-          end
-
-          let!(:cookie) do
-            Cookie.create(jar: jar)
-          end
-
-          let(:from_db) do
-            Cookie.find_or_create_by(jar: jar)
-          end
-
-          it "returns the document" do
-            from_db.should eq(cookie)
-          end
-        end
-      end
-    end
-
-    context "when the document is not found" do
-
-      context "when providing a document" do
-
-        let!(:person) do
-          Person.create
-        end
-
-        let!(:game) do
-          Game.create
-        end
-
-        let(:from_db) do
-          Game.find_or_create_by(person: person)
-        end
-
-        it "returns the new document" do
-          from_db.person.should eq(person)
-        end
-
-        it "does not return an existing false document" do
-          from_db.should_not eq(game)
-        end
-      end
-
-      context "when not providing a block" do
-
-        let!(:person) do
-          Person.find_or_create_by(title: "Senorita")
-        end
-
-        it "creates a persisted document" do
-          person.should be_persisted
-        end
-
-        it "sets the attributes" do
-          person.title.should eq("Senorita")
-        end
-      end
-
-      context "when providing a block" do
-
-        let!(:person) do
-          Person.find_or_create_by(title: "Senorita") do |person|
-            person.pets = true
-          end
-        end
-
-        it "creates a persisted document" do
-          person.should be_persisted
-        end
-
-        it "sets the attributes" do
-          person.title.should eq("Senorita")
-        end
-
-        it "calls the block" do
-          person.pets.should be_true
-        end
-      end
-    end
-  end
-
-  describe ".find_or_initialize_by" do
-
-    context "when the document is found" do
-
-      let!(:person) do
-        Person.create(title: "Senior")
-      end
-
-      it "returns the document" do
-        Person.find_or_initialize_by(title: "Senior").should eq(person)
-      end
-    end
-
-    context "when the document is not found" do
-
-      context "when not providing a block" do
-
-        let!(:person) do
-          Person.find_or_initialize_by(title: "Senorita")
-        end
-
-        it "creates a new document" do
-          person.should be_new_record
-        end
-
-        it "sets the attributes" do
-          person.title.should eq("Senorita")
-        end
-      end
-
-      context "when providing a block" do
-
-        let!(:person) do
-          Person.find_or_initialize_by(title: "Senorita") do |person|
-            person.pets = true
-          end
-        end
-
-        it "creates a new document" do
-          person.should be_new_record
-        end
-
-        it "sets the attributes" do
-          person.title.should eq("Senorita")
-        end
-
-        it "calls the block" do
-          person.pets.should be_true
-        end
-      end
-    end
-  end
-
-  describe "first_or_create" do
-
-    let!(:band) do
-      Band.create(name: "Depeche Mode")
-    end
-
-    context "when the document is found" do
-
-      let(:found) do
-        Band.where(name: "Depeche Mode").first_or_create
-      end
-
-      it "returns the document" do
-        expect(found).to eq(band)
-      end
-    end
-
-    context "when the document is not found" do
-
-      context "when attributes are provided" do
-
-        let(:document) do
-          Band.where(name: "Tool").first_or_create(origin: "Essex")
-        end
-
-        it "returns a new document" do
-          expect(document.name).to eq("Tool")
-        end
-
-        it "returns a persisted document" do
-          expect(document).to be_persisted
-        end
-
-        it "sets the additional attributes" do
-          expect(document.origin).to eq("Essex")
-        end
-      end
-
-      context "when attributes are not provided" do
-
-        let(:document) do
-          Band.where(name: "Tool").first_or_create
-        end
-
-        it "returns a new document" do
-          expect(document.name).to eq("Tool")
-        end
-
-        it "returns a persisted document" do
-          expect(document).to be_persisted
-        end
-      end
-
-      context "when a block is provided" do
-
-        let(:document) do
-          Band.where(name: "Tool").first_or_create do |doc|
-            doc.active = false
-          end
-        end
-
-        it "returns a new document" do
-          expect(document.name).to eq("Tool")
-        end
-
-        it "returns a persisted document" do
-          expect(document).to be_persisted
-        end
-
-        it "yields to the block" do
-          expect(document.active).to be_false
-        end
-      end
-
-      context "when the criteria is complex" do
-
-        context "when the document is not found" do
-
-          let(:document) do
-            Band.in(name: [ "New Order" ]).first_or_create(active: false)
-          end
-
-          it "returns a new document" do
-            expect(document.active).to be_false
-          end
-
-          it "returns a persisted document" do
-            expect(document).to be_persisted
-          end
-        end
-      end
-    end
-  end
-
-  describe "first_or_create!" do
-
-    context "when validation fails on the new document" do
-
-      it "raises an error" do
-        expect {
-          Account.where(number: "12345").first_or_create!
-        }.to raise_error(Mongoid::Errors::Validations)
-      end
-    end
-
-    context "when passing a block" do
-
-      let(:account) do
-        Account.where(number: "12345").first_or_create! do |account|
-          account.name = "testing"
-        end
-      end
-
-      it "passes the block to the create call" do
-        expect(account.name).to eq("testing")
-      end
-
-      it "persists the new document" do
-        expect(account).to be_persisted
-      end
-    end
-
-    context "when the document is found" do
-
-      let!(:band) do
-        Band.with(safe: true).create!(name: "Depeche Mode")
-      end
-
-      let(:found) do
-        Band.where(name: "Depeche Mode").first_or_create!
-      end
-
-      it "returns the document" do
-        expect(found).to eq(band)
-      end
-    end
-
-    context "when the document is not found" do
-
-      let!(:band) do
-        Band.with(safe: true).create!(name: "Depeche Mode")
-      end
-
-      context "when attributes are provided" do
-
-        let(:document) do
-          Band.where(name: "Tool").first_or_create!(origin: "Essex")
-        end
-
-        it "returns a new document" do
-          expect(document.name).to eq("Tool")
-        end
-
-        it "returns a persisted document" do
-          expect(document).to be_persisted
-        end
-
-        it "sets the additional attributes" do
-          expect(document.origin).to eq("Essex")
-        end
-      end
-
-      context "when attributes are not provided" do
-
-        let(:document) do
-          Band.where(name: "Tool").first_or_create!
-        end
-
-        it "returns a new document" do
-          expect(document.name).to eq("Tool")
-        end
-
-        it "returns a persisted document" do
-          expect(document).to be_persisted
-        end
-      end
-
-      context "when a block is provided" do
-
-        let(:document) do
-          Band.where(name: "Tool").first_or_create! do |doc|
-            doc.active = false
-          end
-        end
-
-        it "returns a new document" do
-          expect(document.name).to eq("Tool")
-        end
-
-        it "returns a persisted document" do
-          expect(document).to be_persisted
-        end
-
-        it "yields to the block" do
-          expect(document.active).to be_false
-        end
-      end
-
-      context "when the criteria is complex" do
-
-        context "when the document is not found" do
-
-          let(:document) do
-            Band.in(name: [ "New Order" ]).first_or_create!(active: false)
-          end
-
-          it "returns a new document" do
-            expect(document.active).to be_false
-          end
-
-          it "returns a persisted document" do
-            expect(document).to be_persisted
-          end
-        end
-      end
-    end
-  end
-end