jacqui-versioned 0.1.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jacqui Maher
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,51 @@
+= versioned
+
+Simple versioning for MongoMapper
+
+= installation
+
+The versioned gem is hosted on gemcutter.org:
+
+* gem install versioned
+
+= usage
+
+    class Doc
+      include MongoMapper::Document
+      include Versioned
+      key :title, String
+    end
+
+    @doc = Doc.create(:title=>"v1")
+    @doc.title = "v2"
+    @doc.save
+
+    @doc.revert
+
+    puts @doc.title
+    => v1
+
+    @doc.title = "v3"
+    @doc.save
+    @doc.version
+    => 3
+
+    @doc.retrieve_version 2
+    puts @doc.title 
+    => "v2"
+
+    @doc = Doc.find(@doc.id)
+    @doc.title
+    => "v3"
+    @doc.version
+    => 3
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.

data/Rakefile

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+ 
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |g|
+    g.name = 'jacqui-versioned'
+    g.summary = %(Versioning for MongoMapper)
+    g.description = %(Versioning for MongoMapper)
+    g.email = 'jacqui@brighter.net'
+    g.homepage = 'http://github.com/jacqui/versioned'
+    g.authors = %w(twoism toastyapps jacqui mrkurt)
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts 'Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com'
+end
+ 
+Rake::TestTask.new do |t|
+  t.libs = %w(test)
+  t.pattern = 'test/**/*_test.rb'
+end
+ 
+task :default => :test

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/init.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + 'lib/version.rb'
+require File.dirname(__FILE__) + 'lib/versioned.rb'

data/lib/version.rb

@@ -0,0 +1,36 @@
+class Version
+  include MongoMapper::Document
+  include Comparable
+  
+  key :number, Integer
+  key :versioned_type, String
+  key :versioned_id, ObjectId
+  key :changes, Hash
+  timestamps!
+
+  belongs_to :versioned, :polymorphic => true
+  def changes
+    read_attribute(:changes)
+  end
+  alias_attribute :version, :number
+
+  def <=>(other)
+    number <=> other.number
+  end
+
+  def previous
+    find_related(:first, :number => {:$lt => number}, :order => 'number.desc')
+  end
+
+  def next
+    find_related(:first, :number => {:$gt => number}, :order => 'number.asc')
+  end
+
+  protected
+
+  def find_related(*args)
+    options = args.extract_options!
+    params = options.merge(:versioned_id => versioned_id, :versioned_type => versioned_type)
+    self.class.find(args.first, params)
+  end
+end

data/lib/versioned.rb

