mongo-lock 1.1.0 → 1.1.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NjI3ZTJmYTQ0ODdmNTU3Nzc0ZDQ0OWJmZjAyYzRmYzFhY2U2YzJkNA==
+    N2Y4MjU2MmNlNDI5ZjJhMWRlODA0NThmZTk3OWMyMGFlMGU4NWNjNg==
   data.tar.gz: !binary |-
-    YjRhOGM3MDNlMGM1ZjYzN2RhZjc4NzdiY2E4ZmJlMzVhMDY5MDc2ZQ==
+    MGZlYjEyMjY5ZTc3ZTkwNGI1OTE2MDBlNDVjYzZiMDQ2NWMxMTg2Ng==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    NTViMDE5MDI2MDhjOTFmOWJkNGM5ZGYzZjc1NjUxN2VkMjRiNTdlNTlmYTQy
-    NzgxYTg1NDk2ZWJkNGJiNzBkMzhjNWFmZTUzZjg4YTkxZDI5ZjVkZDcwZDUw
-    ZmY5ZjkyYzlhZDQ2OTRiNjlkM2M4Y2ZkMWYxNTIyOTM2ZDE2NTg=
+    NjA1ZjgzNWJiMGVjYmNiMjkzOGY3YWUxMzNhMTAyZDFlY2YxNzU2MzgzOTk3
+    MjBkY2E5NGM1ZmQwMzBiZWZlZjdkNzY0ODU5MjY0OTVkZWViMmJkOTY5OWY1
+    NDJhZThkZWNjYWEyOTdhZjI3YmE1YzhlZTAwMTBlYWM0OTQxNWU=
   data.tar.gz: !binary |-
