versioned 0.1.0 → 0.2.0

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/Rakefile

@@ -11,7 +11,7 @@ begin
     g.description = %(Versioning for MongoMapper)
     g.email = 'signalstatic@gmail.com'
     g.homepage = 'http://github.com/twoism/versioned'
-    g.authors = %w(twoism toastyapps jacqui)
+    g.authors = %w(twoism toastyapps jacqui mrkurt)
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
@@ -23,4 +23,4 @@ Rake::TestTask.new do |t|
   t.pattern = 'test/**/*_test.rb'
 end
  
-task :default => :test
+task :default => :test

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/version.rb

@@ -17,4 +17,20 @@ class Version
   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

@@ -1,6 +1,7 @@
 require 'version'
 
 module Versioned
+  class StaleDocumentError < MongoMapper::MongoMapperError; end
   def self.included(base)
     base.extend ClassMethods
     base.class_eval do
@@ -8,13 +9,67 @@ module 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)
@@ -56,6 +111,7 @@ module Versioned
       include InstanceMethods
       alias_method_chain :reload, :versions
     end
+
   end
 
   module InstanceMethods
@@ -81,12 +137,18 @@ module Versioned
         @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 => 1)
+        versions.create(:changes => nil, :number => next_version_number(true))
       end
 
       def create_version
-        versions << Version.create(:changes => changes.slice(*versioned_columns), :number => (last_version + 1))
+        versions << Version.create(:changes => changes.slice(*versioned_columns), :number => next_version_number)
         reset_version
       end
 
@@ -128,7 +190,7 @@ module Versioned
       end
       
       def revert
-        revert_to self.version -1
+        revert_to self.versions.at(self.version).previous
       end
       
       def retrieve_version n
@@ -156,8 +218,8 @@ module Versioned
       end
 
       def latest_changes
-        return {} if version.nil? || version == 1
+        return {} if version.nil?
         versions.at(version).changes
       end
   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/schema.rb

@@ -17,5 +17,39 @@ class User
   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
-Version.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

@@ -8,3 +8,5 @@ require 'mongo_mapper'
 require 'versioned'
 require 'schema'
 begin; require 'redgreen'; rescue LoadError; end
+
+

data/versioned.gemspec

@@ -5,18 +5,19 @@
 
 Gem::Specification.new do |s|
   s.name = %q{versioned}
-  s.version = "0.1.0"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["twoism", "toastyapps", "jacqui"]
-  s.date = %q{2009-12-17}
+  s.authors = ["twoism", "toastyapps", "jacqui", "mrkurt"]
+  s.date = %q{2010-01-21}
   s.description = %q{Versioning for MongoMapper}
   s.email = %q{signalstatic@gmail.com}
   s.extra_rdoc_files = [
     "README.rdoc"
   ]
   s.files = [
-    "README.rdoc",
+    ".gitignore",
+     "README.rdoc",
      "Rakefile",
      "VERSION",
      "lib/version.rb",
@@ -27,8 +28,10 @@ Gem::Specification.new do |s|
      "test/comparable_test.rb",
      "test/creation_test.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",
      "versioned.gemspec"
   ]
@@ -43,8 +46,10 @@ Gem::Specification.new do |s|
      "test/comparable_test.rb",
      "test/creation_test.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"
   ]
 

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification 
 name: versioned
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - twoism
 - toastyapps
 - jacqui
+- mrkurt
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-12-17 00:00:00 -05:00
+date: 2010-01-21 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -24,6 +25,7 @@ extensions: []
 extra_rdoc_files: 
 - README.rdoc
 files: 
+- .gitignore
 - README.rdoc
 - Rakefile
 - VERSION
@@ -35,8 +37,10 @@ files:
 - test/comparable_test.rb
 - test/creation_test.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
 - versioned.gemspec
 has_rdoc: true
@@ -73,6 +77,8 @@ test_files:
 - test/comparable_test.rb
 - test/creation_test.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