mongoid_rails4 4.0.0

data/spec/app/models/translation.rb

@@ -0,0 +1,5 @@
+class Translation
+  include Mongoid::Document
+  field :language
+  embedded_in :name
+end

data/spec/app/models/tree.rb

@@ -0,0 +1,9 @@
+class Tree
+  include Mongoid::Document
+
+  field :name
+  field :evergreen, type: Boolean
+
+  scope :verdant, where(evergreen: true)
+  default_scope asc(:name)
+end

data/spec/app/models/truck.rb

@@ -0,0 +1,3 @@
+class Truck < Vehicle
+  embeds_one :bed
+end

data/spec/app/models/user.rb

@@ -0,0 +1,21 @@
+class User
+  include Mongoid::Document
+
+  field :name
+  field :last_login, type: DateTime
+  field :account_expires, type: Date
+
+  has_one :account, foreign_key: :creator_id, validate: false
+  has_many :posts, foreign_key: :author_id, validate: false
+  has_many :descriptions
+  has_one :role, validate: false
+
+  has_and_belongs_to_many :followed_shops, inverse_of: :followers, class_name: "Shop"
+  has_and_belongs_to_many :businesses, class_name: "Business", validate: false
+  has_one :shop
+
+  belongs_to :next, class_name: "User"
+
+  accepts_nested_attributes_for :posts
+  index name: 1
+end

data/spec/app/models/user_account.rb

@@ -0,0 +1,10 @@
+class UserAccount
+  include Mongoid::Document
+  field :username, type: String
+  field :name, type: String
+  field :email, type: String
+  validates_uniqueness_of :username, message: "is not unique"
+  validates_uniqueness_of :email, message: "is not unique", case_sensitive: false
+  validates_length_of :name, minimum: 2, allow_nil: true
+  has_and_belongs_to_many :people
+end

data/spec/app/models/validation_callback.rb

@@ -0,0 +1,10 @@
+class ValidationCallback
+  include Mongoid::Document
+  field :history, type: Array, default: []
+  validate do
+    self.history << :validate
+  end
+
+  before_validation { self.history << :before_validation }
+  after_validation { self.history << :after_validation }
+end

data/spec/app/models/vehicle.rb

@@ -0,0 +1,11 @@
+class Vehicle
+  include Mongoid::Document
+  belongs_to :shipping_container
+  belongs_to :driver
+
+  accepts_nested_attributes_for :driver
+  accepts_nested_attributes_for :shipping_container
+end
+
+require "app/models/car"
+require "app/models/truck"

data/spec/app/models/version.rb

@@ -0,0 +1,5 @@
+class Version
+  include Mongoid::Document
+  field :number, type: Integer
+  embedded_in :memorable, polymorphic: true
+end

data/spec/app/models/vet_visit.rb

@@ -0,0 +1,5 @@
+class VetVisit
+  include Mongoid::Document
+  field :date, type: Date
+  embedded_in :pet
+end

data/spec/app/models/video.rb

@@ -0,0 +1,13 @@
+class Video
+  include Mongoid::Document
+  field :title, type: String
+  field :year, type: Integer
+  field :release_dates, type: Set
+  field :genres, type: Array
+
+  embedded_in :person
+  belongs_to :post
+  belongs_to :game
+
+  default_scope asc(:title)
+end

data/spec/app/models/weapon.rb

@@ -0,0 +1,11 @@
+class Weapon
+  include Mongoid::Document
+
+  field :name
+
+  belongs_to :player, inverse_of: :weapons
+
+  after_build do
+    self.name = "Holy Hand Grenade (#{player.frags})"
+  end
+end

data/spec/app/models/wiki_page.rb

@@ -0,0 +1,14 @@
+class WikiPage
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  field :title, type: String
+  field :transient_property, type: String
+  field :author, type: String
+  field :description, type: String, localize: true
+  max_versions 5
+
+  has_many :comments, dependent: :destroy, validate: false
+  has_many :child_pages, class_name: "WikiPage", dependent: :delete, inverse_of: :parent_pages
+  belongs_to :parent_pages, class_name: "WikiPage", inverse_of: :child_pages
+end

data/spec/app/models/word.rb

@@ -0,0 +1,15 @@
+class Word
+  include Mongoid::Document
+  field :name, type: String
+  field :origin, type: String
+
+  belongs_to :dictionary
+
+  embeds_many :definitions, validate: false
+  embeds_many :word_origins, validate: false
+  embeds_one :pronunciation, validate: false
+
+  accepts_nested_attributes_for :definitions, allow_destroy: true
+
+  index({ name: "text" }, default_language: "english")
+end

data/spec/app/models/word_origin.rb

@@ -0,0 +1,11 @@
+class WordOrigin
+  include Mongoid::Document
+
+  field :_id, type: Integer, default: ->{ origin_id }
+
+  field :origin_id, type: Integer
+  field :country, type: String
+  field :city, type: String
+
+  embedded_in :word
+end

data/spec/app/models/writer.rb

@@ -0,0 +1,11 @@
+class Writer
+  include Mongoid::Document
+  field :speed, type: Integer, default: 0
+
+  embedded_in :canvas
+
+  def write; end
+end
+
+require "app/models/pdf_writer"
+require "app/models/html_writer"

data/spec/config/mongoid.yml

@@ -0,0 +1,38 @@
+test:
+  sessions:
+    default:
+      database: mongoid_test
+      hosts:
+        - <%=ENV["MONGOID_SPEC_HOST"]%>:<%=ENV["MONGOID_SPEC_PORT"]%>
+      options:
+        consistency: :strong
+    mongohq_single:
+      database: <%=ENV["MONGOHQ_SINGLE_NAME"]%>
+      username: <%=ENV["MONGOHQ_SINGLE_USER"]%>
+      password: <%=ENV["MONGOHQ_SINGLE_PASS"]%>
+      hosts:
+        - <%=ENV["MONGOHQ_SINGLE_URL"]%>
+      options:
+        safe: true
+        consistency: :strong
+    mongohq_repl:
+      database: <%=ENV["MONGOHQ_REPL_NAME"]%>
+      username: <%=ENV["MONGOHQ_REPL_USER"]%>
+      password: <%=ENV["MONGOHQ_REPL_PASS"]%>
+      hosts:
+        - <%=ENV["MONGOHQ_REPL_1_URL"]%>
+        - <%=ENV["MONGOHQ_REPL_2_URL"]%>
+      options:
+        consistency: :strong
+        safe: true
+    mongohq_repl_uri:
+      uri: <%= ENV["MONGOHQ_REPL_URI"]%>
+  options:
+    identity_map_enabled: false
+    include_root_in_json: false
+    include_type_for_serialization: false
+    preload_models: false
+    scope_overwrite_exception: false
+    raise_not_found_error: true
+    use_activesupport_time_zone: true
+    use_utc: false

data/spec/mongoid/atomic/modifiers_spec.rb

@@ -0,0 +1,456 @@
+require "spec_helper"
+
+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(
+            { "$pushAll" =>
+              { "addresses" => [
+                  { "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(
+            { "$pushAll" =>
+              { "addresses" => [
+                  { "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: { "$pushAll" =>
+                { "addresses" => [
+                    { "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: { "$pushAll" =>
+                { "addresses" => [
+                    { "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(
+            { "$pushAll" => {
+              "addresses.0.locations" => [{ "street" => "Bond St" }]},
+              conflicts: { "$pushAll" =>
+                { "addresses" => [
+                    { "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