mongoid_versioning 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1541712ab768cbdfe3e5feff620d363e15f26c36
-  data.tar.gz: 502a9f2582215937f32dc231a1bfe92bebe4d68f
+  metadata.gz: 87547bda9b49e1db52669360fa1c652b81797bbc
+  data.tar.gz: 4970ab0963f35517304e732b5779fb2fa928f62c
 SHA512:
-  metadata.gz: b36237f72a53a2d07d660c65a3bcfa67e41c9d665b6a4e8616795f070f44be2c06cdc41f6306b02650612afd5407ecc179c615a8e43cfe5f8b6eada0744794f6
-  data.tar.gz: 73460dbb43b06e4235288c944ac2d1d62411d726bab2afedeb7fd5136528018f6aaf2b6a4bce9f2ab8201075b507339da1cc13a93c42983c88ff3f4c84d80439
+  metadata.gz: 25ae935bcacf3284bd31d7af9b03203b0f9b45801f3cfacd959114c8ce3b53bf47a69b6760400de0d493d3df48f9632e60c15466ba3a66ffceac00088f02d643
+  data.tar.gz: 736f7cf63d417a05d4d48c12ad593722cd5d3877c85a79831b864cb10e481b1b6f05bfafeaa05a9695930f1c52633959245ca4fc763e9b4317c8a591027a7576

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+## 0.0.2
+
+* Calling `#revise` on new document simply creates it (`:revise` callbacks are not triggered).
+* Added `#revise!` method raising Mongoid exceptions.
+* Added tests for conflicting updates.
+* Added thread-safe version check and a loop to resolve version discrepancies in case of failure.
+
+## 0.0.1
+
+Initial version

data/Gemfile.lock

@@ -1,27 +1,27 @@
 PATH
   remote: .
   specs:
