mongo_mapper_acts_as_versioned 0.0.4 → 0.0.10

data/README.md

@@ -1,6 +1,6 @@
 # ActsAsVersioned for [MongoMapper](http://github.com/jnunemaker/mongomapper)
 
-Basic MongoMapper port of technoweenie's [acts_as_versioned](http://github.com/technoweenie/acts_as_versioned). Stores changed attributes in a Hash key instead of copying all keys from the original model.
+Basic MongoMapper port of technoweenie's [acts_as_versioned](http://github.com/technoweenie/acts_as_versioned). Stores changed attributes in a Hash key inside an Embedded Document instead of copying all keys from the original model.
 
 ## Usage
 

data/lib/acts_as_versioned.rb

@@ -1,108 +1,55 @@
 module MongoMapper
   module Acts
     module Versioned
-      VERSION   = '0.0.4'
-      CALLBACKS = [:set_new_version, :save_version, :save_version?]
+      VERSION   = '0.0.10'
+      CALLBACKS = [:save_version, :save_version?]
 
       def self.configure(model)
         model.class_eval do
-          cattr_accessor :versioned_class_name, :versioned_foreign_key,
-                         :versioned_collection_name, :non_versioned_keys
-
-          self.versioned_class_name      = :Version
-          self.versioned_foreign_key     = self.to_s.foreign_key
-          self.versioned_collection_name = "#{collection_name.singularize}_versions"
-          self.non_versioned_keys        = [
-            '_id', 'created_at', 'updated_at', 'creator_id',
-            'updater_id', 'version', versioned_foreign_key,
-            '_type', '_version_type'
-          ]
+          cattr_accessor :versioned_class_name, :non_versioned_keys
 
-          const_set(versioned_class_name, Class.new).class_eval do
-            include MongoMapper::Document
-
-            class << self
-              delegate :versioned_foreign_key, :to => :original_class
-            end
-
-            key :version,            Integer
-            key :changed_attributes, Hash
-
-            if type_key = keys['_type']
-              key :_version_type, type_key.type, type_key.options
-            end
-
-            def self.before(version)
-              where(
-                versioned_foreign_key => version[versioned_foreign_key],
-                :version.lt           => version.version
-              ).sort(:version.desc).first
-            end
-
-            def self.after(version)
-              where(
-                versioned_foreign_key => version[versioned_foreign_key],
-                :version.gt           => version.version
-              ).sort(:version.asc).first
-            end
+          self.versioned_class_name = :Version
+          self.non_versioned_keys   = %w(
+            _id _type created_at updated_at creator_id updater_id version
+          )
 
-            def previous
-              self.class.before(self)
-            end
+          const_set(versioned_class_name, Class.new).class_eval do
+            include MongoMapper::EmbeddedDocument
 
-            def next
-              self.class.after(self)
-            end
+            key :version,  Integer
+            key :modified, Hash
           end
 
-          versioned_class.cattr_accessor :original_class
-          versioned_class.original_class = self
-          versioned_class.set_collection_name versioned_collection_name
-          versioned_class.belongs_to self.to_s.demodulize.underscore.to_sym,
-            :class_name  => self.to_s,
-            :foreign_key => versioned_foreign_key
-
-          key :version, Integer
-
-          many :versions,
-            :class_name => "#{self}::#{versioned_class_name}",
-            :foreign_key => versioned_foreign_key,
-            :dependent => :destroy do
-            def earliest
-              query.sort(:version).first
-            end
-
-            def latest
-              query.sort(:version.desc).first
+          many :versions, :class => "#{self}::#{versioned_class_name}".constantize do
+            def [](given_version)
+              detect {|version| version.version.to_s == given_version.to_s }
             end
           end
-
-          before_save :set_new_version
-          after_save  :save_version
         end
+
+        model.key :version, Integer
+        model.before_save :save_version
       end
 
       module InstanceMethods
         def save_version
-          if @saving_version
-            @saving_version = nil
-
+          if new_record? || save_version?
+            self.version = next_version
             rev = self.class.versioned_class.new
-            clone_versioned_model(self, rev)
+            clone_attributes(self, rev)
             rev.version = version
