mongo_mapper_acts_as_versioned 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8d1b118116f01ad10fb94a44217c25d5cb3484c2
-  data.tar.gz: 6d98d4787e0deb18a00ac773808721ee13f59c1a
+  metadata.gz: c112d7390018bff2595ef3b03c4d8bda1b99232d
+  data.tar.gz: cce2fb0907beb7d3d30dae48bdcdba47a877d653
 SHA512:
-  metadata.gz: 1915620ad8a19ba9f0aa106bcb4ce8cd01353625bb42f01f202770ba2c8ec8838549aea5d8be0677e405e4c0c54beeeae7ce431bc3cbc4ed96bbbcac846b3984
-  data.tar.gz: 255512d843e5dab2157f25d4509ca4dd3ed9c827cf0360992a3b6960740f1c89ea3751ec8e78235ec2ac038df928ca158157db74f329afb56062ba69e7edeedc
+  metadata.gz: 9305d32fe1697cc8e0bd26bd4cfa3f1cb5e5f44534c8a270ec2f07e65031eb6f95478f294a08c768c12d2c06236f6c4048170bae81023a6a06d6defa2a0299cb
+  data.tar.gz: d661de01a41d287253ffa18f6f6d8a5013b6a31b84c8488537f35fffeb03595be423cbc11668e387cf1247b3404a03f59f8cb0973715bc27a2acc844584e50a5

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010 Gigamo <gigamo@gmail.com>
+Copyright (c) 2010-2017 Kenneth De Winter <kdwinter@protonmail.com>
 Copyright (c) 2005 Rick Olson
 
 Permission is hereby granted, free of charge, to any person obtaining

data/README.md

@@ -8,32 +8,34 @@ Stores changed attributes in a single collection using a general Hash key.
 
 ### Basic Example
 
-    class Page
-      include MongoMapper::Document
+```ruby
+class Page
+  include MongoMapper::Document
 
-      plugin MongoMapper::Acts::Versioned
+  plugin MongoMapper::Acts::Versioned
 
-      key :title, String
-    end
+  key :title, String
+end
 
-    page = Page.create(:title => 'title')
-    page.version              # => 1
-    page.versions.size        # => 1
+page = Page.create(:title => 'title')
+page.version              # => 1
+page.versions.size        # => 1
 
-    page.title = 'new title'
-    page.save
+page.title = 'new title'
+page.save
 
-    page = page.reload
-    page.version              # => 2
-    page.versions.size        # => 2
-    page.title                # => 'new title'
+page = page.reload
+page.version              # => 2
+page.versions.size        # => 2
+page.title                # => 'new title'
 
-    page.revert_to!(1)
+page.revert_to!(1)
 
-    page = page.reload
-    page.version              # => 1
-    page.versions.size        # => 2
-    page.title                # => 'title'
+page = page.reload
+page.version              # => 1
+page.versions.size        # => 2
+page.title                # => 'title'
+```
 
 ### Keys that do not trigger new versions
 
@@ -53,11 +55,6 @@ Default ignored keys are:
 
 Simply add `do_not_version 'new_skipped_key', 'another_skipped_key'` somewhere in your model.
 
-## Tested with
-
-* MongoMapper 0.11.1, 0.13.1, 0.14.0
-* Ruby 1.9.2 up to 2.4.0
-
 ## Older MongoMapper versions
 
 * For MongoMapper <= 0.8.6, see the master branch of this repository.
@@ -66,10 +63,53 @@ Simply add `do_not_version 'new_skipped_key', 'another_skipped_key'` somewhere i
 
 * See the next branch of this repository.
 
+### Upgrading from older embedded document versions
+
+Since 0.3.0, versions have moved into standalone documents rather than embedded documents,
+mostly for performance reasons.  
+In hindsight, it didn't really make much sense to load all of a document's versions in every query
+(unless a query specified `.fields` without `:versions`), on top of the actual document itself.  
+Versions are now only loaded when specifically requested. Existing versions in your system
+will however not be automatically updated.
+
+Here's an example script that can do it for you.  
+Assuming models called Page and Template, you can convert its old versions through a script
+like such:
+
+```ruby
+models = [Page, Template]
+
+models.each do |model|
+  model.const_set(:Version, Class.new {
+    include MongoMapper::EmbeddedDocument
+    key :modified
+    key :version
+  })
+
+  model.many :versions, class_name: "#{model.name}::Version"
+
+  model.all.each do |document|
+    document.versions.each do |old_version|
+      MongoMapper::Acts::Versioned::DocumentVersion.create(
+        entity_type: model.name,
+        entity_id:   document.id,
+        modified:    old_version.modified,
+        version:     old_version.version
+      ) || warn("Didnt create new version for #{old_version.inspect}")
+    end
+  end
+end
+```
+
 ## Bundler note
 
 Make sure to specify `:require => 'acts_as_versioned'` in your Gemfile.
 
