mongoid-versioning 0.1.0

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,17 @@
+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)
+
+  attr_accessible :title, as: [ :default, :admin ]
+  attr_accessible :year, as: [ :default ]
+  attr_accessible :person_attributes, as: [ :default ]
+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,17 @@
+class WikiPage
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include Mongoid::Versioning
+
+  field :title, type: String
+  field :transient_property, type: String, versioned: false
+  field :author, type: String
+  field :description, type: String, localize: true
+  max_versions 5
+
+  attr_protected :author
+
+  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,12 @@
+class Word
+  include Mongoid::Document
+  field :name, 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
+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,40 @@
+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:
+    allow_dynamic_fields: true
+    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
+    skip_version_check: true
+    use_activesupport_time_zone: true
+    use_utc: false

data/spec/mongoid/versioning_spec.rb

@@ -0,0 +1,540 @@
+require "spec_helper"
+
+describe Mongoid::Versioning do
+
+  describe ".max_versions" do
+
+    context "when provided an integer" do
+
+      before do
+        WikiPage.max_versions(10)
+      end
+
+      after do
+        WikiPage.max_versions(5)
+      end
+
+      it "sets the class version max" do
+        WikiPage.version_max.should eq(10)
+      end
+    end
+
+    context "when provided a string" do
+
+      before do
+        WikiPage.max_versions("10")
+      end
+
+      after do
+        WikiPage.max_versions(5)
+      end
+
+      it "sets the class version max" do
+        WikiPage.version_max.should eq(10)
+      end
+    end
+  end
+
+  describe "#version" do
+
+    context "when there is no default scope" do
+
+      context "when the document is new" do
+
+        it "returns 1" do
+          WikiPage.new.version.should eq(1)
+        end
+      end
+
+      context "when the document is persisted once" do
+
+        let(:page) do
+          WikiPage.create(title: "1")
+        end
+
+        it "returns 1" do
+          page.version.should eq(1)
+        end
+      end
+
+      context "when the document is persisted more than once" do
+
+        let(:page) do
+          WikiPage.create(title: "1")
+        end
+
+        before do
+          3.times { |n| page.update_attribute(:title, "#{n}") }
+        end
+
+        it "returns the number of versions" do
+          page.version.should eq(4)
+        end
+      end
+
+      context "when maximum versions is defined" do
+
+        let(:page) do
+          WikiPage.create(title: "1")
+        end
+
+        context "when saving over the max versions limit" do
+
+          before do
+            10.times { |n| page.update_attribute(:title, "#{n}") }
+          end
+
+          it "returns the number of versions" do
+            page.version.should eq(11)
+          end
+        end
+      end
+
+      context "when performing versionless saves" do
+
+        let(:page) do
+          WikiPage.create(title: "1")
+        end
+
+        before do
+          10.times do |n|
+            page.versionless { |doc| doc.update_attribute(:title, "#{n}") }
+          end
+        end
+
+        it "does not increment the version number" do
+          page.version.should eq(1)
+        end
+      end
+    end
+
+    context "when there is a default scope" do
+
+      before :all do
+        class WikiPage
+          default_scope where(author: "Jim")
+        end
+      end
+
+      after :all do
+        WikiPage.default_scoping = nil
+      end
+
+      context "when the document is new" do
+
+        it "returns 1" do
+          WikiPage.new.version.should eq(1)
+        end
+      end
+
+      context "when the document is persisted once" do
+
+        let(:page) do
+          WikiPage.create(title: "1")
+        end
+
+        it "returns 1" do
+          page.version.should eq(1)
+        end
+      end
+
+      context "when the document is persisted more than once" do
+
+        let(:page) do
+          WikiPage.create(title: "1")
+        end
+
+        before do
+          3.times { |n| page.update_attribute(:title, "#{n}") }
+        end
+
+        it "returns the number of versions" do
+          page.version.should eq(4)
+        end
+      end
+
+      context "when maximum versions is defined" do
+
+        let(:page) do
+          WikiPage.create(title: "1")
+        end
+
+        context "when saving over the max versions limit" do
+
+          before do
+            10.times { |n| page.update_attribute(:title, "#{n}") }
+          end
+
+          it "returns the number of versions" do
+            page.version.should eq(11)
+          end
+        end
+      end
+
+      context "when performing versionless saves" do
+
+        let(:page) do
+          WikiPage.create(title: "1")
+        end
+
+        before do
+          10.times do |n|
+            page.versionless { |doc| doc.update_attribute(:title, "#{n}") }
+          end
+        end
+
+        it "does not increment the version number" do
+          page.version.should eq(1)
+        end
+      end
+    end
+
+    context "when not using the default database" do
+
+      let(:title) { "my new wiki" }
+
+      let!(:page) do
+        WikiPage.with(database: "mongoid_test_alt").create!(description: "1",title: title)
+      end
+
+      context "when the document is persisted once" do
+
+        it "returns 1" do
+          page.version.should eq(1)
+        end
+
+        it "does not persist to default database" do
+          expect {
+            WikiPage.find_by(title: title)
+          }.to raise_error(Mongoid::Errors::DocumentNotFound)
+        end
+
+        it "persists to specified database" do
+          WikiPage.with(database: "mongoid_test_alt").find_by(title: title).should_not be_nil
+        end
+      end
+
+      context "when the document is persisted more than once" do
+
+        before do
+          3.times { |n| page.with(database: "mongoid_test_alt").update_attribute(:description, "#{n}") }
+        end
+
+        it "returns the number of versions" do
+          page.version.should eq(4)
+        end
+
+        it "persists to specified database" do
+          WikiPage.with(database: "mongoid_test_alt").find_by(:title => title).should_not be_nil
+        end
+
+        it "persists the versions to specified database" do
+          WikiPage.with(database: "mongoid_test_alt").find_by(:title => title).version.should eq(4)
+        end
+      end
+    end
+  end
+
+  describe "#versionless" do
+
+    let(:page) do
+      WikiPage.new(created_at: Time.now.utc)
+    end
+
+    context "when executing the block" do
+
+      it "sets versionless to true" do
+        page.versionless do |doc|
+          doc.should be_versionless
+        end
+      end
+    end
+
+    context "when the block finishes" do
+
+      it "sets versionless to false" do
+        page.versionless
+        page.should_not be_versionless
+      end
+    end
+  end
+
+  describe "#versions" do
+
+    let(:page) do
+      WikiPage.create(title: "1", description: "test") do |wiki|
+        wiki.author = "woodchuck"
+      end
+    end
+
+    context "when saving the document " do
+
+      context "when the document has changed" do
+
+        before do
+          page.update_attribute(:title, "2")
+        end
+
+        let(:version) do
+          page.versions.first
+        end
+
+        it "creates a new version" do
+          version.title.should eq("1")
+        end
+
+        it "properly versions the localized fields" do
+          version.description.should eq("test")
+        end
+
+        it "only creates 1 new version" do
+          page.versions.count.should eq(1)
+        end
+
+        it "does not version the _id" do
+          version._id.should be_nil
+        end
+
+        it "does version the updated_at timestamp" do
+          version.updated_at.should_not be_nil
+        end
+
+        context "when only updated_at was changed" do
+
+          before do
+            page.update_attributes(updated_at: Time.now)
+          end
+
+          it "does not generate another version" do
+            page.versions.count.should eq(1)
+          end
+        end
+
+        it "does not embed versions within versions" do
+          version.versions.should be_empty
+        end
+
+        it "versions protected fields" do
+          version.author.should eq("woodchuck")
+        end
+
+        context "when saving multiple times" do
+
+          before do
+            page.update_attribute(:title, "3")
+          end
+
+          it "does not embed versions within versions" do
+            version.versions.should be_empty
+          end
+
+          it "does not embed versions multiple levels deep" do
+            page.versions.last.versions.should be_empty
+          end
+        end
+      end
+
+      context "when the document has not changed" do
+
+        before do
+          page.save
+        end
+
+        let(:version) do
+          page.versions.first
+        end
+
+        it "does not create a new version" do
+          version.should be_nil
+        end
+      end
+
+      context "when saving over the number of maximum versions" do
+
+        context "when the document is paranoid" do
+
+          let!(:post) do
+            ParanoidPost.create(title: "test")
+          end
+
+          before do
+            3.times do |n|
+              post.update_attribute(:title, "#{n}")
+            end
+          end
+
+          it "only versions the maximum amount" do
+            post.versions.target.size.should eq(2)
+          end
+
+          it "persists the changes" do
+            post.reload.versions.target.size.should eq(2)
+          end
+        end
+
+        context "when saving in succession" do
+
+          before do
+            10.times do |n|
+              page.update_attribute(:title, "#{n}")
+            end
+          end
+
+          let(:versions) do
+            page.versions
+          end
+
+          it "only versions the maximum amount" do
+            versions.count.should eq(5)
+          end
+
+          it "shifts the versions in order" do
+            versions.last.title.should eq("8")
+          end
+
+          it "persists the version shifts" do
+            page.reload.versions.last.title.should eq("8")
+          end
+        end
+
+        context "when saving in batches" do
+
+          before do
+            2.times do
+              5.times do |n|
+                WikiPage.find(page.id).update_attributes(title: "#{n}")
+              end
+            end
+          end
+
+          let(:from_db) do
+            WikiPage.find(page.id)
+          end
+
+          let(:versions) do
+            from_db.versions
+          end
+
+          it "only versions the maximum amount" do
+            versions.count.should eq(5)
+          end
+        end
+      end
+
+      context "when persisting versionless" do
+
+        before do
+          page.versionless { |doc| doc.update_attribute(:title, "2") }
+        end
+
+        it "does not version the document" do
+          page.versions.count.should eq(0)
+        end
+      end
+
+      context "when deleting versions" do
+
+        let(:comment) do
+          Comment.new(title: "Don't delete me!")
+        end
+
+        let!(:orphaned) do
+          Comment.create(title: "Annie")
+        end
+
+        before do
+          page.comments << comment
+          page.update_attribute(:title, "5")
+        end
+
+        context "when the version had a dependent relation" do
+
+          before do
+            page.versions.delete_all
+          end
+
+          let(:from_db) do
+            Comment.find(comment.id)
+          end
+
+          it "does not perform dependent cascading" do
+            from_db.should eq(comment)
+          end
+
+          it "does not delete related orphans" do
+            Comment.find(orphaned.id).should eq(orphaned)
+          end
+
+          it "deletes the version" do
+            page.versions.should be_empty
+          end
+
+          it "persists the deletion" do
+            page.reload.versions.should be_empty
+          end
+
+          it "retains the root relation" do
+            page.reload.comments.should eq([ comment ])
+          end
+        end
+      end
+    end
+  end
+
+  context "when appending a self referencing document with versions" do
+
+    let(:page) do
+      WikiPage.create(title: "1")
+    end
+
+    let(:child) do
+      WikiPage.new
+    end
+
+    before do
+      page.child_pages << child
+    end
+
+    it "allows the document to be added" do
+      page.child_pages.should eq([ child ])
+    end
+
+    it "persists the changes" do
+      page.reload.child_pages.should eq([ child ])
+    end
+  end
+
+  context "when the identity map is enabled" do
+
+    before do
+      Mongoid.identity_map_enabled = true
+    end
+
+    after do
+      Mongoid.identity_map_enabled = false
+    end
+
+    context "when updating a loaded attribute" do
+
+      let!(:page) do
+        WikiPage.create(title: "first")
+      end
+
+      let!(:loaded) do
+        WikiPage.find(page.id)
+      end
+
+      before do
+        loaded.update_attribute(:title, "revised")
+      end
+
+      let(:reloaded) do
+        WikiPage.find(page.id)
+      end
+
+      it "returns the revised im memory document" do
+        reloaded.title.should eq("revised")
+      end
+    end
+  end
+end