@@ -0,0 +1,225 @@
+require 'version'
+
+module Versioned
+  class StaleDocumentError < MongoMapper::MongoMapperError; end
+  def self.included(base)
+    base.extend ClassMethods
+    base.class_eval do
+      versioned
+    end
+  end
+
+  module LockingInstanceMethods
+    private
+      #new? isn't working
+      def is_new_document?
+        (read_attribute(self.version_lock_key).blank? && changes[self.version_lock_key.to_s].blank?) ||
+        (changes[self.version_lock_key.to_s] && changes[self.version_lock_key.to_s].first.blank?)
+      end
+      def prep_lock_version
+        old = read_attribute(self.version_lock_key)
+        if !is_new_document? || old.blank?
+          v = (Time.now.to_f * 1000).ceil.to_s
+          write_attribute self.version_lock_key, v
+        end
+
+        old
+      end
+
+      def save_to_collection(options = {})
+        current_version = prep_lock_version
+        if is_new_document?
+          collection.insert(to_mongo, :safe => true)
+        else
+          selector = { :_id => read_attribute(:_id), self.version_lock_key => current_version }
+          #can't upsert, safe must be true for this to work
+          result = collection.update(selector, to_mongo, :upsert => false, :safe => true)
+
+          if result.is_a?(Array) && result[0][0]['updatedExisting'] == false
+            write_attribute self.version_lock_key, current_version
+            raise StaleDocumentError.new
+          elsif !result.is_a?(Array)
+            #wtf?
+            write_attribute self.version_lock_key, current_version
+            raise "Unexpected result from mongo"
+          end
+
+          selector[:_id]
+        end
+      end
+  end
+  module ClassMethods
+    def locking!(options = {})
+      include(LockingInstanceMethods)
+      class_inheritable_accessor :version_lock_key
+      self.version_lock_key = options[:key] || :lock_version
+      key self.version_lock_key, Integer
+
+      if self.respond_to?(:version_use_key)
+        self.version_use_key = self.version_lock_key
+        (self.version_except_columns ||= []) << self.version_lock_key.to_s #don't version the lock key 
+      end
+    end
+
+    def versioned(options = {})
+      class_inheritable_accessor :version_only_columns
+      self.version_only_columns = Array(options[:only]).map(&:to_s).uniq if options[:only]
+      class_inheritable_accessor :version_except_columns
+      self.version_except_columns = Array(options[:except]).map(&:to_s).uniq if options[:except]
+
+      class_inheritable_accessor :version_use_key
+      self.version_use_key = options[:use_key]
+
+      many :versions, :as => :versioned, :order => 'number ASC', :dependent => :delete_all do
+        def between(from, to)
+          from_number, to_number = number_at(from), number_at(to)
+          return [] if from_number.nil? || to_number.nil?
+          condition = (from_number == to_number) ? to_number : Range.new(*[from_number, to_number].sort)
+          if condition.is_a?(Range)
+            conditions = {'$gte' => condition.first, '$lte' => condition.last}
+          else
+            conditions = condition
+          end
+          find(:all, 
+            :number => conditions,
+            :order => "number #{(from_number > to_number) ? 'DESC' : 'ASC'}"
+          )
+        end
+
+        def at(value)
+          case value
+            when Version then value
+            when Numeric then find_by_number(value.floor)
+            when Symbol then respond_to?(value) ? send(value) : nil
+            when Date, Time then last(:created_at => {'$lte' => value.to_time})
+          end
+        end
+
+        def number_at(value)
+          case value
+            when Version then value.number
+            when Numeric then value.floor
+            when Symbol, Date, Time then at(value).try(:number)
+          end
+        end
+      end
+
+      after_create :create_initial_version
+      after_update :create_initial_version, :if => :needs_initial_version?
+      after_update :create_version, :if => :needs_version?
+
+      include InstanceMethods
+      alias_method_chain :reload, :versions
+    end
+
+  end
+
+  module InstanceMethods
+    private
+      def versioned_columns
+        case
+          when version_only_columns then self.class.keys.keys & version_only_columns
+          when version_except_columns then self.class.keys.keys - version_except_columns
+          else self.class.keys.keys
+        end - %w(created_at created_on updated_at updated_on)
+      end
+
+      def needs_initial_version?
+        versions.empty?
+      end
+
+      def needs_version?
+        !(versioned_columns & changed).empty?
+      end
+
+      def reset_version(new_version = nil)
+        @last_version = nil if new_version.nil?
+        @version = new_version
+      end
+
+      def next_version_number(initial = false)
+        v = read_attribute self.version_use_key unless self.version_use_key.nil?
+        v = 1 if v.nil? && initial
+        v = last_version + 1 if v.nil? && !initial
+        v
+      end
+      def create_initial_version
+        versions.create(:changes => nil, :number => next_version_number(true))
+      end
+
+      def create_version
+        versions << Version.create(:changes => changes.slice(*versioned_columns), :number => next_version_number)
+        reset_version
+      end
+
+    public
+      def version
+        @version ||= last_version
+      end
+
+      def last_version
+        @last_version ||= versions.inject(1){|max, version| version.number > max ? version.number : max} 
+      end
+
+      def reverted?
+        version != last_version
+      end
+
+      def reload_with_versions(*args)
+        reset_version
+        reload_without_versions(*args)
+      end
+
+      def changes_between(from, to)
+        from_number, to_number = versions.number_at(from), versions.number_at(to)
+        return {} if from_number == to_number
+        chain = versions.between(from_number, to_number)
+        return {} if chain.empty?
+
+        backward = chain.first > chain.last
+        backward ? chain.pop : chain.shift
+
+        chain.inject({}) do |changes, version|
+          version.changes.each do |attribute, change|
+            change.reverse! if backward
+            new_change = [changes.fetch(attribute, change).first, change.last]
+            changes.update(attribute => new_change)
+          end
+          changes
+        end
+      end
+      
+      def revert
+        revert_to self.versions.at(self.version).previous
+      end
+      
+      def retrieve_version n
+        versions.find_by_number(n).changes.each do |n,v|
+          self.send("#{n.to_sym}=",v.first)
+        end 
+      end
+      
+      def revert_to(value)
+        to_number = versions.number_at(value)
+        changes = changes_between(version, to_number)
+        return version if changes.empty?
+
+        changes.each do |attribute, change|
+          write_attribute(attribute, change.last)
+        end
+
+        reset_version(to_number)
+      end
+
+      def revert_to!(value)
+        revert_to(value)
+        reset_version if saved = save
+        saved
+      end
+
+      def latest_changes
+        return {} if version.nil?
+        versions.at(version).changes
+      end
+  end
+end