+## Tested with
+
+* MongoMapper 0.11.1, 0.13.1, 0.14.0
+* Ruby 1.9.2 up to 2.4.0
+
 ## Copyright
 
 See LICENSE.

data/lib/acts_as_versioned.rb

@@ -2,6 +2,7 @@ require "active_support"
 require "active_support/concern"
 if ActiveSupport.version >= Gem::Version.new("5.0.0")
   begin
+    # MongoMapper doesn't work without this since it was extracted from Rails in 5.0+
     require "activemodel-serializers-xml"
   rescue LoadError
     warn "Couldn't load AM serializers. Things might break."
@@ -13,9 +14,15 @@ require "active_model"
 module MongoMapper
   module Acts
     module Versioned
+      VERSION = "0.3.3"
+
+      # This model stores all version information.
       class DocumentVersion
         include MongoMapper::Document
-
+        # Manually set the collection name to
+        #   "document_versions"
+        # instead of the default
+        #   "mongo_mapper.acts.versioned.document_versions"
         set_collection_name "document_versions"
 
         key :modified,    Hash
@@ -27,39 +34,49 @@ module MongoMapper
         belongs_to :entity, polymorphic: true
       end
 
+      # Required in order to act as a MM plugin.
       extend ActiveSupport::Concern
 
-      VERSION   = "0.3.2"
+      # Callbacks that should be silenced when saving without revision.
       CALLBACKS = [:save_version, :clear_old_versions]
 
+      # Set defaults when plugin is included into model.
       included do
         class_attribute :non_versioned_keys, :max_version_limit
 