-    OGIwM2E1ZmRjZjQxZGUwOWZjMWNhYTU5MTRhNTk2MTAzZGY1ZmIxNjk4OGQ3
-    NDRjOWRlOGRjZTI1OWY5ZDcyMzNkYzAxMDI3NzVjYjU3YTQwMGUwOWYzNDAz
-    YWQxODEzZTIxYWY2NmQxNmI3OTlkZTY3ZTE2OWI4MTU5M2U0Nzk=
+    YjhiMjJmZmI3ZWJjMzFhZGZjMTAxMWRhN2RlZTY5ZGNmOTcwNzk0MTRiNjA0
+    OTUzOWJkZTM4MWU5OTdkNTYyOWFkZDYyNmZjZTczNWIwNThlNmM4Yzk4ZDVk
+    YjZjZTNlNTcyOTg1M2ZlOTgyNDM2OTYzMGM0MjdmNzU2MTJmNDI=

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mongo-lock (1.0.0)
+    mongo-lock (1.1.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -32,7 +32,7 @@ Or install it yourself as:
 $ gem install mongo-lock
 ```
 
-Build you indexes on any collection that is going to hold locks:
+Build your indexes on any collection that is going to hold locks:
 
 ```ruby
 Mongo::Lock.ensure_indexes # Will use the collection provided to #configure
@@ -57,22 +57,16 @@ A lock has an owner. Mongo::Lock defaults to using an owner id of HOSTNAME:PID:T
 Mongo::Lock makes no effort to help configure the MongoDB connection - that's
 what the Mongo Ruby Driver is for.
 
-Configuring Mongo::Lock with the Mongo Ruby Driver would look like this:
-
 ```ruby
 Mongo::Lock.configure collection: Mongo::Connection.new("localhost").db("somedb").collection("locks")
 ```
 
 Or using Mongoid:
 
-```ruby
-Mongo::Lock.configure collection: Mongoid.database.collection("locks")
-```
-
 You can add multiple collections with a hash that can be referenced later using symbols:
 
 ```ruby
-Mongo::Lock.configure collections: { default: Mongoid.database.collection("locks"), other: Mongoid.database.collection("other_locks") }
+Mongo::Lock.configure collections: { default: database.collection("locks"), other: database.collection("other_locks") }
 Mongo::Lock.acquire('my_lock') # Locks in the default collection
 Mongo::Lock.acquire('my_lock', collection: :other) # Locks in the other_locks collection
 ```
@@ -82,8 +76,8 @@ You can also configure using a block:
 ```ruby
 Mongo::Lock.configure do |config|
   config.collections: {
-    default: Mongoid.database.collection("locks"),
-    other: Mongoid.database.collection("other_locks")
+    default: database.collection("locks"),
+    other: database.collection("other_locks")
   }
 end
 ```
@@ -183,6 +177,10 @@ lock.release
 Mongo::Lock.release('my_key')
 ```
 
+### Lock Key
+
+The lock key is treated in the same way as [ActiveSupport::Cache's keys](http://guides.rubyonrails.org/caching_with_rails.html#cache-keys), except instead of responding to :cache_key or to :to_param it should respond to :lock_key or to :to_param. You can use Hashes and Arrays of values as cache keys.
+
 ### Options
 
 When using Mongo::Lock#acquire, Mongo::Lock#release or Mongo::Lock#new after the key you may overide any of the following options:
@@ -235,6 +233,40 @@ lock = Mongo::Lock.new('my_key')
 lock.available?
 ```
 
+### Release all locks
+
+You can release all locks across an entire collection or owner with the .release_all method.
+
+```ruby
+Mongo::Lock.release_all                              # Release all locks in all registered collections
+Mongo::Lock.release_all collection: :my_locks        # Release all locks in the collection registered as :my_locks
+Mongo::Lock.release_all collection: my_collection    # Release all locks in this instance of Mongo::Collection
+Mongo::Lock.release_all collections: [c1,c2]         # Release all locks in these instances of Mongo::Collection
+Mongo::Lock.release_all collections: {a: ca, b: cb}  # Release all locks in these instances of Mongo::Collection
+Mongo::Lock.release_all owner: 'me'                  # Release all locks in all registered collections that belong to 'me'
+```
+
+### Clear expired locks
+
+You can clear expire locks from the database with the .clear_expired method. If you have called .ensure_indexes mongo will do this for you automatically with a [time to live index](http://docs.mongodb.org/manual/tutorial/expire-data/).
+
+```ruby
+Mongo::Lock.clear_expired                              # Clear expired locks in all registered collections
+Mongo::Lock.clear_expired collection: :my_locks        # Clear expired locks in the collection registered as :my_locks
+Mongo::Lock.clear_expired collection: my_collection    # Clear expired locks in this instance of Mongo::Collection
+Mongo::Lock.clear_expired collections: [c1,c2]         # Clear expired locks in these instances of Mongo::Collection
+Mongo::Lock.clear_expired collections: {a: ca, b: cb}  # Clear expired locks in these instances of Mongo::Collection
+```
+
+### Check a key is already locked without acquiring it
+
+```ruby
+Mongo::Lock.available? 'my_key'
+# Or
+lock = Mongo::Lock.new('my_key')
+lock.available?
+```
+
 ### Failures
 
 If Mongo::Lock#acquire cannot acquire a lock within its configuration limits it will return false.
@@ -279,6 +311,16 @@ rescue Mongo::Lock::LockNotAcquiredError => e
 end
 ```
 
+## Rake tasks
+
+If you are running mongo-lock inside Rails it will add the following rake tasks for you.
+
+```bash
+bundle exec rake mongolock:clear_expired    # Calls Mongo::Lock.clear_expired
+bundle exec rake mongolock:release_all      # Calls Mongo::Lock.release_all
+bundle exec rake mongolock:ensure_indexes   # Calls Mongo::Lock.ensure_indexes
+```
+
 ## Contributors
 
 Matthew Spence (msaspence)

data/lib/mongo-lock.rb

@@ -1,7 +1,12 @@
 require 'mongo-lock/configuration'
-require 'mongo-lock/queries'
+require 'mongo-lock/mongo_queries'
 require 'mongo-lock/class_convenience_methods'
 
+# If we are using Rails then we will include the Mongo::Lock railtie.
+if defined?(Rails)
+  require "mongo-lock/railtie"
+end
+
 module Mongo
   class Lock
 
@@ -39,34 +44,32 @@ module Mongo
       end
     end
 
-
-    def self.release_all options = {}
-      if options.include? :collection
-        Mongo::Lock::Queries.release_collection configuration.collection(options[:collection]), options[:owner]
-      else
-        configuration.collections.each_pair do |key,collection|
-          Mongo::Lock::Queries.release_collection collection, options[:owner]
-        end
-      end
-    end
-
     def self.ensure_indexes
       configuration.collections.each_pair do |key, collection|
-        Mongo::Lock::Queries.ensure_indexes collection
+        Mongo::Lock::MongoQueries.ensure_indexes collection
       end
     end
 
-    def self.clear_expired
-      configuration.collections.each_pair do |key,collection|
-        Mongo::Lock::Queries.clear_expired collection
+    def self.clear_expired options = {}
+      options = configuration.process_collection_options options
+
+      options[:collections].each do |collection|
+        Mongo::Lock::MongoQueries.clear_expired collection
       end
     end
 
+    def self.release_all options = {}
+      options = configuration.process_collection_options options
+
+      options[:collections].each do |collection|
+        Mongo::Lock::MongoQueries.release_collection collection, options[:owner]
+      end
+    end
 
     def initialize key, options = {}
       self.configuration = Configuration.new self.class.configuration.to_hash, options
-      self.key = key
-      self.query = Mongo::Lock::Queries.new self
+      self.key = retrieve_lock_key key
+      self.query = Mongo::Lock::MongoQueries.new self
       acquire_if_acquired
     end
 
@@ -77,13 +80,13 @@ module Mongo
       yield self.configuration if block_given?
     end
 
-    def acquire options = {}
+    def acquire options = {}, &block
       options = inherit_options options
       i = 1
       time_spent = 0
 
       loop do
-        result = try_acquire options, i, time_spent
+        result = try_acquire options, i, time_spent, &block
         return result unless result.nil?
 
         frequency = call_if_proc options[:frequency], i
@@ -93,7 +96,7 @@ module Mongo
       end
     end
 
-    def try_acquire options, i, time_spent
+    def try_acquire options, i, time_spent, &block
       # If timeout has expired
       if options[:timeout_in] && options[:timeout_in] < time_spent
         return raise_or_false options
@@ -114,8 +117,16 @@ module Mongo
       # If the lock was acquired
       else
         self.acquired = true
-        return true
+        return call_block options, &block
+      end
+    end
+
+    def call_block options, &block
+      if block_given?
+        yield self
+        release(options)
       end
+      true
     end
 
     def release options = {}
@@ -150,12 +161,8 @@ module Mongo
     def extend_by time, options = {}
       options = inherit_options options
 
-      # Can't extend a lock that hasn't been acquired
-      if !acquired?
-        return raise_or_false options, NotExtendedError
-
-      # Can't extend a lock that has started
-      elsif expired?
+      # Can't extend a lock that hasn't been acquired or expired
+      if !acquired? || expired?
         return raise_or_false options, NotExtendedError
 
       else
@@ -209,6 +216,14 @@ module Mongo
 
     # Utils
 
+    def retrieve_lock_key key
+      case
+      when key.respond_to?(:lock_key)  then key.lock_key
+      when key.is_a?(Array)            then key.map { |element| retrieve_lock_key(element) }.to_param
+      else                                  key.to_param
+      end.to_s
+    end
+
     def acquire_if_acquired
       self.acquired = true if query.is_acquired?
     end

data/lib/mongo-lock/class_convenience_methods.rb

@@ -2,14 +2,14 @@ module Mongo
   class Lock
     module ClassConvenienceMethods
 
-      def init_and_send key, options = {}, method
+      def init_and_send key, options = {}, method, &block
         lock = Mongo::Lock.new(key, options)
-        lock.send(method)
+        lock.send(method, &block)
         lock
       end
 
-      def acquire key, options = {}
-        init_and_send key, options, :acquire
+      def acquire key, options = {}, &block
+        init_and_send key, options, :acquire, &block
       end
 
       def release key, options = {}
@@ -25,7 +25,7 @@ module Mongo
       end
 
       def available? key, options = {}
-        init_and_send key, options, :available?
+        Mongo::Lock.new(key, options).available?
       end
 
     end

data/lib/mongo-lock/configuration.rb

@@ -50,6 +50,7 @@ module Mongo
 
       def to_hash
         {
+          collections: collections,
           timeout_in: timeout_in,
           limit: limit,
           frequency: frequency,
@@ -67,6 +68,34 @@ module Mongo
         end
       end
 
+      def process_collection_options options
+        options = array_of_collections options
+        options = add_single_collection_to_collections options
+        options = use_registered_collections_if_empty options
+        options
+      end
+
+      def array_of_collections options
+        options[:collections] = options[:collections].try(:values) || options[:collections] || []
+        options
+      end
+
+      def add_single_collection_to_collections options
+        if options[:collection].is_a? Symbol
+          options[:collections] << self.collection(options[:collection])
+        elsif options[:collection]
+          options[:collections] << options[:collection]
+        end
+        options
+      end
+
+      def use_registered_collections_if_empty options
+        if options[:collections].empty?
+          options[:collections] = self.collections.values
+        end
+        options
+      end
+
     end
   end
 end

data/lib/mongo-lock/{queries.rb → mongo_queries.rb}

@@ -1,6 +1,6 @@
 module Mongo
   class Lock
-    class Queries
+    class MongoQueries
 
       attr_accessor :lock
 
@@ -50,7 +50,7 @@ module Mongo
 
       def find_and_modify options
         operation = options[:insert] ? '$setOnInsert' : '$set'
-        existing_lock = collection.find_and_modify({
+        existing_lock = lock.configuration.collection.find_and_modify({
           query: query,
           update: {
             operation => {
@@ -73,7 +73,7 @@ module Mongo
       end
 
       def remove options
-        collection.remove key: key, owner: options[:owner]
+        lock.configuration.collection.remove key: key, owner: options[:owner]
       end
 
       def is_acquired?
@@ -81,7 +81,7 @@ module Mongo
       end
 
       def find_already_acquired
-        collection.find({
+        lock.configuration.collection.find({
           key: key,
           owner: lock.configuration.owner,
           expires_at: { '$gt' => Time.now }
@@ -89,7 +89,7 @@ module Mongo
       end
 
       def find_existing
-        collection.find(query).first
+        lock.configuration.collection.find(query).first
       end
 
     end

data/lib/mongo-lock/railtie.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+require "mongoid"
+require "mongoid/config"
+require "mongoid/railties/document"
+require "rails"
+require "rails/mongoid"
+
+module Rails
+  module Mongo
+    module Lock
+      class Railtie < Rails::Railtie
+
+        rake_tasks do
+          load "mongoid/railties/mongo.rake"
+        end
+
+      end
+    end
+  end
+end

data/lib/mongo-lock/railties/mongo.rake

@@ -0,0 +1,16 @@
+namespace :mongolock do
+  desc "Remove all the expired locks from registered collections"
+  task :clear_expired => :environment do
+    ::Mongo::Lock.clear_expired
+  end
+
+  desc "Release all expired locks from registered collections"
+  task :release_all => :environment do
+    ::Mongo::Lock.release_all
+  end
+
+  desc "Release all expired locks from registered collections"
+  task :ensure_indexes => :environment do
+    ::Mongo::Lock.ensure_indexes
+  end
+end

data/lib/mongo-lock/version.rb

@@ -1,5 +1,5 @@
 module Mongo
   class Lock
-    VERSION = "1.1.0"
+    VERSION = "1.1.1"
   end
 end

data/spec/acquire_spec.rb

@@ -22,6 +22,16 @@ describe Mongo::Lock do
 
     end
 
+    context "when a block is provided" do
+
+      it "passes it to the new lock" do
+        block = Proc.new { |lock| }
+        expect_any_instance_of(Mongo::Lock).to receive(:acquire).with( &block)
+        lock = Mongo::Lock.acquire('my_lock', { limit: 3 }, &block)
+      end
+
+    end
+
   end
 
   describe '#acquire' do
@@ -32,13 +42,13 @@ describe Mongo::Lock do
 
       it "acquires the lock" do
         lock.acquire
-        expect(collection.find(key: 'my_lock').count).to be 1
+        expect(my_collection.find(key: 'my_lock').count).to be 1
       end
 
       it "sets the lock to expire" do
         lock.acquire
-        expect(collection.find(key: 'my_lock').first['expires_at']).to be_within(1.second).of(10.seconds.from_now)
-        expect(collection.find(key: 'my_lock').first['ttl']).to be_within(1.second).of(10.seconds.from_now)
+        expect(my_collection.find(key: 'my_lock').first['expires_at']).to be_within(1.second).of(10.seconds.from_now)
+        expect(my_collection.find(key: 'my_lock').first['ttl']).to be_within(1.second).of(10.seconds.from_now)
       end
 
       it "returns true" do
@@ -52,7 +62,7 @@ describe Mongo::Lock do
       let(:lock) { Mongo::Lock.new 'my_lock' }
 
       it "should call the Proc with the attempt number" do
-        collection.insert key: 'my_lock', owner: 'tobie', expires_at: 10.seconds.from_now
+        my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 10.seconds.from_now
         proc = Proc.new{ |x| x }
         expect(proc).to receive(:call).with(1).and_return(0.01)
         expect(proc).to receive(:call).with(2).and_return(0.01)
@@ -65,9 +75,9 @@ describe Mongo::Lock do
     context "when the lock is unavailable" do
 
       it "retries until it can acquire it" do
-        collection.insert key: 'my_lock', owner: 'tobie', expires_at: 0.1.seconds.from_now
+        my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 0.1.seconds.from_now
         lock.acquire frequency: 0.01, timeout_in: 0.2, limit: 20
-        expect(collection.find(key: 'my_lock', owner: 'spence').count).to be 1
+        expect(my_collection.find(key: 'my_lock', owner: 'spence').count).to be 1
       end
 
     end
@@ -75,12 +85,12 @@ describe Mongo::Lock do
     context "when the lock is already acquired but by the same owner" do
 
       before :each do
-        collection.insert key: 'my_lock', owner: 'spence', expires_at: 10.minutes.from_now
+        my_collection.insert key: 'my_lock', owner: 'spence', expires_at: 10.minutes.from_now
       end
 
       it "doesn't create a new lock" do
         lock.acquire
-        expect(collection.find(key: 'my_lock').count).to be 1
+        expect(my_collection.find(key: 'my_lock').count).to be 1
       end
 
       it "returns true" do
@@ -101,7 +111,7 @@ describe Mongo::Lock do
         let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.03, frequency: 0.01 }
 
         it "should return false" do
-          collection.insert key: 'my_lock', owner: 'tobie', expires_at: 0.2.seconds.from_now
+          my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.second.from_now
           expect(lock.acquire).to be_false
         end
 
@@ -112,7 +122,7 @@ describe Mongo::Lock do
         let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.4, limit: 3, frequency: 0.01 }
 
         it "should return false" do
-          collection.insert key: 'my_lock', owner: 'tobie', expires_at: 0.2.seconds.from_now
+          my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.second.from_now
           expect(lock.acquire).to be_false
         end
 
@@ -127,7 +137,7 @@ describe Mongo::Lock do
         let(:lock) { Mongo::Lock.new 'my_lock', owner: 'tobie', timeout_in: 0.4, limit: 3, frequency: 0.01, raise: true }
 
         it "should raise Mongo::Lock::NotAcquiredError" do
-          collection.insert key: 'my_lock', owner: 'spence', expires_at: 0.2.seconds.from_now
+          my_collection.insert key: 'my_lock', owner: 'spence', expires_at: 1.second.from_now
           expect{lock.acquire}.to raise_error Mongo::Lock::NotAcquiredError
         end
 
@@ -138,7 +148,7 @@ describe Mongo::Lock do
         let(:lock) { Mongo::Lock.new 'my_lock', owner: 'tobie', timeout_in: 0.3, limit: 3, frequency: 0.01, raise: true }
 
         it "should raise Mongo::Lock::NotAcquiredError" do
-          collection.insert key: 'my_lock', owner: 'spence', expires_at: 0.2.seconds.from_now
+          my_collection.insert key: 'my_lock', owner: 'spence', expires_at: 1.second.from_now
           expect{lock.acquire}.to raise_error Mongo::Lock::NotAcquiredError
         end
 
@@ -151,12 +161,35 @@ describe Mongo::Lock do
       let(:lock) { Mongo::Lock.new 'my_lock', owner: 'tobie', timeout_in: 0.2, limit: 11, frequency: 0.01, raise: true }
 
       it "overrides the lock's" do
-        collection.insert key: 'my_lock', owner: 'spence', expires_at: 0.1.seconds.from_now
+        my_collection.insert key: 'my_lock', owner: 'spence', expires_at: 1.second.from_now
         expect(lock.acquire timeout_in: 0.05, limit: 3, frequency: 0.02, raise: false).to be_false
       end
 
     end
 
+    context "when a block is provided" do
+
+      let(:lock) { Mongo::Lock.new 'my_lock', owner: 'tobie', timeout_in: 0.2, limit: 11, frequency: 0.01, raise: true }
+
+      it "should acquire the lock" do
+        lock.acquire do |lock|
+          expect(Mongo::Lock.available? 'my_lock', owner: 'spence').to be_false
+        end
+      end
+
+      it "should call the block" do
+        expect{ |block| lock.acquire &block }.to yield_with_args lock
+      end
+
+      it "should release the lock" do
+        lock.acquire do |lock|
+          # Do something
+        end
+        expect(Mongo::Lock.available?('my_lock', owner: 'spence')).to be_true
+      end
+
+    end
+
   end
 
   describe '.acquire!' do

data/spec/acquired_spec.rb

@@ -18,7 +18,7 @@ describe Mongo::Lock do
     context "when the lock hasn't been acquired" do
 
       it "returns false" do
-        collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.minute.from_now
+        my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.minute.from_now
         lock.acquire
         expect(lock.acquired?).to be_false
       end
@@ -27,8 +27,9 @@ describe Mongo::Lock do
 
     context "when the lock was acquired but has since expired" do
 
+      let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.01, frequency: 0.01, expire_in: 0.1 }
+
       it "returns false" do
-        collection.insert key: 'my_lock', owner: 'spence', expires_at: 0.1.seconds.from_now
         lock.acquire
         sleep 0.2
         expect(lock.acquired?).to be_false
@@ -39,7 +40,7 @@ describe Mongo::Lock do
     context "when the lock was acquired but has since been released" do
 
       it "returns false" do
-        collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.minute.ago
+        my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.minute.ago
         lock.acquire
         lock.release
         expect(lock.acquired?).to be_false

data/spec/available_spec.rb

@@ -4,8 +4,8 @@ describe Mongo::Lock do
 
   describe '.available?' do
 
-    it "creates and returns a new Mongo::Lock instance" do
-      expect(Mongo::Lock.available? 'my_lock').to be_a Mongo::Lock
+    it "creates a new Mongo::Lock instance and returns whether it is available" do
+      expect(Mongo::Lock.available? 'my_lock').to be_true
     end
 
     it "calls #available?" do
@@ -16,8 +16,8 @@ describe Mongo::Lock do
     context "when options are provided" do
 
       it "passes them to the new lock" do
-        lock = Mongo::Lock.available?('my_lock', { owner: 'spence' })
-        expect(lock.configuration.owner).to eql 'spence'
+        Mongo::Lock.acquire 'my_lock', { owner: 'spence' }
+        expect(Mongo::Lock.available?('my_lock', { owner: 'spence' })).to be_true
       end
 
     end
@@ -39,7 +39,7 @@ describe Mongo::Lock do
     context "when the lock is expired" do
 
       it "returns true" do
-        collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.minute.ago
+        my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.minute.ago
         expect(lock.available?).to be_true
       end
 
@@ -48,7 +48,7 @@ describe Mongo::Lock do
     context "when the lock is already acquired but by this owner" do
 
       it "returns true" do
-        collection.insert key: 'my_lock', owner: 'spence', expires_at: 1.minute.from_now
+        my_collection.insert key: 'my_lock', owner: 'spence', expires_at: 1.minute.from_now
         expect(lock.available?).to be_true
       end
 
@@ -57,7 +57,7 @@ describe Mongo::Lock do
     context "when the lock is already acquired" do
 
       it "returns false" do
-        collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.minute.from_now
+        my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.minute.from_now
         expect(lock.available?).to be_false
       end
 

data/spec/clear_expired_spec.rb

@@ -4,17 +4,95 @@ describe Mongo::Lock do
 
   describe '.clear_expired' do
 
-    it "deletes expired locks in all collections" do
-      Mongo::Lock.configure collections: { default: collection, other: other_collection }
-      collection.insert owner: 'owner', key: 'my_lock', expires_at: 1.minute.from_now
-      collection.insert owner: 'owner', key: 'my_lock', expires_at: 1.minute.ago
+    before :each do
+      Mongo::Lock.configure collections: { default: my_collection, other: other_collection }
+    end
+
+    let!(:locks) do
+      my_collection.insert key: 'tobies_lock', owner: 'tobie', expires_at: 1.minute.from_now, ttl: 1.minute.from_now
+      my_collection.insert key: 'spences_lock', owner: 'spence', expires_at: 1.minute.ago, ttl: 1.minute.ago
+      other_collection.insert key: 'spences_lock', owner: 'spence', expires_at: 1.minute.ago, ttl: 1.minute.ago
+      another_collection.insert key: 'spences_lock', owner: 'spence', expires_at: 1.minute.ago, ttl: 1.minute.ago
+    end
+
+    it "deletes expired locks in all reegistered collections" do
+      Mongo::Lock.configure collections: { default: my_collection, other: other_collection }
       other_collection.insert owner: 'owner', key: 'my_lock', expires_at: 1.minute.from_now
-      other_collection.insert owner: 'owner', key: 'my_lock', expires_at: 1.minute.ago
       Mongo::Lock.clear_expired
-      expect(collection.find().count).to be 1
+      expect(my_collection.find().count).to be 1
       expect(other_collection.find().count).to be 1
     end
 
+    context "when a collection is provided" do
+
+      before do
+        Mongo::Lock.clear_expired collection: other_collection
+      end
+
+      it "does release locks in that collection" do
+        expect(other_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
+      end
+
+      it "doesn't release locks in other collections" do
+        expect(my_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 1
+        expect(my_collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
+      end
+
+    end
+
+    context "when a collection symbol is provided" do
+
+      before do
+        Mongo::Lock.clear_expired collection: :other
+      end
+
+      it "does release locks in that collection" do
+        expect(other_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
+      end
+
+      it "doesn't release locks in other collections" do
+        expect(my_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 1
+        expect(my_collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
+      end
+
+    end
+
+    context "when collections are provided" do
+
+      before do
+        Mongo::Lock.clear_expired collections: [another_collection, other_collection]
+      end
+
+      it "does release locks in those collection" do
+        expect(other_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
+        expect(another_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
+      end
+
+      it "doesn't release locks in other collections" do
+        expect(my_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 1
+        expect(my_collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
+      end
+
+      context "when collections is provided as a hash" do
+
+        before do
+          Mongo::Lock.clear_expired collections: { another_collection: another_collection, other_collection: other_collection }
+        end
+
+        it "does release locks in those collection" do
+          expect(other_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
+          expect(another_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
+        end
+
+        it "doesn't release locks in other collections" do
+          expect(my_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 1
+          expect(my_collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
+        end
+
+      end
+
+    end
+
   end
 
 end

data/spec/configuration_spec.rb

@@ -4,9 +4,9 @@ describe Mongo::Lock::Configuration do
 
   subject { Mongo::Lock::Configuration.new({}, {}) }
 
-  let (:collections_with_default) { { a: 'a', b: 'b', default: collection } }
+  let (:collections_with_default) { { a: 'a', b: 'b', default: my_collection } }
   let (:collections) { { a: 'a', b: 'b' } }
-  let (:collection) { 'default' }
+  let (:my_collection) { 'default' }
 
   describe '#initialize' do
 
@@ -21,7 +21,7 @@ describe Mongo::Lock::Configuration do
       context "when provided with a default connection" do
 
         it "stores it in the connections hash as :default" do
-          config = Mongo::Lock::Configuration.new({}, { collection: collection, collections: collections })
+          config = Mongo::Lock::Configuration.new({}, { collection: my_collection, collections: collections })
           expect(config.collections).to eql collections_with_default
         end
 
@@ -40,7 +40,7 @@ describe Mongo::Lock::Configuration do
       context "when provided with a default connection" do
 
         it "stores it in the connections hash as :default" do
-          config = Mongo::Lock::Configuration.new({ collections: collections }, { collection: collection})
+          config = Mongo::Lock::Configuration.new({ collections: collections }, { collection: my_collection})
           expect(config.collections).to eql collections_with_default
         end
 
@@ -87,8 +87,8 @@ describe Mongo::Lock::Configuration do
   describe "#collection=" do
 
     it "should set the default collection" do
-      subject.collection = collection
-      expect(subject.instance_variable_get('@collections')[:default]).to be collection
+      subject.collection = my_collection
+      expect(subject.instance_variable_get('@collections')[:default]).to be my_collection
     end
 
   end

data/spec/ensure_indexes_spec.rb

@@ -11,11 +11,20 @@ describe Mongo::Lock do
       end
 
       it "should build ttl index for each collection" do
-        expect(collection.index_information['ttl_1']).to eql "v"=>1, "key"=> { "ttl"=>1 }, "ns"=>"mongo_lock_tests.locks", "name"=>"ttl_1", "expireAfterSeconds"=>0
+        expect(my_collection.index_information['ttl_1']).to eql "v"=>1, "key"=> { "ttl"=>1 }, "ns"=>"mongo_lock_tests.locks", "name"=>"ttl_1", "expireAfterSeconds"=>0
       end
 
       it "should build an index on key and expires_at for each collection" do
-        expect(collection.index_information['key_1_owner_1_expires_at_1']).to eql "v"=>1, "key"=> { "key"=>1, "owner"=>1, "expires_at"=>1 }, "ns"=>"mongo_lock_tests.locks", "name"=>"key_1_owner_1_expires_at_1"
+        expect(my_collection.index_information['key_1_owner_1_expires_at_1']).to eql "v"=>1, "key"=> { "key"=>1, "owner"=>1, "expires_at"=>1 }, "ns"=>"mongo_lock_tests.locks", "name"=>"key_1_owner_1_expires_at_1"
+      end
+
+      it "should mean expired locks are automatically cleaned", :slow do
+        Mongo::Lock.acquire 'my_lock', owner: 'spence', expire_in: 0
+        Mongo::Lock.acquire 'other_lock', owner: 'spence', expire_in: 500
+        while my_collection.find(owner: 'spence').count != 1
+          sleep 1
+        end
+        expect(my_collection.find(owner: 'spence').count).to be 1
       end
 
     end

data/spec/extend_by_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Mongo::Lock do
 
-  let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.01, frequency: 0.01, expire_in: 0.1 }
+  let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.01, frequency: 0.01, expire_in: 1 }
 
   describe '#extend_by' do
 
@@ -11,7 +11,7 @@ describe Mongo::Lock do
       it "extends the lock" do
         lock.acquire
         lock.extend_by 60
-        expect(collection.find(owner: 'spence', key: 'my_lock').first['expires_at']).to be_within(1.second).of(60.seconds.from_now)
+        expect(my_collection.find(owner: 'spence', key: 'my_lock').first['expires_at']).to be_within(1.second).of(60.seconds.from_now)
       end
 
       it "returns true" do
@@ -23,6 +23,8 @@ describe Mongo::Lock do
 
     context "when the lock has expired" do
 
+      let(:lock) { Mongo::Lock.new 'my_lock', owner: 'spence', timeout_in: 0.01, frequency: 0.01, expire_in: 0.11 }
+
       it "returns false" do
         lock.acquire
         sleep 0.11

data/spec/initialise_spec.rb

@@ -19,13 +19,12 @@ describe Mongo::Lock do
       Mongo::Lock.configure limit: 3
       lock = Mongo::Lock.new 'my_lock', limit: 4
       expect(lock.configuration.limit).to be 4
-
     end
 
     context "when the key is already acquired by this owner" do
 
       it "acquires that lock" do
-        collection.insert key: 'my_lock', owner: 'spence', expires_at: 1.minute.from_now
+        my_collection.insert key: 'my_lock', owner: 'spence', expires_at: 1.minute.from_now
         expect(lock.acquired?).to be_true
       end
 

data/spec/rake_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'rake'
+# load File.expand_path("../lib/railties/mongo.rake", __FILE__)
+load 'mongo-lock/railties/mongo.rake'
+task :environment do ; end
+
+describe 'mongolock' do
+
+  describe 'mongolock:clear_expired' do
+
+    it "calls .clear_expired" do
+      expect(Mongo::Lock).to receive(:clear_expired)
+      Rake::Task['mongolock:clear_expired'].invoke
+    end
+
+  end
+
+  describe 'mongolock:release_all' do
+
+    it "calls .release_all" do
+      expect(Mongo::Lock).to receive(:release_all)
+      Rake::Task['mongolock:release_all'].invoke
+    end
+
+  end
+
+  describe 'mongolock:ensure_indexes' do
+
+    it "calls .ensure_indexes" do
+      expect(Mongo::Lock).to receive(:ensure_indexes)
+      Rake::Task['mongolock:ensure_indexes'].invoke
+    end
+
+  end
+
+end

data/spec/release_all_spec.rb

@@ -5,19 +5,20 @@ describe Mongo::Lock do
   describe '.release_all' do
 
     before :each do
-      Mongo::Lock.configure collections: { default: collection, other: other_collection }
+      Mongo::Lock.configure collections: { default: my_collection, other: other_collection }
     end
 
     let!(:locks) do
-      collection.insert key: 'tobies_lock', owner: 'tobie'
-      collection.insert key: 'spences_lock', owner: 'spence'
+      my_collection.insert key: 'tobies_lock', owner: 'tobie'
+      my_collection.insert key: 'spences_lock', owner: 'spence'
       other_collection.insert key: 'spences_lock', owner: 'spence'
+      another_collection.insert key: 'spences_lock', owner: 'spence'
     end
 
     it "removes all locks from the database" do
       Mongo::Lock.release_all
-      expect(collection.count({ key: 'spences_lock', owner: 'spence'})).to eql 0
-      expect(collection.count({ key: 'tobies_lock', owner: 'tobie'})).to eql 0
+      expect(my_collection.count({ key: 'spences_lock', owner: 'spence'})).to eql 0
+      expect(my_collection.count({ key: 'tobies_lock', owner: 'tobie'})).to eql 0
       expect(other_collection.count({ key: 'spences_lock', owner: 'spence'})).to eql 0
     end
 
@@ -28,12 +29,12 @@ describe Mongo::Lock do
       end
 
       it "doesn't release locks belonging to other owners" do
-        expect(collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
+        expect(my_collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
       end
 
       it "does release locks belonging to that owner" do
         Mongo::Lock.release_all owner: 'spence'
-        expect(collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
+        expect(my_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
         expect(other_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
       end
 
@@ -50,8 +51,8 @@ describe Mongo::Lock do
       end
 
       it "doesn't release locks in other collections" do
-        expect(collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 1
-        expect(collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
+        expect(my_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 1
+        expect(my_collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
       end
 
     end
@@ -67,8 +68,44 @@ describe Mongo::Lock do
       end
 
       it "doesn't release locks in other collections" do
-        expect(collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 1
-        expect(collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
+        expect(my_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 1
+        expect(my_collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
+      end
+
+    end
+
+    context "when collections are provided" do
+
+      before do
+        Mongo::Lock.release_all collections: [another_collection, other_collection]
+      end
+
+      it "does release locks in those collection" do
+        expect(other_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
+        expect(another_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
+      end
+
+      it "doesn't release locks in other collections" do
+        expect(my_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 1
+        expect(my_collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
+      end
+
+      context "when collections is provided as a hash" do
+
+        before do
+          Mongo::Lock.release_all collections: { another_collection: another_collection, other_collection: other_collection }
+        end
+
+        it "does release locks in those collection" do
+          expect(other_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
+          expect(another_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 0
+        end
+
+        it "doesn't release locks in other collections" do
+          expect(my_collection.find({ key: 'spences_lock', owner: 'spence'}).count).to eql 1
+          expect(my_collection.find({ key: 'tobies_lock', owner: 'tobie'}).count).to eql 1
+        end
+
       end
 
     end

data/spec/release_spec.rb

@@ -32,14 +32,14 @@ describe Mongo::Lock do
     context "when lock is acquired" do
 
       before :each do
-        collection.insert key: 'my_lock', owner: 'spence'
+        my_collection.insert key: 'my_lock', owner: 'spence'
       end
 
       let(:lock) { Mongo::Lock.acquire 'my_lock', owner: 'spence' }
 
       it "releases the lock" do
         lock.release
-        expect(collection.find(key: 'my_lock', owner: 'spence').count).to be 0
+        expect(my_collection.find(key: 'my_lock', owner: 'spence').count).to be 0
       end
 
       it "returns true" do
@@ -68,14 +68,14 @@ describe Mongo::Lock do
       let(:lock) { Mongo::Lock.new 'my_lock', timeout_in: 1, frequency: 0.01 }
 
       it "returns false" do
-        collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.seconds.from_now
+        my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.seconds.from_now
         expect(lock.release timeout_in: 0.01).to be_false
       end
 
       it "doesn't release the lock" do
-        collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.seconds.from_now
+        my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.seconds.from_now
         lock.release timeout_in: 0.01
-        expect(collection.find(key: 'my_lock', owner: 'tobie').count).to be 1
+        expect(my_collection.find(key: 'my_lock', owner: 'tobie').count).to be 1
       end
 
     end
@@ -106,7 +106,7 @@ describe Mongo::Lock do
       it "releases the lock" do
         lock
         different_instance.release
-        expect(collection.find(key: 'my_lock', owner: 'spence').count).to be 0
+        expect(my_collection.find(key: 'my_lock', owner: 'spence').count).to be 0
       end
 
       it "returns true" do
@@ -123,7 +123,7 @@ describe Mongo::Lock do
       context "when the lock isn't acquired and cant be" do
 
         it "raises Mongo::Lock::NotReleasedError" do
-          collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.seconds.from_now
+          my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.seconds.from_now
           expect{ lock.release }.to raise_error Mongo::Lock::NotReleasedError
         end
 
@@ -134,9 +134,9 @@ describe Mongo::Lock do
     context "when options are provided" do
 
       it "they override the defaults" do
-        collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.seconds.from_now
+        my_collection.insert key: 'my_lock', owner: 'tobie', expires_at: 1.seconds.from_now
         expect(lock.release owner: 'tobie').to be_true
-        expect(collection.find(key: 'my_lock', owner: 'tobie').count).to be 0
+        expect(my_collection.find(key: 'my_lock', owner: 'tobie').count).to be 0
       end
 
     end

data/spec/spec_helper.rb

@@ -25,7 +25,8 @@ RSpec.configure do |config|
   config.before :each do
     database.drop_collection("locks")
     database.drop_collection("other_locks")
-    Mongo::Lock.configure collection: collection
+    database.drop_collection("another_locks")
+    Mongo::Lock.configure collection: my_collection
   end
 
   config.after :each do

data/spec/support/mongo_helper.rb

@@ -8,12 +8,16 @@ module MongoHelper
     @database ||= connection.db("mongo_lock_tests")
   end
 
-  def collection
-    @collection ||= database.collection :locks
+  def my_collection
+    @my_collection ||= database.collection :locks
   end
 
   def other_collection
     @other_collection ||= database.collection :other_locks
   end
 
+  def another_collection
+    @another_collection ||= database.collection :another_locks
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongo-lock
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Matthew Spence
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-24 00:00:00.000000000 Z
+date: 2014-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -113,7 +113,9 @@ files:
 - lib/mongo-lock.rb
 - lib/mongo-lock/class_convenience_methods.rb
 - lib/mongo-lock/configuration.rb
-- lib/mongo-lock/queries.rb
+- lib/mongo-lock/mongo_queries.rb
+- lib/mongo-lock/railtie.rb
+- lib/mongo-lock/railties/mongo.rake
 - lib/mongo-lock/version.rb
 - mongo-lock.gemspec
 - mongoid.yml
@@ -127,6 +129,7 @@ files:
 - spec/expired_spec.rb
 - spec/extend_by_spec.rb
 - spec/initialise_spec.rb
+- spec/rake_spec.rb
 - spec/release_all_spec.rb
 - spec/release_spec.rb
 - spec/spec_helper.rb
@@ -166,6 +169,7 @@ test_files:
 - spec/expired_spec.rb
 - spec/extend_by_spec.rb
 - spec/initialise_spec.rb
+- spec/rake_spec.rb
 - spec/release_all_spec.rb
 - spec/release_spec.rb
 - spec/spec_helper.rb