mongoid_optimistic_locking 0.0.2 → 0.0.3

data/.travis.yml

@@ -1,5 +1,4 @@
 language: ruby
 rvm:
-  - 1.8.7
   - 1.9.2
   - 1.9.3

data/Gemfile

@@ -1,4 +1,3 @@
 source "http://rubygems.org"
 
-# Specify your gem's dependencies in mongoid_optimistic_locking.gemspec
 gemspec

data/README.md

@@ -6,9 +6,9 @@ The gem is an addon over [Mongoid ODM](http://mongoid.org/) and is based on [Act
 
 ## Compatibility
 
-So far it works with the Rails 3 and Mongoid 2.4.
+Works with *Mongoid 3*.
 
-Created branch for edge *Mongoid 3*.
+For Mongoid 2 use version 0.0.2
 
 ## Rails 3 Installation
 
@@ -23,7 +23,6 @@ To use it, all you have to do is add include `Mongoid::OptimisticLocking`:
     class Post
       include Mongoid::Document
       include Mongoid::OptimisticLocking
-
       field :text
     end
 
@@ -47,6 +46,28 @@ For example:
 
 That's it!
 
+## Embedded Document Caveats
+
+While `Mongoid::OptimisticLocking` can be used to some degree within embedded documents, there are certain limitations due to Mongoid's document embedding callback structure. Consider the following example:
+
+    class Post
+      include Mongoid::Document
+      field :text
+      embeds_many :comments
+    end
+
+    class Comment
+      include Mongoid::Document
+      include Mongoid::OptimisticLocking
+      embedded_in :post
+      field :text
+    end
+
+    post = Post.new
+    comment = post.comments.build(:text => 'hello')
+    comment.save # will use optimistic locking checks
+    post.save # will not use optimistic locking checks
+
 ## Open sourced by
 
 [Boxee](http://www.boxee.tv)
@@ -55,3 +76,5 @@ That's it!
 [Mongo Developer FAQ - How do I do transactions/locking?](http://docs.mongodb.org/manual/faq/developers/#how-do-i-do-transactions-and-locking-in-mongodb)
 
 [Mongo Atomic Operations - "Update if Current"](http://www.mongodb.org/display/DOCS/Atomic+Operations#AtomicOperations-%22UpdateifCurrent%22)
+
+[Presentation from "Startup Day" on Mongoid Optimistic Locking](https://speakerdeck.com/u/burgalon/p/mongoid-optimistic-locking)

data/lib/mongoid/optimistic_locking/operations.rb

@@ -2,19 +2,20 @@ module Mongoid
   module OptimisticLocking
     module Operations
 
-      def insert(*args)
+      def insert(options = {})
         return super unless optimistic_locking?
         increment_lock_version do
           super
         end
       end
 
-      def update(*args)
+      def update(options = {})
         return super unless optimistic_locking?
         set_lock_version_for_selector do
           increment_lock_version do
             result = super
-            unless Mongoid.database.command({:getlasterror => 1})['updatedExisting']
+            getlasterror = mongo_session.command({:getlasterror => 1})
+            if result && !getlasterror['updatedExisting']
               raise Mongoid::Errors::StaleDocument.new('update', self)
             end
             result
@@ -22,15 +23,16 @@ module Mongoid
         end
       end
 
-      def remove(*args)
-        return super unless optimistic_locking?
-        set_lock_version_for_selector do
-          result = super
-          unless Mongoid.database.command({:getlasterror => 1})['updatedExisting']
-            raise Mongoid::Errors::StaleDocument.new('destroy', self)
-          end
-          result
+      def remove(options = {})
+        return super unless optimistic_locking? && persisted?
+        # we need to just see if the document exists and got updated with
+        # a higher lock version
+        existing = _reload # get the current root or embedded document
+        if existing.present? && existing['_lock_version'] &&
+           existing['_lock_version'].to_i > _lock_version.to_i
+          raise Mongoid::Errors::StaleDocument.new('destroy', self)
         end
+        super
       end
 
       def atomic_selector

data/lib/mongoid/optimistic_locking/version.rb

@@ -1,5 +1,5 @@
 module Mongoid
   module OptimisticLocking
-    VERSION = '0.0.2'
+    VERSION = '0.0.3'
   end
 end

data/mongoid_optimistic_locking.gemspec

@@ -11,10 +11,9 @@ Gem::Specification.new do |s|
   s.summary     = %q{Allows optimisitic locking for Mongoid models}
   s.description = %q{Allows optimisitic locking for Mongoid models. See https://github.com/burgalon/mongoid_optimistic_locking}
 
-  s.add_dependency 'mongoid', '~> 2.4'
+  s.add_dependency 'mongoid', '>= 3.0.0rc'
   s.add_development_dependency 'rake', '~> 0.9.0'
   s.add_development_dependency 'rspec', '~> 2.6'
-  s.add_development_dependency 'bson_ext', '~> 1.5'
 
   s.rubyforge_project = "mongoid_optimistic_locking"
 

data/spec/optimistic_locking_spec.rb

@@ -2,106 +2,296 @@ require 'spec_helper'
 
 describe Mongoid::OptimisticLocking do
 
-  context 'without optimistic locking' do
+  COLLECTIONS = %w(Company Person Car State Flag City)
 
-    let(:company_class) do
-      Class.new do
-        include Mongoid::Document
-        self.collection_name = 'companies' 
-        field :name
-      end
+  before(:all) do
+
+    class Company
+      include Mongoid::Document
+      field :name
+      has_many :people, :class_name => 'Person', :dependent => :destroy
+    end
+
+    class Person
+      include Mongoid::Document
+      include Mongoid::OptimisticLocking
+      field :name
+      has_many :cars, :dependent => :destroy
     end
 
-    it 'should allow collisions' do
-      c1 = company_class.create!(:name => 'Acme')
-      c2 = company_class.find(c1.id)
+    class Car
+      include Mongoid::Document
+      include Mongoid::OptimisticLocking
+      field :color
+      belongs_to :person
+    end
+
+    class State
+      include Mongoid::Document
+      field :name
+      embeds_one :flag, :inverse_of => :state
+      embeds_many :cities, :class_name => 'City', :inverse_of => :state
+    end
+
+    class Flag
+      include Mongoid::Document
+      include Mongoid::OptimisticLocking
+      embedded_in :state, :inverse_of => :flag
+      field :color
+    end
+
+    class City
+      include Mongoid::Document
+      include Mongoid::OptimisticLocking
+      embedded_in :state, :inverse_of => :cities
+      field :name
+    end
+
+  end
+
+  after(:all) { COLLECTIONS.each { |n| Object.send(:remove_const, n) } }
+  before { (COLLECTIONS - %w(Flag City)).each { |n| n.constantize.delete_all } }
+
+  context 'without optimistic locking' do
+
+    let!(:c1) { Company.create!(:name => 'Acme') }
+    let!(:c2) { Company.find(c1.id) }
+
+    it 'should allow collisions when saving' do
       c1.name = 'Biz'
-      c1.save.should == true
+      c1.save.should be_true
       c2.name = 'Baz'
-      c2.save.should == true
+      c2.save.should be_true
+    end
+
+    it 'should allow collisions when destroying' do
+      c1.destroy.should be_true
+      c2.destroy.should be_true
     end
 
   end
 
-  context 'three instances of the same document' do
+  context 'optimistic locking on a document' do
 
-    let(:person_class) do
-      Class.new do
-        include Mongoid::Document
-        include Mongoid::OptimisticLocking
-        self.collection_name = 'people' 
-        field :name
-      end
+    let(:person) { Person.create!(:name => 'Bob') }
+
+    it 'should allow creating' do
+      person._lock_version.should == 1
+      person.save.should be_true
+      person._lock_version.should == 2
+      Person.count.should == 1
+    end
+
+    it 'should allow updating' do
+      person.name = 'Chris'
+      person.save.should be_true
+      person._lock_version.should == 2
+    end
+
+    it 'should allow destroying after create' do
+      person.destroy.should be_true
+      person.should be_frozen
+      person._lock_version.should == 1
+      Person.count.should == 0
     end
 
-    before do
-      @p1 = person_class.create!(:name => 'Bob')
-      @p2 = person_class.find(@p1.id)
-      @p3 = person_class.find(@p1.id)
+    it 'should allow destroying from find' do
+      another = Person.find(person.id)
+      another.destroy.should be_true
+      another.should be_frozen
+      another._lock_version.should == 1
+      Person.count.should == 0
     end
 
-    context 'after updating the first' do
+    context 'after updating the first of 3 instances of the same document' do
 
       before do
+        @p1 = person
+        @p2 = Person.find(@p1.id)
+        @p3 = Person.find(@p1.id)
         @p1.name = 'Michael'
-        @p1.save.should == true
+        @p1.save.should be_true
       end
 
-      it 'should fail when updating the second' do
+      it 'should raise an exception when updating the second' do
         expect {
           @p2.name = 'George'
           @p2.save
         }.to raise_error(Mongoid::Errors::StaleDocument)
       end
-
+    
       it 'should succeed when updating the second without locking' do
         @p2.name = 'George'
-        @p2.unlocked.save.should == true
+        @p2.unlocked.save.should be_true
       end
-
+    
       it 'should succeed when updating the second without locking, ' +
-         'then fail when updating the third' do
+         'then raise an exception when updating the third' do
         @p2.name = 'George'
-        @p2.unlocked.save.should == true
+        @p2.unlocked.save.should be_true
         expect {
           @p3.name = 'Sally'
           @p3.save
         }.to raise_error(Mongoid::Errors::StaleDocument)
       end
 
-      it 'should fail when destroying the second' do
+      it 'should raise an exception when destroying the second' do
         expect {
           @p2.destroy
         }.to raise_error(Mongoid::Errors::StaleDocument)
+        Person.count.should == 1
       end
 
       it 'should succeed when destroying the second without locking' do
         @p2.unlocked.destroy
+        Person.count.should == 0
       end
 
       it 'should succeed when destroying the second without locking, ' +
-         'then fail when destroying the third' do
+         'and succeed when destroying the third with locking' do
         @p2.unlocked.destroy
-        expect {
-          @p3.destroy
-        }.to raise_error(Mongoid::Errors::StaleDocument)
+        Person.count.should == 0
+        @p3.destroy.should
       end
 
     end
 
+    it 'should destroy dependents with dependent destroy option' do
+      Car.count.should == 0
+      person.cars.create(:color => 'Red')
+      person.destroy
+      Car.count.should == 0
+    end
+
+    it 'should destroy dependents with dependent destroy option even when they are concurrently edited' do
+      car1 = person.cars.create(:color => 'Red')
+      car2 = Car.find(car1.id)
+      car2.update_attribute :color, 'Green'
+      person.reload # important
+      person.destroy
+      Person.count.should == 0
+      Car.count.should == 0
+    end
+
     it 'should give a deprecation warning for #save_optimistic!' do
       ::ActiveSupport::Deprecation.should_receive(:warn).once
-      @p1.save_optimistic!
+      person.save_optimistic!
     end
 
-    it 'should give a deprecation warning for including Mongoid::Lockable' do
-      ::ActiveSupport::Deprecation.should_receive(:warn).once
-      Class.new do
-        include Mongoid::Document
-        include Mongoid::Lockable
-      end
+  end
+
+  context 'optimistic locking on an embeds_one document' do
+
+    let!(:state) { State.new(:name => 'California') }
+
+    it 'should be savable with no embeds' do
+      state.name = 'Nevada'
+      state.save.should be_true
+    end
+
+    it 'should be savable with a built embed' do
+      state.build_flag(:color => 'Red')
+      state.save.should be_true
+    end
+
+    it 'should allow creating the embed' do
+      state.create_flag(:color => 'Red')
+      state.flag.should be_persisted
+    end
+
+    it 'should not increment the lock version when saving the base' do
+      state.build_flag(:color => 'Red')
+      state.flag._lock_version.should == 0
+      state.save
+      state.flag._lock_version.should == 0
+    end
+
+    it 'should increment lock version when saving the embed' do
+      state.build_flag(:color => 'Red')
+      state.flag._lock_version.should == 0
+      state.flag.save
+      state.flag._lock_version.should == 1
+    end
+
+    it 'should not raise an exception on saving the base when another process updated it' do
+      flag1 = state.create_flag(:color => 'Red')
+      flag2 = State.find(state.id).flag
+      flag1.color = 'Green'
+      state.save # doesn't increment lock version
+      flag2.update_attribute(:color, 'Purple').should be_true
+    end
+
+    it 'should raise an exception on update when another process updated it' do
+      flag1 = state.create_flag(:color => 'Red')
+      flag2 = State.find(state.id).flag
+      flag1.update_attribute :color, 'Green'
+      expect {
+        flag2.update_attribute :color, 'Purple'
+      }.to raise_error(Mongoid::Errors::StaleDocument)
+    end
+
+    it 'should raise an exception on destroy when another process updated it' do
+      flag1 = state.create_flag(:color => 'Red')
+      flag2 = State.find(state.id).flag
+      flag1.update_attribute :color, 'Green'
+      expect {
+        flag2.destroy
+      }.to raise_error(Mongoid::Errors::StaleDocument)
+    end
+
+  end
+
+  context 'optimistic locking on an embeds_many document' do
+
+    let!(:state) { State.create!(:name => 'California') }
+
+    it 'should be savable with no embeds' do
+      state.name = 'Nevada'
+      state.save.should be_true
+    end
+
+    it 'should be savable with a built embed' do
+      state.cities.build(:name => 'Los Angeles')
+      state.save.should be_true
+    end
+
+    it 'should allow embedded build to save' do
+      city = state.cities.build(:name => 'Los Angeles')
+      city.save.should be_true
+    end
+
+    it 'should allow embedded create' do
+      city = state.cities.create(:name => 'Los Angeles')
+      city.should be_persisted
     end
 
+    it 'should not increment the lock version when saving the base' do
+      city = state.cities.build(:name => 'Los Angeles')
+      city._lock_version.should == 0
+      state.save
+      city._lock_version.should == 0
+    end
+
+    it 'should increment the lock version when building and saving the embed' do
+      city = state.cities.build(:name => 'Los Angeles')
+      city._lock_version.should == 0
+      city.save
+      city._lock_version.should == 1
+    end
+
+    it 'should increment the lock version when creating the embed' do
+      city = state.cities.create(:name => 'Los Angeles')
+      city._lock_version.should == 1
+    end
+
+  end
+
+  it 'should give a deprecation warning for including Mongoid::Lockable' do
+    ::ActiveSupport::Deprecation.should_receive(:warn).once
+    Class.new do
+      include Mongoid::Document
+      include Mongoid::Lockable
+    end
   end
 
 end

data/spec/spec_helper.rb

@@ -4,8 +4,9 @@ Bundler.setup
 
 require 'mongoid'
 
+# Set the database that the spec suite connects to.
 Mongoid.configure do |config|
-  config.master = Mongo::Connection.new.db("mongoid_optimistic_locking_test")
+  config.connect_to('mongoid_optimistic_locking_test')
 end
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_optimistic_locking
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -10,22 +10,27 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-31 00:00:00.000000000 Z
+date: 2013-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
-  requirement: &2161833600 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: 3.0.0rc
   type: :runtime
   prerelease: false
-  version_requirements: *2161833600
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0rc
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2161832880 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +38,15 @@ dependencies:
         version: 0.9.0
   type: :development
   prerelease: false
-  version_requirements: *2161832880
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2161832180 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,18 +54,12 @@ dependencies:
         version: '2.6'
   type: :development
   prerelease: false
-  version_requirements: *2161832180
-- !ruby/object:Gem::Dependency
-  name: bson_ext
-  requirement: &2161831560 !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.5'
-  type: :development
-  prerelease: false
-  version_requirements: *2161831560
+        version: '2.6'
 description: Allows optimisitic locking for Mongoid models. See https://github.com/burgalon/mongoid_optimistic_locking
 email:
 - burgalon@gmail.com
@@ -106,7 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: mongoid_optimistic_locking
-rubygems_version: 1.8.10
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Allows optimisitic locking for Mongoid models