-            rev[self.class.versioned_foreign_key] = id
-            rev.save!
+            self.versions << rev
           end
         end
 
         def revert_to(version)
           if version.is_a?(self.class.versioned_class)
-            return false unless version[self.class.versioned_foreign_key] == id and !version.new_record?
+            return false if version.new_record?
           else
-            return false unless version = versions.where(:version => version).first
+            return false unless version = versions[version]
           end
 
-          clone_versioned_model(version, self)
+          clone_attributes(version, self)
           self.version = version.version
 
           true
@@ -125,17 +72,15 @@ module MongoMapper
           end
         end
 
-        def clone_versioned_model(orig_model, new_model)
+        def clone_attributes(orig_model, new_model)
           if orig_model.is_a?(self.class.versioned_class)
-            new_model['_type'] = orig_model['_version_type']
-            orig_model = orig_model.changed_attributes
+            orig_model = orig_model.modified
           elsif new_model.is_a?(self.class.versioned_class)
-            new_model['_version_type'] = orig_model['_type']
-            new_model = new_model.changed_attributes
+            new_model = new_model.modified
           end
 
-          self.class.versioned_keys.each do |col|
-            new_model[col] = orig_model[col]
+          self.class.versioned_keys.each do |attribute|
+            new_model[attribute] = orig_model[attribute]
           end
         end
 
@@ -152,11 +97,6 @@ module MongoMapper
 
       protected
 
-        def set_new_version
-          @saving_version = new_record? || save_version?
-          self.version = next_version if @saving_version
-        end
-
         def next_version
           new_record? || versions.empty? ? 1 : versions.map(&:version).max.next
         end

data/spec/acts_as_versioned_spec.rb

@@ -1,231 +1,222 @@
 require 'spec_helper'
 
 describe MongoMapper::Acts::Versioned do
-  before :all do
-    class Landmark
-      include MongoMapper::Document
+  context 'landmarks and generally' do
+    before :all do
+      class Landmark
+        include MongoMapper::Document
 
-      plugin MongoMapper::Acts::Versioned
+        plugin MongoMapper::Acts::Versioned
 
-      self.non_versioned_keys << 'depth'
+        self.non_versioned_keys << 'depth'
 
-      key :title, String
-      key :depth, Integer
-      timestamps!
+        key :title, String
+        key :depth, Integer
+        timestamps!
+      end
+
+      class Sublandmark < Landmark
+        key :location, String
+      end
     end
 
-    class Sublandmark < Landmark
-      key :location, String
+    it 'should set the correct properties on the version class' do
+      Landmark.versioned_class.should == Landmark::Version
+      Sublandmark.versioned_class.should == Landmark::Version
     end
-  end
 
-  it 'should set the correct properties on the version class' do
-    Landmark::Version.original_class.should == Landmark
-    Landmark::Version.collection_name.should == 'landmark_versions'
-    Landmark.versioned_class.should == Landmark::Version
-    Sublandmark::Version.original_class.should == Landmark
-    Sublandmark::Version.collection_name.should == 'landmark_versions'
-    Sublandmark.versioned_class.should == Landmark::Version
-  end
+    it 'should save a versioned copy' do
+      l = Landmark.create(:title => 'title')
+      l.new_record?.should be_false
+      l.versions.size.should == 1
+      l.version.should == 1
+      l.versions.first.should be_a(Landmark.versioned_class)
+    end
 
-  it 'should save a versioned copy' do
-    l = Landmark.create(:title => 'title')
-    l.new_record?.should be_false
-    l.versions.size.should == 1
-    l.version.should == 1
-    l.versions.first.should be_a(Landmark.versioned_class)
-  end
+    it 'should save without revision' do
+      l = Landmark.create(:title => 'title')
+      l.version.should == 1
 
-  it 'should save without revision' do
-    l = Landmark.create(:title => 'title')
-    l.version.should == 1
+      l.update_attributes(:title => 'changed')
+      l = l.reload
+      l.version.should == 2
 
-    l.update_attributes(:title => 'changed')
-    l = l.reload
-    l.version.should == 2
+      old_versions = l.versions.size
 