-        self.max_version_limit    = 0
-        self.non_versioned_keys   = %w(
+        self.max_version_limit  = 0
+        self.non_versioned_keys = %w(
           _id _type created_at updated_at
           creator_id updater_id version
         )
 
+        # The document's current version.
         key :version, Integer
+
         before_save :save_version
         before_save :clear_old_versions
       end
 
+      # All DocumentVersion documents belonging to this document.
+      # Returns +Plucky::Query+.
       def versions
         MongoMapper::Acts::Versioned::DocumentVersion.where(
           entity_type: self.class.name, entity_id: self.id
         )
       end
 
+      # Grab a specific DocumentVersion document by +given_version+ number.
       def document_version(given_version)
         versions.where(version: given_version).first
       end
 
+      # Grab the DocumentVersion document corresponding with this document's
+      # current +version+.
       def current_document_version
         document_version(version)
       end
 
+      # Save a new version for this document.
       def save_version
         if new_record? || save_version?
           self.version = next_version
@@ -75,43 +92,58 @@ module MongoMapper
         end
       end
 
-      def clear_old_versions
-        return if self.class.max_version_limit == 0
-        excess_bagage = version.to_i - self.class.max_version_limit
-
-        if excess_bagage > 0
-          versions.select { |v| v.version.to_i <= excess_bagage }.map(&:delete)
-        end
-      end
-
-      def revert_to(rev)
-        if rev.is_a?(MongoMapper::Acts::Versioned::DocumentVersion)
-          return false if rev.new_record?
+      # Change the current document's attributes to those of a given +revision+.
+      def revert_to(revision)
+        if revision.is_a?(MongoMapper::Acts::Versioned::DocumentVersion)
+          return false if revision.new_record?
         else
-          return false unless rev = document_version(rev)
+          return false unless revision = document_version(revision)
         end
 
-        clone_attributes(rev, self)
-        self.version = rev.version
+        clone_attributes(revision, self)
+        self.version = revision.version
 
         true
       end
 
-      def revert_to!(rev)
-        revert_to(rev) and save_without_revision or false
+      # Change the current document's attributes to those of a given +revision+,
+      # and save the document.
+      def revert_to!(revision)
+        revert_to(revision) and save_without_revision or false
       end
 
+      # Save this document without creating a new version.
       def save_without_revision
-        save_without_revision!
-        true
-      rescue
-        false
+        without_revision { save }
       end
 
+      # Save this document without creating a new version. Raises on save
+      # failure.
       def save_without_revision!
         without_revision { save! }
       end
 
+      # Forwards to +self.class.without_revision+.
+      def without_revision(&block)
+        self.class.without_revision(&block)
+      end
+
+    protected
+
+      # Clear old versions based on +self.class.max_version_limit+.
+      # If this limit is 0, no versions are removed.
+      def clear_old_versions
+        return if self.class.max_version_limit == 0
+        excess_bagage = version.to_i - self.class.max_version_limit
+
+        if excess_bagage > 0
+          versions.select { |v| v.version.to_i <= excess_bagage }.map(&:delete)
+        end
+      end
+
+      # Copy the attributes specified in +self.class.versioned_keys+ from either
+      # a +DocumentVersion+ into this document, or from this document into a
+      # +DocumentVersion+.
       def clone_attributes(orig_model, new_model)
         if orig_model.is_a?(MongoMapper::Acts::Versioned::DocumentVersion)
           orig_model = orig_model.modified
@@ -124,37 +156,41 @@ module MongoMapper
         end
       end
 
+      # Should a new version be saved?
       def save_version?
         (self.class.versioned_keys & changed).any?
       end
 
-      def without_revision(&block)
-        self.class.without_revision(&block)
-      end
-
+      # Do nothing.
       def empty_callback
       end
 
-    protected
-
+      # Next version number, based on current version.
       def next_version
         new_record? || versions.count == 0 ?
           1 : versions.fields(:version).map(&:version).max.next
       end
 
       module ClassMethods
+        # Keys/attributes that should be saved in versions.
+        #
+        # Returns all available keys minus those found in the
+        # +non_versioned_keys+ list.
         def versioned_keys
-          keys.keys - non_versioned_keys
+          keys.keys - non_versioned_keys.map(&:to_s)
         end
 
+        # Add given +args+ to the +non_versioned_keys+ list.
         def do_not_version(*args)
           self.non_versioned_keys |= args
         end
 
+        # Set +max_version_limit+ as +amount+.
         def max_versions(amount)
           self.max_version_limit = amount
         end
 
+        # Versioning-related are silenced within given +&block+.
         def without_revision
           class_eval do
             CALLBACKS.each do |attr_name|

data/spec/acts_as_versioned_spec.rb

@@ -7,7 +7,7 @@ describe MongoMapper::Acts::Versioned do
         include MongoMapper::Document
 
         plugin MongoMapper::Acts::Versioned
-        do_not_version 'depth'
+        do_not_version :depth
 
         key :title, String
         key :depth, Integer
@@ -21,10 +21,10 @@ describe MongoMapper::Acts::Versioned do
 
     it 'should save a versioned copy' do
       l = Landmark.create(:title => 'title')
-      l.new_record?.should be_falsy
-      l.versions.size.should == 1
-      l.version.should == 1
-      l.versions.first.should be_a(MongoMapper::Acts::Versioned::DocumentVersion)
+      expect(l.new_record?).to be_falsy
+      expect(l.versions.size).to eq 1
+      expect(l.version).to eq 1
+      expect(l.versions.first).to be_a(MongoMapper::Acts::Versioned::DocumentVersion)
     end
 
     it 'should clear old versions when a limit is set' do
@@ -37,20 +37,20 @@ describe MongoMapper::Acts::Versioned do
       end
 
       l = l.reload
-      l.versions.size.should == 3
-      l.versions.first.version.should == 8
-      l.versions.last.version.should == 10
+      expect(l.versions.size).to eq 3
+      expect(l.versions.first.version).to eq 8
+      expect(l.versions.last.version).to eq 10
 
       Landmark.max_version_limit = 0
     end
 
     it 'should save without revision' do
       l = Landmark.create(:title => 'title')
-      l.version.should == 1
+      expect(l.version).to eq 1
 
       l.update_attributes(:title => 'changed')
       l = l.reload
-      l.version.should == 2
+      expect(l.version).to eq 2
 
       old_versions = l.versions.size
 
@@ -60,7 +60,7 @@ describe MongoMapper::Acts::Versioned do
         l.update_attributes :title => 'changed again'
       end
 
-      l.reload.versions.size.should == old_versions
+      expect(l.reload.versions.size).to eq old_versions
     end
 
     it 'should rollback with version number' do
@@ -71,15 +71,15 @@ describe MongoMapper::Acts::Versioned do
       end
 
       l = l.reload
-      l.version.should == 10
-      l.versions.size.should == 10
-      l.title.should == 'title10'
+      expect(l.version).to eq 10
+      expect(l.versions.size).to eq 10
+      expect(l.title).to eq 'title10'
 
-      l.revert_to!(7).should be_truthy
+      expect(l.revert_to!(7)).to be_truthy
       l = l.reload
-      l.version.should == 7
-      l.versions.size.should == 10
-      l.title.should == 'title7'
+      expect(l.version).to eq 7
+      expect(l.versions.size).to eq 10
+      expect(l.title).to eq 'title7'
     end
 
     it 'should rollback with version class' do
@@ -90,15 +90,15 @@ describe MongoMapper::Acts::Versioned do
       end
 
       l = l.reload
-      l.version.should == 10
-      l.versions.size.should == 10
-      l.title.should == 'title10'
+      expect(l.version).to eq 10
+      expect(l.versions.size).to eq 10
+      expect(l.title).to eq 'title10'
 
-      l.revert_to!(l.document_version(7)).should be_truthy
+      expect(l.revert_to!(l.document_version(7))).to be_truthy
       l = l.reload
-      l.version.should == 7
-      l.versions.size.should == 10
-      l.title.should == 'title7'
+      expect(l.version).to eq 7
+      expect(l.versions.size).to eq 10
+      expect(l.title).to eq 'title7'
     end
 
     it 'should have versioned records belong to its parent' do
@@ -109,68 +109,68 @@ describe MongoMapper::Acts::Versioned do
       end
 
       l_version = l.reload.versions.last
-      l_version.entity.should == l.reload
+      expect(l_version.entity).to eq l.reload
     end
 
     it 'should not create new versions for skipped keys' do
       l = Landmark.create(:title => 'title')
       l.update_attributes(:depth => 1)
       l = l.reload
-      l.version.should == 1
-      l.versions.size.should == 1
+      expect(l.version).to eq 1
+      expect(l.versions.size).to eq 1
     end
 
     it 'should create a new version even if a skipped key is added' do
       l = Landmark.create(:title => 'title')
       l.update_attributes(:title => 'new title', :depth => 1)
       l = l.reload
-      l.version.should == 2
-      l.versions.size.should == 2
+      expect(l.version).to eq 2
+      expect(l.versions.size).to eq 2
     end
 
     it 'should remember skipped keys through versions' do
       l = Landmark.create(:title => 'title')
       l.update_attributes(:title => 'new title')
       l = l.reload
-      l.version.should == 2
-      l.versions.size.should == 2
+      expect(l.version).to eq 2
+      expect(l.versions.size).to eq 2
 
       l.update_attributes(:depth => 1)
       l = l.reload
-      l.version.should == 2
-      l.versions.size.should == 2
-      l.depth.should == 1
-      l.title.should == 'new title'
+      expect(l.version).to eq 2
+      expect(l.versions.size).to eq 2
+      expect(l.depth).to eq 1
+      expect(l.title).to eq 'new title'
 
       l.revert_to!(1)
       l = l.reload
-      l.version.should == 1
-      l.versions.size.should == 2
-      l.depth.should == 1
-      l.title.should == 'title'
+      expect(l.version).to eq 1
+      expect(l.versions.size).to eq 2
+      expect(l.depth).to eq 1
+      expect(l.title).to eq 'title'
     end
 
     it 'should store changes in a hash' do
       l = Landmark.create(:title => 'title')
-      l.document_version(1).modified.should == {'title' => 'title'}
+      expect(l.document_version(1).modified).to eq({'title' => 'title'})
 
       l.update_attributes(:title => 'changed title', :depth => 1)
-      l.reload.document_version(2).modified.should == {'title' => 'changed title'}
+      expect(l.reload.document_version(2).modified).to eq({'title' => 'changed title'})
     end
 
     it 'should save when a version was created' do
       l = Landmark.create(:title => 'title')
-      l.document_version(1).created_at.should be_instance_of(Time)
+      expect(l.document_version(1).created_at).to be_instance_of(Time)
     end
 
     it 'should save a versioned class with sci' do
       s = Sublandmark.create!(:title => 'first title')
-      s.new_record?.should be_falsy
-      s.version.should == 1
+      expect(s.new_record?).to be_falsy
+      expect(s.version).to eq 1
 
-      s.versions.size.should == 1
-      s.versions.first.should be_a(MongoMapper::Acts::Versioned::DocumentVersion)
-      s.versions.first.entity_type.should == "Sublandmark"
+      expect(s.versions.size).to eq 1
+      expect(s.versions.first).to be_a(MongoMapper::Acts::Versioned::DocumentVersion)
+      expect(s.versions.first.entity_type).to eq "Sublandmark"
     end
 
     it 'should rollback with sci' do
@@ -181,14 +181,14 @@ describe MongoMapper::Acts::Versioned do
       end
 
       l = l.reload
-      l.version.should == 5
-      l.versions.size.should == 5
-      l.title.should == 'other title5'
-      l.revert_to!(3).should be_truthy
+      expect(l.version).to eq 5
+      expect(l.versions.size).to eq 5
+      expect(l.title).to eq 'other title5'
+      expect(l.revert_to!(3)).to be_truthy
       l = l.reload
-      l.version.should == 3
-      l.versions.size.should == 5
-      l.title.should == 'other title3'
+      expect(l.version).to eq 3
+      expect(l.versions.size).to eq 5
+      expect(l.title).to eq 'other title3'
 
       s = Sublandmark.create(:title => 'title')
       (2..5).each do |i|
@@ -197,15 +197,15 @@ describe MongoMapper::Acts::Versioned do
       end
 
       s = s.reload
-      s.versions.should_not == l.versions
-      s.version.should == 5
-      s.versions.size.should == 5
-      s.title.should == 'title5'
-      s.revert_to!(3).should be_truthy
+      expect(s.versions).not_to eq l.versions
+      expect(s.version).to eq 5
+      expect(s.versions.size).to eq 5
+      expect(s.title).to eq 'title5'
+      expect(s.revert_to!(3)).to be_truthy
       s = s.reload
-      s.version.should == 3
-      s.versions.size.should == 5
-      s.title.should == 'title3'
+      expect(s.version).to eq 3
+      expect(s.versions.size).to eq 5
+      expect(s.title).to eq 'title3'
     end
   end
 
@@ -229,10 +229,10 @@ describe MongoMapper::Acts::Versioned do
     it 'should version only the subclass' do
       page = Page.create(:title => 'page title')
       post = Post.create(:title => 'post title')
-      page.version.should == 1
-      page.versions.size.should == 1
-      post.version.should == 1
-      post.versions.size.should == 1
+      expect(page.version).to eq 1
+      expect(page.versions.size).to eq 1
+      expect(post.version).to eq 1
+      expect(post.versions.size).to eq 1
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,18 +1,19 @@
 require 'mongo_mapper'
-require 'mongo_mapper/version'
-puts MongoMapper::Version
 require 'rspec'
 require File.expand_path('../../lib/acts_as_versioned', __FILE__)
 
 MongoMapper.connection = Mongo::Connection.new('127.0.0.1', 27017)
 MongoMapper.database = 'test'
-MongoMapper.database.collections.each {|c| c.drop_indexes }
+MongoMapper.database.collections.each(&:drop_indexes)
 
-RSpec.configure do |config|
-  config.after :each do
-    MongoMapper.database.collections.each do |collection|
-      collection.remove unless collection.name =~ /(.*\.)?system\..*/
-      collection.drop_indexes
-    end
+def remove_collections
+  MongoMapper.database.collections.each do |collection|
+    collection.remove unless collection.name =~ /(.*\.)?system\..*/
+    collection.drop_indexes
   end
 end
+remove_collections
+
+RSpec.configure do |config|
+  config.after(:each) { remove_collections }
+end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: mongo_mapper_acts_as_versioned
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
-- Gigamo
+- Kenneth De Winter
 autorequire: 
 bindir: bin
 cert_chain: []