data/test/between_test.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+class BetweenTest < Test::Unit::TestCase
+  context 'The number of versions between' do
+    setup do
+      @user = User.create(:name => 'Steve Richert')
+      @version = @user.version
+      @valid = [@version, 0, 1_000_000, :first, :last, 1.day.since(@user.created_at), @user.versions.first]
+      @invalid = [nil, :bogus, 'bogus', Date.parse('0001-12-25')]
+    end
+
+    context 'the current version and the current version' do
+      should 'equal one' do
+        assert_equal 1, @user.versions.between(@version, @version).size
+      end
+    end
+
+    context 'the current version and a valid value' do
+      should 'not equal zero' do
+        @valid.each do |valid|
+          assert_not_equal 0, @user.versions.between(@version, valid).size
+          assert_not_equal 0, @user.versions.between(valid, @version).size
+        end
+      end
+    end
+
+    context 'the current version and an invalid value' do
+      should 'equal zero' do
+        @invalid.each do |invalid|
+          assert_equal 0, @user.versions.between(@version, invalid).size
+          assert_equal 0, @user.versions.between(invalid, @version).size
+        end
+      end
+    end
+
+    context 'two invalid values' do
+      should 'equal zero' do
+        @invalid.each do |first|
+          @invalid.each do |second|
+            assert_equal 0, @user.versions.between(first, second).size
+            assert_equal 0, @user.versions.between(second, first).size
+          end
+        end
+      end
+    end
+
+    context 'a valid value and an invalid value' do
+      should 'equal zero' do
+        @valid.each do |valid|
+          @invalid.each do |invalid|
+            assert_equal 0, @user.versions.between(valid, invalid).size
+            assert_equal 0, @user.versions.between(invalid, valid).size
+          end
+        end
+      end
+    end
+  end
+end

data/test/changes_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class ChangesTest < Test::Unit::TestCase
+  context "A version's changes" do
+    setup do
+      @user = User.create(:name => 'Steve Richert')
+    end
+
+    should "initially be blank" do
+      assert @user.versions.first.changes.blank?
+    end
+
+    should 'contain all changed attributes' do
+      @user.name = 'Steve Jobs'
+      changes = @user.changes
+      @user.save
+      assert_equal changes, @user.versions.last.changes.slice(*changes.keys)
+    end
+
+    should 'contain no more than the changed attributes and timestamps' do
+      timestamps = %w(created_at created_on updated_at updated_on)
+      @user.name = 'Steve Jobs'
+      changes = @user.changes
+      @user.save
+      assert_equal changes, @user.versions.last.changes.except(*timestamps)
+    end
+  end
+end