-    old_versions = l.versions.size
+      l.save_without_revision
 
-    l.save_without_revision
+      l.without_revision do
+        l.update_attributes :title => 'changed again'
+      end
 
-    l.without_revision do
-      l.update_attributes :title => 'changed again'
+      l.reload.versions.size.should == old_versions
     end
 
-    l.reload.versions.size.should == old_versions
-  end
+    it 'should rollback with version number' do
+      l = Landmark.create(:title => 'title')
+      (2..10).each do |i|
+        l = Landmark.first
+        l.update_attributes(:title => "title#{i}")
+      end
 
-  it 'should rollback with version number' do
-    l = Landmark.create(:title => 'title')
-    (2..10).each do |i|
-      l = Landmark.first
-      l.update_attributes(:title => "title#{i}")
+      l = l.reload
+      l.version.should == 10
+      l.versions.size.should == 10
+      l.title.should == 'title10'
+
+      l.revert_to!(7).should be_true
+      l = l.reload
+      l.version.should == 7
+      l.versions.size.should == 10
+      l.title.should == 'title7'
     end
 
-    l = l.reload
-    l.version.should == 10
-    l.versions.size.should == 10
-    l.title.should == 'title10'
+    it 'should rollback with version class' do
+      l = Landmark.create(:title => 'title')
+      (2..10).each do |i|
+        l = Landmark.first
+        l.update_attributes(:title => "title#{i}")
+      end
 
-    l.revert_to!(7).should be_true
-    l = l.reload
-    l.version.should == 7
-    l.versions.size.should == 10
-    l.title.should == 'title7'
-  end
+      l = l.reload
+      l.version.should == 10
+      l.versions.size.should == 10
+      l.title.should == 'title10'
 
-  it 'should rollback with version class' do
-    l = Landmark.create(:title => 'title')
-    (2..10).each do |i|
-      l = Landmark.first
-      l.update_attributes(:title => "title#{i}")
+      l.revert_to!(l.versions[7]).should be_true
+      l = l.reload
+      l.version.should == 7
+      l.versions.size.should == 10
+      l.title.should == 'title7'
     end
 
-    l = l.reload
-    l.version.should == 10
-    l.versions.size.should == 10
-    l.title.should == 'title10'
+    it 'should have versioned records belong to its parent' do
+      l = Landmark.create(:title => 'title')
+      (2..10).each do |i|
+        l = Landmark.first
+        l.update_attributes(:title => "title#{i}")
+      end
 
-    l.revert_to!(l.versions.find_by_version(7)).should be_true
-    l = l.reload
-    l.version.should == 7
-    l.versions.size.should == 10
-    l.title.should == 'title7'
-  end
+      l_version = l.reload.versions.last
+      l_version._root_document.should == l.reload
+    end
 
-  it 'should have versioned records belong to its parent' do
-    l = Landmark.create(:title => 'title')
-    (2..10).each do |i|
-      l = Landmark.first
-      l.update_attributes(:title => "title#{i}")
+    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
     end
 
-    l_version = l.reload.versions.last
-    l_version.landmark.should == l.reload
-  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
+    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
-  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
+
+      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'
+
+      l.revert_to!(1)
+      l = l.reload
+      l.version.should == 1
+      l.versions.size.should == 2
+      l.depth.should == 1
+      l.title.should == 'title'
+    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
-  end
+    it 'should store changes in a hash' do
+      l = Landmark.create(:title => 'title')
+      l.versions[1].modified.should == {'title' => 'title'}
 
-  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
-
-    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'
-
-    l.revert_to!(1)
-    l = l.reload
-    l.version.should == 1
-    l.versions.size.should == 2
-    l.depth.should == 1
-    l.title.should == 'title'
-  end
+      l.update_attributes(:title => 'changed title', :depth => 1)
+      l.reload.versions[2].modified.should == {'title' => 'changed title'}
+    end
 