-    mongoid_versioning (0.0.1)
+    mongoid_versioning (0.0.2)
       mongoid (~> 4.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (4.1.6)
-      activesupport (= 4.1.6)
+    activemodel (4.2.0)
+      activesupport (= 4.2.0)
       builder (~> 3.1)
-    activesupport (4.1.6)
-      i18n (~> 0.6, >= 0.6.9)
+    activesupport (4.2.0)
+      i18n (~> 0.7)
       json (~> 1.7, >= 1.7.7)
       minitest (~> 5.1)
-      thread_safe (~> 0.1)
+      thread_safe (~> 0.3, >= 0.3.4)
       tzinfo (~> 1.1)
     bson (2.3.0)
     builder (3.2.2)
     celluloid (0.16.0)
       timers (~> 4.0.0)
     coderay (1.1.0)
-    connection_pool (2.0.0)
+    connection_pool (2.1.0)
     coveralls (0.7.1)
       multi_json (~> 1.3)
       rest-client
@@ -42,7 +42,7 @@ GEM
       guard (~> 2.0)
       minitest (>= 3.0)
     hitimes (1.2.2)
-    i18n (0.6.11)
+    i18n (0.7.0)
     json (1.8.1)
     listen (2.7.11)
       celluloid (>= 0.15.2)
@@ -57,7 +57,7 @@ GEM
       moped (~> 2.0.0)
       origin (~> 2.1)
       tzinfo (>= 0.3.37)
-    moped (2.0.0)
+    moped (2.0.2)
       bson (~> 2.2)
       connection_pool (~> 2.0)
       optionable (~> 0.2.0)

data/README.md

@@ -2,6 +2,10 @@
 
 [![Build Status](https://travis-ci.org/tomasc/mongoid_versioning.svg)](https://travis-ci.org/tomasc/mongoid_versioning) [![Gem Version](https://badge.fury.io/rb/mongoid_versioning.svg)](http://badge.fury.io/rb/mongoid_versioning) [![Coverage Status](https://img.shields.io/coveralls/tomasc/mongoid_versioning.svg)](https://coveralls.io/r/tomasc/mongoid_versioning)
 
+Versioning of Mongoid documents. Past versions are stored in separate collection.
+
+This gem is intended for versioning of whole documents. However, it might be possible to extend its support to embedded documents as well. Pull requests are welcome.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -51,7 +55,9 @@ doc._version # => 1
 doc._based_on_version # => nil
 ```
 
-The `#revise` method validates the document and runs `:revise`, `:save` and `:update` callbacks (resp. `:revise`, `:save` and `:create` for new record).
+The `#revise` method validates the document and runs `:revise`, `:save` and `:update` callbacks. (Please note that running `#revise` on new document will resort to standard `#save`.)
+
+A `#revise!` method, raising `Mongoid::Errors::Validations` and `Mongoid::Errors::Callbacks` exceptions, is also available.
 
 ### Retrieving versions
 

data/lib/mongoid_versioning/version.rb

@@ -1,3 +1,3 @@
 module MongoidVersioning
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/mongoid_versioning/versioned.rb

@@ -9,10 +9,11 @@ module MongoidVersioning
         field :_version, type: Integer
         field :_based_on_version, type: Integer
 
-        collection.database[versions_collection_name].indexes.create(
+        versions_collection.indexes.create(
           { _orig_id: 1, _version: 1 }, { unique: true }
         )
 
+        before_create :set_initial_version
         after_initialize :revert_id
       end
     end
@@ -23,16 +24,36 @@ module MongoidVersioning
       def versions_collection_name
         [collection.name, 'versions'].join('.')
       end
+
+      def versions_collection
+        collection.database[versions_collection_name]
+      end
     end
 
     # =====================================================================
 
     def revise options={}
-      if new_record?
-        !_create_revised(options).new_record?
-      else
-        _update_revised(options)
+      return save if new_record?
+
+      return false if performing_validations?(options) && invalid?(:update)
+      process_flagged_destroys
+      result = run_callbacks(:revise) do
+        run_callbacks(:save) do
+          run_callbacks(:update) do
+            _revise
+            true
+          end
+        end
       end
+      post_process_persist(result, options) and self
+    end
+
+    def revise! options={}
+      unless revise(options)
+        fail_due_to_validation! unless errors.empty?
+        fail_due_to_callback!(:revise!)
+      end
+      true
     end
 
     # ---------------------------------------------------------------------
@@ -59,65 +80,35 @@ module MongoidVersioning
 
     private # =============================================================
 
+    def set_initial_version
+      self._version ||= 1
+    end
+
     def revert_id
       return unless self['_orig_id']
       self._id = self['_orig_id']
     end
 
-    # these mirror the #create and #save methods from Mongoid
-    def _create_revised options={}
-      return self if performing_validations?(options) && invalid?(:create)
-      result = run_callbacks(:revise) do
-        run_callbacks(:save) do
-          run_callbacks(:create) do
-            _revise
-            true
-          end
-        end
-      end
-      post_process_persist(result, options) and self
-    end
-
-    def _update_revised options={}
-      return false if performing_validations?(options) && invalid?(:update)
-      process_flagged_destroys
-      result = run_callbacks(:revise) do
-        run_callbacks(:save) do
-          run_callbacks(:update) do
-            _revise
-            true
-          end
-        end
-      end
-      post_process_persist(result, options) and self
-    end
-
     def _revise
-      previous_version = nil
-
-      # 1. get the latest version as stored in the db
-      if previous_doc = self.class.collection.find({ _id: id }).first
-
-        previous_version = previous_doc["_version"] || 1
+      loop do
+        previous_doc = latest_version
 
         previous_doc['_orig_id'] = previous_doc['_id']
         previous_doc['_id'] = BSON::ObjectId.new
-        previous_doc['_version'] = previous_version
 
-        # 2. upsert the latest version into the .versions collection
-        self.class.collection.database[self.class.versions_collection_name].where(_orig_id: id, _version: previous_version).upsert(previous_doc)
-      end
+        current_version = previous_doc._version
+
+        res1 = self.class.versions_collection.where(_orig_id: previous_doc['_orig_id'], _version: previous_doc._version).upsert(previous_doc.as_document)
 
-      # 3. insert new version
-      self._based_on_version = _version || previous_version
-      self._version = previous_version.to_i+1
+        self._based_on_version = _version || current_version
+        self._version = current_version+1
 
-      self.class.collection.where(_id: id).upsert(self.as_document)
+        res2 = self.class.collection.where(_id: id, _version: current_version).update(self.as_document)
 
-      # TODO
-      # if (result.nModified != 1) {
-      #    print("Someone got there first, replay flow to try again");
-      # }
+        # replay flow if someone else updated the document before us
+        break unless res2['n'] != 1
+      end
     end
+
   end
-end
+end

data/test/mongoid_versioning/versioned_test.rb

@@ -32,12 +32,19 @@ module MongoidVersioning
     # =====================================================================
 
     describe 'fields' do
-      it 'has :_version' do
-        subject.must_respond_to :_version
+      describe '_version' do
+        it { subject.must_respond_to :_version }
+        it { subject._version.must_be_nil }
+
+        describe 'on create' do
+          before { subject.save }
+          it { subject._version.must_equal 1 }
+        end
       end
 
-      it 'has :_based_on_version' do
-        subject.must_respond_to :_based_on_version
+      describe '_based_on_version' do
+        it { subject.must_respond_to :_based_on_version }
+        it { subject._based_on_version.must_be_nil }
       end
     end
 
@@ -56,141 +63,193 @@ module MongoidVersioning
     describe 'instance methods' do
       describe '#revise' do
 
-        describe 'when invalid' do
-          let(:invalid_document) { TestDocument.new }
+        describe 'on new document' do
+          let(:new_document) { TestDocument.new(name: 'New') }
+
+          before do
+            new_document.name = 'Foo'
+            new_document.revise
 
-          it 'returns false' do
-            invalid_document.revise.must_equal false
+            @versions = TestDocument.versions_collection.where(_orig_id: new_document.id).sort(_version: -1)
+            @current = TestDocument.collection.where(_id: new_document.id).first
           end
-        end
 
-        describe 'new record' do
-          before do
-            subject.callbacks = []
-            subject.revise
+          it 'sets _version' do
+            new_document._version.must_equal 1
+          end
+          it 'sets _based_on_version' do
+            new_document._based_on_version.must_be_nil
+          end
 
-            @current_docs = TestDocument.collection.where({ _id: subject.id })
-            @version_docs = TestDocument.collection.database[TestDocument.versions_collection_name].where(_orig_id: subject.id)
+          describe 'when invalid' do
+            before { new_document.name = nil }
+
+            it 'returns false' do
+              new_document.revise.must_equal false
+            end
           end
 
           describe 'callbacks' do
-            it 'runs :revise, :save, :create' do
-              subject.callbacks.must_equal %w(before_revise before_save before_create after_create after_save after_revise)
+            it 'does not run :revise' do
+              new_document.callbacks.wont_include 'before_revise'
+              new_document.callbacks.wont_include 'after_revise'
             end
           end
 
-          describe 'default collection' do
-            it 'stores the document' do
-              @current_docs.first.must_be :present?
-            end
-            it '_version to 1' do
-              @current_docs.first['_version'].must_equal 1
-            end
-            it '_based_on_version at nil' do
-              @current_docs.first['_based_on_version'].must_be_nil
-            end
-            it 'maintains only one current doc' do
-              @current_docs.count.must_equal 1
+          describe 'versions' do
+            it 'does not store anything' do
+              @versions.count.must_equal 0
             end
           end
 
-          describe 'versions' do
-            it 'does not create any versions' do
-              @version_docs.count.must_equal 0
+          describe 'current' do
+            it 'stores updated doc into current collection' do
+              @current["_version"].must_equal 1
+              @current["_based_on_version"].must_be_nil
+              @current["name"].must_equal 'Foo'
             end
           end
         end
 
         # ---------------------------------------------------------------------
 
-        describe 'existing record' do
-          let(:existing_document) { TestDocument.create(name: 'Init') }
+        describe 'on existing document' do
+          let(:existing_document) { TestDocument.create(name: 'Existing') }
 
           before do
             existing_document.callbacks = []
             existing_document.name = 'Foo'
             existing_document.revise
 
-            @current_docs = TestDocument.collection.where(_id: existing_document.id)
-            @version_docs = TestDocument.collection.database[TestDocument.versions_collection_name].where(_orig_id: existing_document.id)
+            @versions = TestDocument.versions_collection.where(_orig_id: existing_document.id).sort(_version: -1)
+            @current = TestDocument.collection.where(_id: existing_document.id).first
+          end
+
+          it 'sets _version' do
+            existing_document._version.must_equal 2
+          end
+          it 'sets _based_on_version' do
+            existing_document._based_on_version.must_equal 1
+          end
+
+          describe 'when invalid' do
+            before { existing_document.name = nil }
+
+            it 'returns false' do
+              existing_document.revise.must_equal false
+            end
           end
 
           describe 'callbacks' do
-            it 'runs :revise, :save, :update' do
+            it 'runs :revise, :save, :create' do
               existing_document.callbacks.must_equal %w(before_revise before_save before_update after_update after_save after_revise)
             end
           end
 
-          describe 'default collection' do
-            it 'updates the document' do
-              @current_docs.first['name'].must_equal 'Foo'
-            end
-            it '_version to 2' do
-              @current_docs.first['_version'].must_equal 2
-            end
-            it 'sets the _based_on_version to 1' do
-              @current_docs.first['_based_on_version'].must_equal 1
+          describe 'versions' do
+            it 'stores previous doc' do
+              @versions.count.must_equal 1
+              @versions.first["_version"].must_equal 1
+              @versions.first["_based_on_version"].must_be_nil
+              @versions.first["name"].must_equal 'Existing'
             end
-            it 'maintains only one current doc' do
-              @current_docs.count.must_equal 1
+          end
+
+          describe 'current' do
+            it 'stores updated doc into current collection' do
+              @current["_version"].must_equal 2
+              @current["_based_on_version"].must_equal 1
+              @current["name"].must_equal 'Foo'
             end
           end
 
-          describe 'previous versions' do
-            it 'copies the latest version to .versions' do
-              @version_docs.first.must_be :present?
+          describe 'subsequent revise' do
+            before do
+              existing_document.callbacks = []
+              existing_document.name = 'Bar'
+              existing_document.revise
+
+              @versions = TestDocument.versions_collection.where(_orig_id: existing_document.id).sort(_version: -1)
+              @current = TestDocument.collection.where(_id: existing_document.id).first
             end
 
-            it '_version to 1' do
-              @version_docs.first['_version'].must_equal 1
+            it 'sets _version' do
+              existing_document._version.must_equal 3
             end
-            it '_version to 1' do
-              @version_docs.first['_based_on_version'].must_equal nil
+            it 'sets _based_on_version' do
+              existing_document._based_on_version.must_equal 2
             end
-            it 'is not updated' do
-              @version_docs.first['name'].wont_equal 'Foo'
+
+            describe 'versions' do
+              it 'stores previous doc' do
+                @versions.count.must_equal 2
+                @versions.map{ |v| v['_version'] }.must_equal [2, 1]
+                @versions.map{ |v| v['_based_on_version'] }.must_equal [1, nil]
+                @versions.first["_version"].must_equal 2
+                @versions.first["_based_on_version"].must_equal 1
+                @versions.first["name"].must_equal 'Foo'
+              end
             end
-            it 'creates only one version' do
-              @version_docs.count.must_equal 1
+
+            describe 'current' do
+              it 'stores updated doc into current collection' do
+                @current["_version"].must_equal 3
+                @current["_based_on_version"].must_equal 2
+                @current["name"].must_equal 'Bar'
+              end
             end
           end
         end
 
         # ---------------------------------------------------------------------
 
-        describe 'subsequent revision' do
+        describe 'on concurrent updates' do
           before do
-            subject.name = 'v1'
-            subject.revise
-            subject.name = 'v2'
-            subject.revise
-            subject.name = 'v3'
-            subject.revise
+            @doc = TestDocument.create(name: 'Doc')
 
-            @current_docs = TestDocument.collection.where(_id: subject.id)
-            @version_docs = TestDocument.collection.database[TestDocument.versions_collection_name].where(_orig_id: subject.id)
+            @user1 = TestDocument.where(_id: @doc.id).first
+            @user2 = TestDocument.where(_id: @doc.id).first
+
+            @user2.name = 'Doc2'
+            @user1.name = 'Doc1'
+
+            @user2.revise
+            @user1.revise
+
+            @result = TestDocument.where(_id: @doc.id).first
+            @versions = TestDocument.versions_collection.where(_orig_id: @doc.id).sort(_version: -1)
+            @current = TestDocument.collection.where(_id: @doc.id).first
           end
 
-          describe 'default collection' do
-            it 'updates the current document in the db' do
-              @current_docs.first['name'].must_equal 'v3'
-              @current_docs.first['_version'].must_equal 3
-              @current_docs.first['_based_on_version'].must_equal 2
-              @current_docs.count.must_equal 1
-            end
+          it 'will correctly set values' do
+            @result._version.must_equal 3
+            @result._based_on_version.must_equal 1
+            @result.name.must_equal 'Doc1'
           end
 
           describe 'versions' do
-            it 'has 2 previous versions' do
-              @version_docs.count.must_equal 2
-              @version_docs.collect{ |i| i['_version'] }.must_equal [1,2]
-              @version_docs.collect{ |i| i['_based_on_version'] }.must_equal [nil,1]
+            it 'stores previous doc' do
+              @versions.count.must_equal 2
+              @versions.map{ |v| v['_version'] }.must_equal [2, 1]
+              @versions.map{ |v| v['_based_on_version'] }.must_equal [1, nil]
+              @versions.map{ |v| v['name'] }.must_equal ['Doc2', 'Doc']
+              @versions.first["_version"].must_equal 2
+              @versions.first["_based_on_version"].must_equal 1
+              @versions.first["name"].must_equal 'Doc2'
+            end
+          end
+
+          describe 'current' do
+            it 'stores updated doc into current collection' do
+              @current["_version"].must_equal 3
+              @current["_based_on_version"].must_equal 1
+              @current["name"].must_equal 'Doc1'
             end
           end
         end
 
         # ---------------------------------------------------------------------
-        
+
         describe 'revise on previous version' do
           before do
             subject.name = 'v1'
@@ -216,6 +275,24 @@ module MongoidVersioning
         end
       end
 
+      # =====================================================================
+      
+      describe '#revise!' do
+        let(:doc) { TestDocument.create(name: 'revise!') }
+
+        it 'raises error when invalid' do
+          doc.name = nil
+          proc { doc.revise! }.must_raise Mongoid::Errors::Validations
+        end
+
+        it 'raises error when the :revise callbacks returns false' do
+          skip 'not sure how to test this'
+          TestDocument.stub(:before_revise, false) do
+            proc { doc.revise! }.must_raise Mongoid::Errors::Callback
+          end
+        end
+      end
+
       # =====================================================================
 
       describe 'versions' do
@@ -229,70 +306,66 @@ module MongoidVersioning
           subject.name = 'Foo'
         end
 
-        it 'returns an Array' do
-          subject.versions.must_be_kind_of Array
-        end
-
         # ---------------------------------------------------------------------
 
         describe '#previous_versions' do
           it 'returns everything but the latest' do
             subject.previous_versions.map(&:_version).must_equal [2,1]
           end
-          it 'correctly reverts document _ids' do
+          it 'reverts document _ids' do
             subject.previous_versions.map(&:id).uniq.must_equal [subject.id]
           end
         end
 
-        # ---------------------------------------------------------------------
-
         describe '#latest_version' do
           it 'includes the latest version as in the database' do
             subject.latest_version.name.wont_equal 'Foo'
           end
         end
 
-        # ---------------------------------------------------------------------
-
         describe '#versions' do
+          it 'returns an Array' do
+            subject.versions.must_be_kind_of Array
+          end
           it 'returns all versions including the latest one' do
             subject.versions.map(&:_version).must_equal [3,2,1]
           end
         end
+      end
 
 
-        # ---------------------------------------------------------------------
+      # ---------------------------------------------------------------------
 
-        describe '#version' do
-          before do
-            subject.name = 'v1'
-            subject.revise
-            subject.name = 'v2'
-            subject.revise
-            subject.name = 'v3'
-            subject.revise
-            subject.name = 'Foo'
-          end
+      describe '#version' do
+        before do
+          subject.name = 'v1'
+          subject.revise
+          subject.name = 'v2'
+          subject.revise
+          subject.name = 'v3'
+          subject.revise
+          subject.name = 'Foo'
+        end
 
-          describe 'when latest version' do
-            it 'returns the version from db' do
-              subject.version(3)._version.must_equal 3
-            end
+        describe 'when latest version' do
+          it 'returns the version from db' do
+            subject.version(3)._version.must_equal 3
           end
+        end
 
-          describe 'when previous version' do
-            it 'returns the version from db' do
-              subject.version(1)._version.must_equal 1
-            end
+        describe 'when previous version' do
+          it 'returns the version from db' do
+            subject.version(1)._version.must_equal 1
           end
+        end
 
-          describe 'when version does not exist' do
-            it 'returns nil' do
-              subject.version(10).must_be_nil
-            end
+        describe 'when version does not exist' do
+          it 'returns nil' do
+            subject.version(10).must_be_nil
           end
         end
       end
+
     end
 
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_versioning
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Tomas Celizna
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-30 00:00:00.000000000 Z
+date: 2015-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
@@ -131,6 +131,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - Guardfile