data/test/comparable_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class ComparableTest < Test::Unit::TestCase
+  context 'A comparable version' do
+    setup do
+      @version_1 = Version.new(:number => 1)
+      @version_2 = Version.new(:number => 2)
+    end
+
+    should 'equal itself' do
+      assert @version_1 == @version_1
+      assert @version_2 == @version_2
+    end
+
+    context 'with version number 1' do
+      should 'not equal a version with version number 2' do
+        assert @version_1 != @version_2
+      end
+
+      should 'be less than a version with version number 2' do
+        assert @version_1 < @version_2
+      end
+    end
+
+    context 'with version number 2' do
+      should 'not equal a version with version number 1' do
+        assert @version_2 != @version_1
+      end
+
+      should 'be greater than a version with version number 1' do
+        assert @version_2 > @version_1
+      end
+    end
+  end
+end

data/test/creation_test.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+class CreationTest < Test::Unit::TestCase
+  context 'The number of versions' do
+    setup do
+      @name = 'Steve Richert'
+      @user = User.create(:name => @name)
+      @count = @user.versions.count
+    end
+
+    should 'initially equal one' do
+      assert_equal 1, @count
+    end
+
+    should 'not increase when no changes are made in an update' do
+      @user.name =  @name
+      assert_equal @count, @user.versions.count
+    end
+
+    should 'not increase when no changes are made before a save' do
+      @user.save
+      assert_equal @count, @user.versions.count
+    end
+
+    should 'not increase when reverting to the current version' do
+      @user.revert_to!(@user.version)
+      assert_equal @count, @user.versions.count
+    end
+
+    context 'after an update' do
+      setup do
+        @initial_count = @count
+        @name = 'Steve Jobs'
+        @user.name = @name
+        @user.save
+        @count = @user.versions.count
+      end
+
+      should 'increase by one' do
+        assert_equal @initial_count + 1, @count
+      end
+
+      should 'increase by one when reverted' do
+        @user.revert_to!(:first)
+        assert_equal @count + 1, @user.versions.count
+      end
+
+      should 'not increase until a revert is saved' do
+        @user.revert_to(:first)
+        assert_equal @count, @user.versions.count
+        @user.save
+        assert_not_equal @count, @user.versions.count
+      end
+    end
+    
+    should "retrieve a specific version without reverting it" do
+      @user.name = "Hoge"
+      @user.save
+      version_count = @user.versions.size
+      @user.retrieve_version 2
+      assert_equal version_count, @user.versions.size
+    end
+
+    context 'after multiple updates' do
+      setup do
+        @initial_count = @count
+        @new_name = 'Steve Jobs'
+        @user.name = @new_name
+        @user.name = @name
+        @count = @user.versions.count
+      end
+
+      should 'not increase when reverting to an identical version' do
+        @user.revert_to!(:first)
+        assert_equal @count, @user.versions.count
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'versioned'
+
+class Test::Unit::TestCase
+end

data/test/latest_changes_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class LatestChangesTest < Test::Unit::TestCase
+  context "A created model's last changes" do
+    setup do
+      @user = User.create(:name => 'Steve Richert')
+    end
+
+    should 'be blank' do
+      assert @user.latest_changes.blank?
+    end
+  end
+
+  context "An updated model's last changes" do
+    setup do
+      @user = User.create(:name => 'Steve Richert')
+      @previous_attributes = @user.attributes
+      @user.name = 'Steve Jobs'
+      @current_attributes = @user.attributes
+    end
+
+    should 'values of two-element arrays with unique values' do
+      @user.latest_changes.values.each do |value|
+        assert_kind_of Array, value
+        assert_equal 2, value.size
+        assert_equal value, value.uniq
+      end
+    end
+
+    should 'begin with the previous attribute values' do
+      changes = @user.latest_changes.inject({}){|h,(k,v)| h.update(k => v.first) }
+      previous = @previous_attributes.slice(*@user.latest_changes.keys)
+      assert_equal previous, changes
+    end
+
+    should 'end with the current attribute values' do
+      changes = @user.latest_changes.inject({}){|h,(k,v)| h.update(k => v.last) }
+      current = @current_attributes.slice(*@user.latest_changes.keys)
+      assert_equal current, changes
+    end
+  end
+end

data/test/lock_test.rb

@@ -0,0 +1,91 @@
+require 'test_helper'
+
+class LockTest < Test::Unit::TestCase
+  context 'An unversioned model with locks' do
+    setup do
+      @user = UnversionedLockableUser.create(:name => 'Kurt')
+    end
+
+    should 'have a lock_version field' do
+      assert_not_nil @user.lock_version
+    end
+
+    should 'save just fine when no conflicts' do
+      @user.name = 'Bob'
+      assert @user.save
+    end
+
+    should 'save just fine when given the proper lock version' do
+      u = UnversionedLockableUser.find(@user.id)
+      @user.update_attributes(:name => 'Bill')
+
+      assert u.update_attributes(:name => 'Jose', :lock_version => @user.lock_version)
+    end
+
+    should 'not save when given the wrong version' do
+      assert_raise Versioned::StaleDocumentError do
+        @user.update_attributes(:name => 'Bob', :lock_version => 1111)
+      end
+
+      # lock_version should match what we passed in
+      assert_equal 1111, @user.lock_version
+    end
+  end
+  context 'A versioned model with locks' do
+    setup do
+      @user = LockableUser.create(:name => 'Kurt', :required_field => 'woo!')
+    end
+
+    should 'have a lock_version field' do
+      assert_not_nil @user.lock_version
+      assert_equal @user.version, @user.lock_version
+    end
+
+    should 'save just fine when no conflicts' do
+      @user.name = 'Bob'
+      assert @user.save
+    end
+
+    should 'save just fine when given the proper lock version' do
+      u = LockableUser.find(@user.id)
+      @user.update_attributes(:name => 'Bill')
+
+      assert u.update_attributes(:name => 'Jose', :lock_version => @user.lock_version)
+    end
+
+    should 'not save when given the wrong version' do
+      assert_raise Versioned::StaleDocumentError do
+        @user.update_attributes(:name => 'Bob', :lock_version => 1111)
+      end
+
+      # lock_version should match what we passed in
+      assert_equal 1111, @user.lock_version
+    end
+
+    should 'be revertable with the lock version' do
+      v = @user.lock_version
+      name = @user.name
+      @user.update_attributes(:name => "Schlub")
+
+      assert_not_equal v, @user.lock_version
+
+      @user.revert_to(v)
+
+      assert_equal name, @user.name
+      assert_not_equal v, @user.lock_version #shouldn't have reverted version
+    end
+
+    should 'accept a specified version on create' do
+      u = LockableUser.create(:name => 'Burt', :required_field => 'woo!', :lock_version => 1111)
+      assert_equal 1111, u.lock_version
+    end
+
+    should "have same lock_version when validation fails" do
+      @user.required_field = nil
+      v = @user.lock_version
+      result = @user.save
+      assert !result
+      assert_equal v, @user.lock_version
+    end
+  end
+end

data/test/revert_test.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+class RevertTest < Test::Unit::TestCase
+  context 'A model reversion' do
+    setup do
+      @user, @attributes, @times = User.new, {}, {}
+      names = ['Steve Richert', 'Stephen Richert', 'Stephen Jobs', 'Steve Jobs']
+      time = names.size.hours.ago
+      names.each do |name|
+        @user.update_attributes({:name => name})
+        @attributes[@user.version] = @user.attributes
+        time += 1.hour
+        @user.versions.last.update_attributes({:created_at => time})
+        @times[@user.version] = time
+      end
+      @first_version, @last_version = @attributes.keys.min, @attributes.keys.max
+    end
+
+    should 'do nothing for a non-existent version' do
+      attributes = @user.attributes
+      @user.revert_to!(nil)
+      assert_equal attributes, @user.attributes
+    end
+
+    should 'return the new version number' do
+      new_version = @user.revert_to(@first_version)
+      assert_equal @first_version, new_version
+    end
+
+    should 'change the version number when saved' do
+      current_version = @user.version
+      @user.revert_to!(@first_version)
+      assert_not_equal current_version, @user.version
+    end
+
+    should 'be able to target the first version' do
+      @user.revert_to(:first)
+      assert_equal @first_version, @user.version
+    end
+
+    should 'be able to target the last version' do
+      @user.revert_to(:last)
+      assert_equal @last_version, @user.version
+    end
+
+    should 'do nothing for a non-existent method name' do
+      current_version = @user.version
+      @user.revert_to(:bogus)
+      assert_equal current_version, @user.version
+    end
+
+    should 'be able to target a version number' do
+      @user.revert_to(1)
+      assert 1, @user.version
+    end
+
+    should 'be able to target a date and time' do
+      @times.each do |version, time|
+        @user.revert_to(time + 1.second)
+        assert_equal version, @user.version
+      end
+    end
+
+    should 'be able to target a version object' do
+      @user.versions.each do |version|
+        @user.revert_to(version)
+        assert_equal version.number, @user.version
+      end
+    end
+
+    should "correctly roll back the model's attributes" do
+      timestamps = %w(created_at created_on updated_at updated_on)
+      @attributes.each do |version, attributes|
+        @user.revert_to!(version)
+        assert_equal attributes.except(*timestamps), @user.attributes.except(*timestamps)
+      end
+    end
+  end
+end

data/test/schema.rb

@@ -0,0 +1,55 @@
+MongoMapper.connection = Mongo::Connection.new('127.0.0.1')
+MongoMapper.database = "testing_versioned"
+
+class User
+  include MongoMapper::Document
+  include Versioned
+  key :first_name, String
+  key :last_name, String
+  timestamps!
+  
+  def name
+    [first_name, last_name].compact.join(' ')
+  end
+
+  def name=(names)
+    self[:first_name], self[:last_name] = names.split(' ', 2)
+  end
+end
+
+class Loser
+  include MongoMapper::Document
+  extend Versioned::ClassMethods
+  versioned :use_key => :revision
+  key :revision, Integer
+  key :name, String
+  timestamps!
+
+  before_save :set_revision
+
+  def set_revision
+    write_attribute :revision, (Time.now.to_f * 1000).ceil
+  end
+end
+
+class LockableUser
+  include MongoMapper::Document
+  include Versioned
+  locking!
+
+  key :name, String
+  key :required_field, String
+  validates_presence_of :required_field
+end
+
+class UnversionedLockableUser
+  include MongoMapper::Document
+  extend Versioned::ClassMethods
+  locking!
+  
+  key :name, String
+end
+
+User.destroy_all
+Loser.destroy_all
+Version.destroy_all

data/test/specified_version_key_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+class SpecifiedVersionKey < Test::Unit::TestCase
+  context 'A model with a specified version key' do
+    setup do
+      @name = "Blah"
+      @loser = Loser.create(:name => @name)
+      @version = @loser.version
+    end
+    should 'be used for the initial version' do
+      assert_equal @loser.revision, @loser.version
+      assert_equal @loser.revision, @loser.versions.first.number
+    end
+
+    context 'after an update' do
+      setup do
+        @initial_version = @loser.version
+        @initial_count = @loser.versions.count
+        @initial_name = @loser.name
+        @name = 'Blip'
+        @loser.name = @name
+        @loser.save
+        @version = @loser.version
+        @count = @loser.versions.count
+      end
+
+      should 'have a different version number' do
+        assert_not_equal @initial_version, @loser.version
+      end
+
+      should 'still be using the specified key' do
+        assert_equal @loser.revision, @loser.version
+        assert_equal @loser.revision, @loser.versions.last.number
+      end
+
+      should 'version count should have increased by one' do
+        assert_equal @initial_count + 1, @count
+      end
+      
+      should 'revert properly' do
+        @loser.revert
+        @loser.save!
+        assert_equal @initial_name, @loser.name
+        assert_equal @count + 1, @loser.versions.count
+        assert_not_equal @version, @loser.version
+        assert_not_equal @initial_version, @loser.version
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+$: << File.dirname(__FILE__)
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mongo_mapper'
+require 'versioned'
+require 'schema'
+begin; require 'redgreen'; rescue LoadError; end

data/test/test_versioned.rb

@@ -0,0 +1,80 @@
+require "test_helper"
+
+require File.expand_path(File.dirname(__FILE__) + '/../lib/versioned')
+require File.expand_path(File.dirname(__FILE__) + '/../lib/version')
+
+class Doc
+  include MongoMapper::Document
+  include Versioned
+  key :title, String
+end
+
+MongoMapper.connection.drop_database DB_NAME
+MongoMapper.database = DB_NAME
+
+class VersionTest < Test::Unit::TestCase
+  
+  context "A Content Instance" do
+    
+    setup do
+      @doc = Doc.create(:title=>"Foo")   
+    end
+    
+    should "respond to versions" do
+      assert @doc.respond_to?(:versions)
+    end
+    
+    should "have before_save callback" do
+      assert Doc.before_update.collect(&:method).include?(:save_version)
+    end
+    
+    context "after update" do
+      setup do
+        @doc.title = "Version 2"
+        @doc.save
+      end
+
+      should "create a version after update" do
+        assert_equal(1, @doc.versions.count)
+      end
+      
+      should "have the correct version number" do
+        assert_equal(1, @doc.versions.first.version_number)
+      end
+
+      should "update the model's version key" do
+        assert_equal(1, @doc.version)
+      end
+      
+      should "have :title in changes" do
+        assert_contains(@doc.versions.first.changed_attrs.keys, "title")
+      end
+      
+      should "revert to last version" do
+        @doc.revert
+        assert_equal(@doc.title, "Foo")
+      end
+      
+      should "revert by version #" do
+        @doc.title = "Version 3"
+        @doc.save
+        @doc.revert_to_version 2
+        assert_equal("Version 2", @doc.title)
+      end
+      
+      should "retrieve a specific version without reverting it" do
+        @doc.title = "Version 3"
+        @doc.save
+        version_count = @doc.versions.size
+        @doc.retrieve_version 2
+        assert_equal version_count, @doc.versions.size
+      end
+      should "cleanup versions on destroy" do
+        @doc.destroy
+        assert_equal(0, Version.count)
+      end
+      
+    end
+    
+  end
+end

data/versioned.gemspec

@@ -0,0 +1,60 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{versioned}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["twoism", "toastyapps", "jacqui", "mrkurt"]
+  s.date = %q{2009-12-17}
+  s.description = %q{Versioning for MongoMapper}
+  s.email = %q{signalstatic@gmail.com}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "lib/version.rb",
+     "lib/versioned.rb",
+     "test/between_test.rb",
+     "test/changes_test.rb",
+     "test/comparable_test.rb",
+     "test/creation_test.rb",
+     "test/latest_changes_test.rb",
+     "test/revert_test.rb",
+     "test/schema.rb",
+     "test/test_helper.rb",
+     "versioned.gemspec"
+  ]
+  s.homepage = %q{http://github.com/twoism/versioned}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Versioning for MongoMapper}
+  s.test_files = [
+    "test/between_test.rb",
+     "test/changes_test.rb",
+     "test/comparable_test.rb",
+     "test/creation_test.rb",
+     "test/latest_changes_test.rb",
+     "test/revert_test.rb",
+     "test/schema.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: jacqui-versioned
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- twoism
+- toastyapps
+- jacqui
+- mrkurt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-18 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Versioning for MongoMapper
+email: jacqui@brighter.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- init.rb
+- lib/version.rb
+- lib/versioned.rb
+- pkg/versioned-0.1.0.gem
+- test/between_test.rb
+- test/changes_test.rb
+- test/comparable_test.rb
+- test/creation_test.rb
+- test/helper.rb
+- test/latest_changes_test.rb
+- test/lock_test.rb
+- test/revert_test.rb
+- test/schema.rb
+- test/specified_version_key_test.rb
+- test/test_helper.rb
+- test/test_versioned.rb
+- versioned.gemspec
+has_rdoc: true
+homepage: http://github.com/jacqui/versioned
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Versioning for MongoMapper
+test_files: 
+- test/between_test.rb
+- test/changes_test.rb
+- test/comparable_test.rb
+- test/creation_test.rb
+- test/helper.rb
+- test/latest_changes_test.rb
+- test/lock_test.rb
+- test/revert_test.rb
+- test/schema.rb
+- test/specified_version_key_test.rb
+- test/test_helper.rb
+- test/test_versioned.rb