-  it 'should store changes in a hash' do
-    l = Landmark.create(:title => 'title')
-    l.versions[0].changed_attributes.should == {'title' => 'title'}
+    it 'should save a versioned class with sci' do
+      s = Sublandmark.create!(:title => 'first title')
+      s.new_record?.should be_false
+      s.version.should == 1
 
-    l.update_attributes(:title => 'changed title', :depth => 1)
-    l.reload.versions[1].changed_attributes.should == {'title' => 'changed title'}
-  end
+      s.versions.size.should == 1
+      s.versions.first.should be_a(Landmark.versioned_class)
+      s.versions.first._root_document.should == s
+    end
 
-  context 'finders' do
-    before :each do
-      @l = Landmark.create(:title => 'title')
+    it 'should rollback with sci' do
+      l = Landmark.create(:title => 'other title')
       (2..5).each do |i|
-        Landmark.first.update_attributes(:title => "title#{i}")
+        l = Landmark.first
+        l.update_attributes(:title => "other title#{i}")
       end
-      @l = @l.reload
-    end
-
-    it 'should find the earliest version' do
-      @l.versions.earliest.should == @l.versions.find_by_version(1)
-    end
-
-    it 'should find the latest version' do
-      @l.versions.latest.should == @l.versions.find_by_version(5)
-    end
 
-    it 'should find the previous version' do
-      @l.versions[1].previous.should == @l.versions[0]
-    end
+      l = l.reload
+      l.version.should == 5
+      l.versions.size.should == 5
+      l.title.should == 'other title5'
+      l.revert_to!(3).should be_true
+      l = l.reload
+      l.version.should == 3
+      l.versions.size.should == 5
+      l.title.should == 'other title3'
+
+      s = Sublandmark.create(:title => 'title')
+      (2..5).each do |i|
+        s = Sublandmark.first
+        s.update_attributes(:title => "title#{i}")
+      end
 
-    it 'should find the next version' do
-      @l.versions[0].next.should == @l.versions[1]
+      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_true
+      s = s.reload
+      s.version.should == 3
+      s.versions.size.should == 5
+      s.title.should == 'title3'
     end
   end
 
-  it 'should save a versioned class with sci' do
-    s = Sublandmark.create!(:title => 'first title')
-    s.new_record?.should be_false
-    s.version.should == 1
+  context 'nodes' do
+    before :all do
+      class Node
+        include MongoMapper::Document
 
-    s.versions.size.should == 1
-    s.versions.first.should be_a(Landmark.versioned_class)
-    s.versions.first.attributes.keys.should include('_version_type')
-    s.versions.first._version_type.should == 'Sublandmark'
-    s.versions.first.landmark.should == s
-  end
+        key :title, String
+      end
 
-  it 'should rollback with sti' do
-    s = Sublandmark.create(:title => 'title')
-    (2..5).each do |i|
-      s = Sublandmark.first
-      s.update_attributes(:title => "title#{i}")
-    end
+      class Page < Node
+        plugin MongoMapper::Acts::Versioned
+      end
 
-    s = s.reload
-    s.version.should == 5
-    s.versions.size.should == 5
-    s.title.should == 'title5'
-    s.revert_to!(3).should be_true
-    s = s.reload
-    s.version.should == 3
-    s.versions.size.should == 5
-    s.title.should == 'title3'
-
-    s.versions.each do |version|
-      version._version_type.should == 'Sublandmark'
+      class Post < Node
+        plugin MongoMapper::Acts::Versioned
+      end
     end
 
-    l = Landmark.create(:title => 'other title')
-    (2..5).each do |i|
-      l = Landmark.first
-      l.update_attributes(:title => "other title#{i}")
+    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
     end
-
-    l = l.reload
-    l.versions.should_not == s.versions
-    l.version.should == 5
-    l.versions.size.should == 5
-    l.title.should == 'other title5'
-    l.revert_to!(3).should be_true
-    l = l.reload
-    l.version.should == 3
-    l.versions.size.should == 5
-    l.title.should == 'other title3'
-
-    Landmark::Version.count.should == 10
   end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  - 10
+  version: 0.0.10
 platform: ruby
 authors: 
 - Gigamo
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-27 00:00:00 +02:00
+date: 2010-09-12 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency