redis-mutex 3.0.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 31cd09963698ff45f5481699862332a7299ea0fb
-  data.tar.gz: ca58764a3e815285dc03a03650969f20db9c65fc
+  metadata.gz: 253615b378afcd470a670355dc6924fc18ce9bad
+  data.tar.gz: 22fdcf12b682dd3550a6a73b2ef1b0aa96aaa5b3
 SHA512:
-  metadata.gz: d6cc1d509749ac3214d6bdfe8d02e1c91dcde89fc901e54c6019a451aba47c7592581eee63cf7dd0eea9a00f0776acca86d64850712929f6f29de9dadef95a6c
-  data.tar.gz: fd155b4e46710e57b0e95425ae896abdcb7a2efa7e0ddd872915156ffd2e92a0ef0933b433b0bfab0b8f399f46e500c7ee329bdb4c002a294dcef5d438a404b7
+  metadata.gz: e4e348e87e282e279e3bb4a780f420484365ceaa101438de710f7b0fe5ed9843278d3615579c343497d23041980614fbd2772c2a85f86ec4029800e92104b888
+  data.tar.gz: 06897c56818022fae3b8b97a8a391f1d72e06887916fb08ed81d58f3b37341063a4c15feff782f82ed6a7072a342a66d501a7e44e4e213f6774c489a8b83602e

data/.travis.yml

@@ -4,6 +4,6 @@ services:
 rvm:
   - 2.0.0
   - 2.1.0
-  - rbx
+  - rbx-2
   - ruby-head
   - jruby-head

data/README.md

@@ -13,7 +13,7 @@ Synopsis
 In the following example, only one thread / process / server can enter the locked block at one time.
 
 ```ruby
-Redis::Mutex.with_lock(:your_lock_name) do
+RedisMutex.with_lock(:your_lock_name) do
   # do something exclusively
 end
 ```
@@ -21,7 +21,7 @@ end
 or
 
 ```ruby
-mutex = Redis::Mutex.new(:your_lock_name)
+mutex = RedisMutex.new(:your_lock_name)
 if mutex.lock
   # do something exclusively
   mutex.unlock
@@ -40,13 +40,21 @@ Or if you want to immediately receive `false` on an unsuccessful locking attempt
 Changelog
 ---------
 
+### v4.0
+
+`redis-mutex` 4.0 has brought a few backward incompatible changes to follow the major upgrade of the underlying `redis-classy` gem.
+
+* The base class `Redis::Mutex` is now `RedisMutex`.
+* `Redis::Classy.db = Redis.new` is now `RedisClassy.redis = Redis.new`.
+
 ### v3.0
 
 * Ruby 2.0 or later is required.
+* `auto_mutex` now takes `:on` for additional key scoping.
 
 ### v2.0
 
-* **Exception-based control flow**: Added `lock!` and `unlock!`, which raises an exception when fails to acquire a lock. Raises `Redis::Mutex::LockError` and `Redis::Mutex::UnlockError` respectively.
+* **Exception-based control flow**: Added `lock!` and `unlock!`, which raises an exception when fails to acquire a lock. Raises `RedisMutex::LockError` and `RedisMutex::UnlockError` respectively.
 * **INCOMPATIBLE CHANGE**: `#lock` no longer accepts a block. Use `#with_lock` instead, which uses `lock!` internally and returns the value of block.
 * `unlock` returns boolean values for success / failure, for consistency with `lock`.
 
@@ -67,7 +75,7 @@ gem 'redis-mutex'
 Register the Redis server: (e.g. in `config/initializers/redis_mutex.rb` for Rails)
 
 ```ruby
-Redis::Classy.db = Redis.new(:host => 'localhost')
+RedisClassy.redis = Redis.new
 ```
 
 Note that Redis Mutex uses the `redis-classy` gem internally to organize keys in an isolated namespace.
@@ -75,7 +83,7 @@ Note that Redis Mutex uses the `redis-classy` gem internally to organize keys in
 There are a number of methods:
 
 ```ruby
-mutex = Redis::Mutex.new(key, options)    # Configure a mutex lock
+mutex = RedisMutex.new(key, options)    # Configure a mutex lock
 mutex.lock                                # Try to acquire the lock, returns false when failed
 mutex.lock!                               # Try to acquire the lock, raises exception when failed
 mutex.unlock                              # Try to release the lock, returns false when failed
@@ -84,20 +92,20 @@ mutex.locked?                             # Find out if resource already locked
 mutex.with_lock                           # Try to acquire the lock, execute the block, then return the value of the block.
                                           # Raises exception when failed to acquire the lock.
 
-Redis::Mutex.sweep                        # Remove all expired locks
-Redis::Mutex.with_lock(key, options)      # Shortcut to new + with_lock
+RedisMutex.sweep                        # Remove all expired locks
+RedisMutex.with_lock(key, options)      # Shortcut to new + with_lock
 ```
 
 The key argument can be symbol, string, or any Ruby objects that respond to `id` method, where the key is automatically set as
-`TheClass:id`. For any given key, `Redis::Mutex:` prefix will be automatically prepended. For instance, if you pass a `Room`
-object with id of `123`, the actual key in Redis will be `Redis::Mutex:Room:123`. The automatic prefixing and instance binding
-is the feature of `Redis::Classy` - for more internal details, refer to [Redis Classy](https://github.com/kenn/redis-classy).
+`TheClass:id`. For any given key, `RedisMutex:` prefix will be automatically prepended. For instance, if you pass a `Room`
+object with id of `123`, the actual key in Redis will be `RedisMutex:Room:123`. The automatic prefixing and instance binding
+is the feature of `RedisClassy` - for more internal details, refer to [Redis Classy](https://github.com/kenn/redis-classy).
 
 The initialize method takes several options.
 
 ```ruby
 :block  => 1    # Specify in seconds how long you want to wait for the lock to be released.
-                # Speficy 0 if you need non-blocking sematics and return false immediately. (default: 1)
+                # Specify 0 if you need non-blocking sematics and return false immediately. (default: 1)
 :sleep  => 0.1  # Specify in seconds how long the polling interval should be when :block is given.
                 # It is NOT recommended to go below 0.01. (default: 0.1)
 :expire => 10   # Specify in seconds when the lock should be considered stale when something went wrong
@@ -114,11 +122,11 @@ class RoomController < ApplicationController
   before_filter { @room = Room.find(params[:id]) }
   
   def enter
-    Redis::Mutex.with_lock(@room) do    # key => "Room:123"
+    RedisMutex.with_lock(@room) do    # key => "Room:123"
       # do something exclusively
     end
     render text: 'success!'
-  rescue Redis::Mutex::LockError
+  rescue RedisMutex::LockError
     render text: 'failed to acquire lock!'
   end
 end
@@ -129,7 +137,7 @@ put the `unlock` method in the `ensure` clause.
 
 ```ruby
 def enter
-  mutex = Redis::Mutex.new('non-blocking', block: 0, expire: 10.minutes)
+  mutex = RedisMutex.new('non-blocking', block: 0, expire: 10.minutes)
   if mutex.lock
     begin
       # do something exclusively
@@ -153,7 +161,7 @@ If you give a proc object to the `after_failure` option, it will get called afte
 
 ```ruby
 class JobController < ApplicationController
-  include Redis::Mutex::Macro
+  include RedisMutex::Macro
   auto_mutex :run, block: 0, after_failure: lambda { render text: 'failed to acquire lock!' }
 
   def run
@@ -162,3 +170,17 @@ class JobController < ApplicationController
   end
 end
 ```
+
+Also you can specify method arguments with the `on` option. The following creates a mutex key named `ItunesVerifier#perform:123456`, so that the same method can run in parallel as long as the `transaction_id` is different.
+
+```ruby
+class ItunesVerifier
+  include Sidekiq::Worker
+  include RedisMutex::Macro
+  auto_mutex :perform, on: [:transaction_id]
+
+  def perform(transaction_id)
+    ...
+  end
+end
+```

data/lib/redis-mutex.rb

@@ -1,5 +1,2 @@
 require 'redis-classy'
-
-class Redis
-  autoload :Mutex, 'redis/mutex'
-end
+require 'redis_mutex'

data/lib/redis_mutex.rb

@@ -0,0 +1,132 @@
+class RedisMutex < RedisClassy
+  #
+  # Options
+  #
+  # :block  => Specify in seconds how long you want to wait for the lock to be released. Speficy 0
+  #            if you need non-blocking sematics and return false immediately. (default: 1)
+  # :sleep  => Specify in seconds how long the polling interval should be when :block is given.
+  #            It is recommended that you do NOT go below 0.01. (default: 0.1)
+  # :expire => Specify in seconds when the lock should forcibly be removed when something went wrong
+  #            with the one who held the lock. (default: 10)
+  #
+  autoload :Macro, 'redis_mutex/macro'
+
+  DEFAULT_EXPIRE = 10
+  LockError = Class.new(StandardError)
+  UnlockError = Class.new(StandardError)
+  AssertionError = Class.new(StandardError)
+
+  def initialize(object, options={})
+    super(object.is_a?(String) || object.is_a?(Symbol) ? object : "#{object.class.name}:#{object.id}")
+    @block = options[:block] || 1
+    @sleep = options[:sleep] || 0.1
+    @expire = options[:expire] || DEFAULT_EXPIRE
+  end
+
+  def lock
+    self.class.raise_assertion_error if block_given?
+    @locking = false
+
+    if @block > 0
+      # Blocking mode
+      start_at = Time.now
+      while Time.now - start_at < @block
+        @locking = true and break if try_lock
+        sleep @sleep
+      end
+    else
+      # Non-blocking mode
+      @locking = try_lock
+    end
+    @locking
+  end
+
+  def try_lock
+    now = Time.now.to_f
+    @expires_at = now + @expire                       # Extend in each blocking loop
+
+    loop do
+      return true if setnx(@expires_at)               # Success, the lock has been acquired
+    end until old_value = get                         # Repeat if unlocked before get
+
+    return false if old_value.to_f > now              # Check if the lock is still effective
+
+    # The lock has expired but wasn't released... BAD!
+    return true if getset(@expires_at).to_f <= now    # Success, we acquired the previously expired lock
+    return false # Dammit, it seems that someone else was even faster than us to remove the expired lock!
+  end
+
+  # Returns true if resource is locked. Note that nil.to_f returns 0.0
+  def locked?
+    get.to_f > Time.now.to_f
+  end
+
+  def unlock(force = false)
+    # Since it's possible that the operations in the critical section took a long time,
+    # we can't just simply release the lock. The unlock method checks if @expires_at
+    # remains the same, and do not release when the lock timestamp was overwritten.
+
+    if get == @expires_at.to_s or force
+      # Redis#del with a single key returns '1' or nil
+      !!del
+    else
+      false
+    end
+  end
+
+  def with_lock
+    if lock!
+      begin
+        @result = yield
+      ensure
+        unlock
+      end
+    end
+    @result
+  end
+
+  def lock!
+    lock or raise LockError, "failed to acquire lock #{key.inspect}"
+  end
+
+  def unlock!(force = false)
+    unlock(force) or raise UnlockError, "failed to release lock #{key.inspect}"
+  end
+
+  class << self
+    def sweep
+      return 0 if (all_keys = keys).empty?
+
+      now = Time.now.to_f
+      values = mget(*all_keys)
+
+      expired_keys = all_keys.zip(values).select do |key, time|
+        time && time.to_f <= now
+      end
+
+      expired_keys.each do |key, _|
+        # Make extra sure that anyone haven't extended the lock
+        del(key) if getset(key, now + DEFAULT_EXPIRE).to_f <= now
+      end
+
+      expired_keys.size
+    end
+
+    def lock(object, options = {})
+      raise_assertion_error if block_given?
+      new(object, options).lock
+    end
+
+    def lock!(object, options = {})
+      new(object, options).lock!
+    end
+
+    def with_lock(object, options = {}, &block)
+      new(object, options).with_lock(&block)
+    end
+
+    def raise_assertion_error
+      raise AssertionError, 'block syntax has been removed from #lock, use #with_lock instead'
+    end
+  end
+end

data/lib/redis_mutex/macro.rb

@@ -0,0 +1,56 @@
+class RedisMutex
+  module Macro
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_eval do
+        class << self
+          attr_accessor :auto_mutex_methods
+        end
+        @auto_mutex_methods = {}
+      end
+    end
+
+    module ClassMethods
+      def auto_mutex(target, options={})
+        self.auto_mutex_methods[target] = options
+      end
+
+      def method_added(target)
+        return if target.to_s =~ /^auto_mutex_methods/
+        return unless self.auto_mutex_methods[target]
+        without_method  = "#{target}_without_auto_mutex"
+        with_method     = "#{target}_with_auto_mutex"
+        after_method    = "#{target}_after_failure"
+        return if method_defined?(without_method)
+        options = self.auto_mutex_methods[target]
+
+        if options[:after_failure].is_a?(Proc)
+          define_method(after_method, &options[:after_failure])
+        end
+        target_argument_names = instance_method(target.to_sym).parameters.map(&:last)
+        on_arguments = Array(options[:on])
+        mutex_arguments = on_arguments & target_argument_names
+        unknown_arguments = on_arguments - target_argument_names
+        if unknown_arguments.any?
+          raise ArgumentError, "You are trying to lock on unknown arguments: #{unknown_arguments.join(', ')}"
+        end
+
+        define_method(with_method) do |*args|
+          named_arguments =  Hash[target_argument_names.zip(args)]
+          arguments  = mutex_arguments.map { |name| named_arguments.fetch(name) }
+          key = self.class.name << '#' << target.to_s << ":" << arguments.join(':')
+          begin
+            RedisMutex.with_lock(key, options) do
+              send(without_method, *args)
+            end
+          rescue RedisMutex::LockError
+            send(after_method, *args) if respond_to?(after_method)
+          end
+        end
+
+        alias_method without_method, target
+        alias_method target, with_method
+      end
+    end
+  end
+end

data/redis-mutex.gemspec

@@ -12,9 +12,9 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "redis-mutex"
   gem.require_paths = ["lib"]
-  gem.version       = '3.0.0' # retrieve this value by: Gem.loaded_specs['redis-mutex'].version.to_s
+  gem.version       = '4.0.0' # retrieve this value by: Gem.loaded_specs['redis-mutex'].version.to_s
 
-  gem.add_runtime_dependency "redis-classy", "~> 1.2"
+  gem.add_runtime_dependency "redis-classy", "~> 2.0"
   gem.add_development_dependency "rspec"
   gem.add_development_dependency "bundler"
 

data/spec/redis_mutex_macro_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 class C
-  include Redis::Mutex::Macro
+  include RedisMutex::Macro
   auto_mutex :run_singularly, :block => 0, :after_failure => lambda {|id| return "failure: #{id}" }
 
   def run_singularly(id)
@@ -22,7 +22,7 @@ class C
   end
 end
 
-describe Redis::Mutex::Macro do
+describe RedisMutex::Macro do
 
   def race(a, b)
     t1 = Thread.new(&a)
@@ -38,32 +38,32 @@ describe Redis::Mutex::Macro do
 
   it 'adds auto_mutex' do
     race(
-      proc { C.new.run_singularly(1).should == "success: 1" },
-      proc { C.new.run_singularly(2).should == "failure: 2" })
+      proc { expect(C.new.run_singularly(1)).to eq("success: 1") },
+      proc { expect(C.new.run_singularly(2)).to eq("failure: 2") })
   end
 
   it 'adds auto_mutex on different args' do
     race(
-      proc { C.new.run_singularly_on_args(1, :'2', object_arg).should == "success: 1" },
-      proc { C.new.run_singularly_on_args(2, :'2', object_arg).should == "success: 2" })
+      proc { expect(C.new.run_singularly_on_args(1, :'2', object_arg)).to eq("success: 1") },
+      proc { expect(C.new.run_singularly_on_args(2, :'2', object_arg)).to eq("success: 2") })
   end
 
   it 'adds auto_mutex on same args' do
     race(
-      proc { C.new.run_singularly_on_args(1, :'2', object_arg).should == "success: 1" },
-      proc { C.new.run_singularly_on_args(1, :'2', object_arg).should == "failure: 1" })
+      proc { expect(C.new.run_singularly_on_args(1, :'2', object_arg)).to eq("success: 1") },
+      proc { expect(C.new.run_singularly_on_args(1, :'2', object_arg)).to eq("failure: 1") })
   end
 
   it 'adds auto_mutex on different keyword args' do
     race(
-      proc { C.new.run_singularly_on_keyword_args(id: 1, foo: :'2', bar: object_arg).should == "success: 1" },
-      proc { C.new.run_singularly_on_keyword_args(id: 2, foo: :'2', bar: object_arg).should == "success: 2" })
+      proc { expect(C.new.run_singularly_on_keyword_args(id: 1, foo: :'2', bar: object_arg)).to eq("success: 1") },
+      proc { expect(C.new.run_singularly_on_keyword_args(id: 2, foo: :'2', bar: object_arg)).to eq("success: 2") })
   end
 
   it 'adds auto_mutex on same keyword args' do
     race(
-      proc { C.new.run_singularly_on_keyword_args(id: 1, foo: :'2', bar: object_arg).should == "success: 1" },
-      proc { C.new.run_singularly_on_keyword_args(id: 1, foo: :'2', bar: object_arg).should == "failure: 1" })
+      proc { expect(C.new.run_singularly_on_keyword_args(id: 1, foo: :'2', bar: object_arg)).to eq("success: 1") },
+      proc { expect(C.new.run_singularly_on_keyword_args(id: 1, foo: :'2', bar: object_arg)).to eq("failure: 1") })
   end
 
   it 'raise exception if there is no such argument' do

data/spec/redis_mutex_spec.rb

@@ -2,152 +2,152 @@ require 'spec_helper'
 
 SHORT_MUTEX_OPTIONS = { :block => 0.1, :sleep => 0.02 }
 
-describe Redis::Mutex do
+describe RedisMutex do
   before do
-    Redis::Classy.flushdb
+    RedisClassy.flushdb
   end
 
   after :all do
-    Redis::Classy.flushdb
-    Redis::Classy.quit
+    RedisClassy.flushdb
+    RedisClassy.quit
   end
 
   it 'locks the universe' do
-    mutex1 = Redis::Mutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
-    mutex1.lock.should be_true
+    mutex1 = RedisMutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
+    expect(mutex1.lock).to be_truthy
 
-    mutex2 = Redis::Mutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
-    mutex2.lock.should be_false
+    mutex2 = RedisMutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
+    expect(mutex2.lock).to be_falsey
   end
 
   it 'fails to lock when the lock is taken' do
-    mutex1 = Redis::Mutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
+    mutex1 = RedisMutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
 
-    mutex2 = Redis::Mutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
-    mutex2.lock.should be_true    # mutex2 beats us to it
+    mutex2 = RedisMutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
+    expect(mutex2.lock).to be_truthy    # mutex2 beats us to it
 
-    mutex1.lock.should be_false   # fail
+    expect(mutex1.lock).to be_falsey   # fail
   end
 
   it 'unlocks only once' do
-    mutex = Redis::Mutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
-    mutex.lock.should be_true
+    mutex = RedisMutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
+    expect(mutex.lock).to be_truthy
 
-    mutex.unlock.should be_true   # successfully released the lock
-    mutex.unlock.should be_false  # the lock no longer exists
+    expect(mutex.unlock).to be_truthy   # successfully released the lock
+    expect(mutex.unlock).to be_falsey  # the lock no longer exists
   end
 
   it 'prevents accidental unlock from outside' do
-    mutex1 = Redis::Mutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
-    mutex1.lock.should be_true
+    mutex1 = RedisMutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
+    expect(mutex1.lock).to be_truthy
 
-    mutex2 = Redis::Mutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
-    mutex2.unlock.should be_false
+    mutex2 = RedisMutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
+    expect(mutex2.unlock).to be_falsey
   end
 
   it 'sets expiration' do
     start = Time.now
     expires_in = 10
-    mutex = Redis::Mutex.new(:test_lock, :expire => expires_in)
+    mutex = RedisMutex.new(:test_lock, :expire => expires_in)
     mutex.with_lock do
-      mutex.get.to_f.should be_within(1.0).of((start + expires_in).to_f)
+      expect(mutex.get.to_f).to be_within(1.0).of((start + expires_in).to_f)
     end
-    mutex.get.should be_nil   # key should have been cleaned up
+    expect(mutex.get).to be_nil   # key should have been cleaned up
   end
 
   it 'overwrites a lock when existing lock is expired' do
     # stale lock from the far past
-    Redis::Mutex.set(:test_lock, Time.now - 60)
+    RedisMutex.on(:test_lock).set(Time.now - 60)
 
-    mutex = Redis::Mutex.new(:test_lock)
-    mutex.lock.should be_true
+    mutex = RedisMutex.new(:test_lock)
+    expect(mutex.lock).to be_truthy
   end
 
   it 'fails to unlock the key if it took too long past expiration' do
-    mutex = Redis::Mutex.new(:test_lock, :expire => 0.1, :block => 0)
-    mutex.lock.should be_true
+    mutex = RedisMutex.new(:test_lock, :expire => 0.1, :block => 0)
+    expect(mutex.lock).to be_truthy
     sleep 0.2   # lock expired
 
     # someone overwrites the expired lock
-    mutex2 = Redis::Mutex.new(:test_lock, :expire => 10, :block => 0)
-    mutex2.lock.should be_true
+    mutex2 = RedisMutex.new(:test_lock, :expire => 10, :block => 0)
+    expect(mutex2.lock).to be_truthy
 
     mutex.unlock
-    mutex.get.should_not be_nil   # lock should still be there
+    expect(mutex.get).not_to be_nil   # lock should still be there
   end
 
   it 'ensures unlocking when something goes wrong in the block' do
-    mutex = Redis::Mutex.new(:test_lock)
+    mutex = RedisMutex.new(:test_lock)
     begin
       mutex.with_lock do
         raise "Something went wrong!"
       end
     rescue RuntimeError
-      mutex.get.should be_nil
+      expect(mutex.get).to be_nil
     end
   end
 
   it 'resets locking state on reuse' do
-    mutex = Redis::Mutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
-    mutex.lock.should be_true
-    mutex.lock.should be_false
+    mutex = RedisMutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
+    expect(mutex.lock).to be_truthy
+    expect(mutex.lock).to be_falsey
   end
 
   it 'tells about lock\'s state' do
-    mutex = Redis::Mutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
+    mutex = RedisMutex.new(:test_lock, SHORT_MUTEX_OPTIONS)
     mutex.lock
 
-    mutex.should be_locked
+    expect(mutex).to be_locked
 
     mutex.unlock
-    mutex.should_not be_locked
+    expect(mutex).not_to be_locked
   end
 
   it 'tells that resource is not locked when lock is expired' do
-    mutex = Redis::Mutex.new(:test_lock, :expire => 0.1)
+    mutex = RedisMutex.new(:test_lock, :expire => 0.1)
     mutex.lock
 
     sleep 0.2 # lock expired now
 
-    mutex.should_not be_locked
+    expect(mutex).not_to be_locked
   end
 
   it 'returns value of block' do
-    Redis::Mutex.with_lock(:test_lock) { :test_result }.should == :test_result
+    expect(RedisMutex.with_lock(:test_lock) { :test_result }).to eq(:test_result)
   end
 
   it 'requires block for #with_lock' do
-    expect { Redis::Mutex.with_lock(:test_lock) }.to raise_error(LocalJumpError) #=> no block given (yield)
+    expect { RedisMutex.with_lock(:test_lock) }.to raise_error(LocalJumpError) #=> no block given (yield)
   end
 
   it 'raises LockError if lock not obtained' do
-    expect { Redis::Mutex.lock!(:test_lock, SHORT_MUTEX_OPTIONS) }.to_not raise_error
-    expect { Redis::Mutex.lock!(:test_lock, SHORT_MUTEX_OPTIONS) }.to raise_error(Redis::Mutex::LockError)
+    expect { RedisMutex.lock!(:test_lock, SHORT_MUTEX_OPTIONS) }.to_not raise_error
+    expect { RedisMutex.lock!(:test_lock, SHORT_MUTEX_OPTIONS) }.to raise_error(RedisMutex::LockError)
   end
 
   it 'raises UnlockError if lock not obtained' do
-    mutex = Redis::Mutex.new(:test_lock)
-    mutex.lock.should be_true
-    mutex.unlock.should be_true
-    expect { mutex.unlock! }.to raise_error(Redis::Mutex::UnlockError)
+    mutex = RedisMutex.new(:test_lock)
+    expect(mutex.lock).to be_truthy
+    expect(mutex.unlock).to be_truthy
+    expect { mutex.unlock! }.to raise_error(RedisMutex::UnlockError)
   end
 
   it 'raises AssertionError when block is given to #lock' do
     # instance method
-    mutex = Redis::Mutex.new(:test_lock)
-    expect { mutex.lock {} }.to raise_error(Redis::Mutex::AssertionError)
+    mutex = RedisMutex.new(:test_lock)
+    expect { mutex.lock {} }.to raise_error(RedisMutex::AssertionError)
 
     # class method
-    expect { Redis::Mutex.lock(:test_lock) {} }.to raise_error(Redis::Mutex::AssertionError)
+    expect { RedisMutex.lock(:test_lock) {} }.to raise_error(RedisMutex::AssertionError)
   end
 
   it 'sweeps expired locks' do
-    Redis::Mutex.set(:past, Time.now.to_f - 60)
-    Redis::Mutex.set(:present, Time.now.to_f)
-    Redis::Mutex.set(:future, Time.now.to_f + 60)
-    Redis::Mutex.keys.size.should == 3
-    Redis::Mutex.sweep.should == 2
-    Redis::Mutex.keys.size.should == 1
+    RedisMutex.on(:past).set(Time.now.to_f - 60)
+    RedisMutex.on(:present).set(Time.now.to_f)
+    RedisMutex.on(:future).set(Time.now.to_f + 60)
+    expect(RedisMutex.keys.size).to eq(3)
+    expect(RedisMutex.sweep).to eq(2)
+    expect(RedisMutex.keys.size).to eq(1)
   end
 
   describe 'stress test' do
@@ -155,8 +155,8 @@ describe Redis::Mutex do
 
     def run(id)
       print "invoked worker #{id}...\n"
-      Redis::Classy.db.client.reconnect
-      mutex = Redis::Mutex.new(:test_lock, :expire => 1, :block => 10, :sleep => 0.01)
+      RedisClassy.redis.client.reconnect
+      mutex = RedisMutex.new(:test_lock, :expire => 1, :block => 10, :sleep => 0.01)
       result = 0
       LOOP_NUM.times do |i|
         mutex.with_lock do

data/spec/spec_helper.rb

@@ -6,9 +6,8 @@ require 'redis-mutex'
 
 RSpec.configure do |config|
   # Use database 15 for testing so we don't accidentally step on you real data.
-  Redis::Classy.db = Redis.new(:db => 15)
-  unless Redis::Classy.keys.empty?
-    puts '[ERROR]: Redis database 15 not empty! If you are sure, run "rake flushdb" beforehand.'
-    exit!
+  RedisClassy.redis = Redis.new(db: 15)
+  unless RedisClassy.keys.empty?
+    abort '[ERROR]: Redis database 15 not empty! If you are sure, run "rake flushdb" beforehand.'
   end
 end

metadata

@@ -1,69 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: redis-mutex
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Kenn Ejima
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-28 00:00:00.000000000 Z
+date: 2014-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-classy
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Distrubuted mutex using Redis
@@ -73,16 +73,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - lib/redis-mutex.rb
-- lib/redis/mutex.rb
-- lib/redis/mutex/macro.rb
+- lib/redis_mutex.rb
+- lib/redis_mutex/macro.rb
 - redis-mutex.gemspec
 - spec/redis_mutex_macro_spec.rb
 - spec/redis_mutex_spec.rb
@@ -96,17 +96,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Distrubuted mutex using Redis

data/lib/redis/mutex.rb

@@ -1,134 +0,0 @@
-class Redis
-  #
-  # Options
-  #
-  # :block  => Specify in seconds how long you want to wait for the lock to be released. Speficy 0
-  #            if you need non-blocking sematics and return false immediately. (default: 1)
-  # :sleep  => Specify in seconds how long the polling interval should be when :block is given.
-  #            It is recommended that you do NOT go below 0.01. (default: 0.1)
-  # :expire => Specify in seconds when the lock should forcibly be removed when something went wrong
-  #            with the one who held the lock. (default: 10)
-  #
-  class Mutex < Redis::Classy
-    autoload :Macro, 'redis/mutex/macro'
-
-    DEFAULT_EXPIRE = 10
-    LockError = Class.new(StandardError)
-    UnlockError = Class.new(StandardError)
-    AssertionError = Class.new(StandardError)
-
-    def initialize(object, options={})
-      super(object.is_a?(String) || object.is_a?(Symbol) ? object : "#{object.class.name}:#{object.id}")
-      @block = options[:block] || 1
-      @sleep = options[:sleep] || 0.1
-      @expire = options[:expire] || DEFAULT_EXPIRE
-    end
-
-    def lock
-      self.class.raise_assertion_error if block_given?
-      @locking = false
-
-      if @block > 0
-        # Blocking mode
-        start_at = Time.now
-        while Time.now - start_at < @block
-          @locking = true and break if try_lock
-          sleep @sleep
-        end
-      else
-        # Non-blocking mode
-        @locking = try_lock
-      end
-      @locking
-    end
-
-    def try_lock
-      now = Time.now.to_f
-      @expires_at = now + @expire                       # Extend in each blocking loop
-
-      loop do
-        return true if setnx(@expires_at)               # Success, the lock has been acquired
-      end until old_value = get                         # Repeat if unlocked before get
-
-      return false if old_value.to_f > now              # Check if the lock is still effective
-
-      # The lock has expired but wasn't released... BAD!
-      return true if getset(@expires_at).to_f <= now    # Success, we acquired the previously expired lock
-      return false # Dammit, it seems that someone else was even faster than us to remove the expired lock!
-    end
-
-    # Returns true if resource is locked. Note that nil.to_f returns 0.0
-    def locked?
-      get.to_f > Time.now.to_f
-    end
-
-    def unlock(force = false)
-      # Since it's possible that the operations in the critical section took a long time,
-      # we can't just simply release the lock. The unlock method checks if @expires_at
-      # remains the same, and do not release when the lock timestamp was overwritten.
-
-      if get == @expires_at.to_s or force
-        # Redis#del with a single key returns '1' or nil
-        !!del
-      else
-        false
-      end
-    end
-
-    def with_lock
-      if lock!
-        begin
-          @result = yield
-        ensure
-          unlock
-        end
-      end
-      @result
-    end
-
-    def lock!
-      lock or raise LockError, "failed to acquire lock #{key.inspect}"
-    end
-
-    def unlock!(force = false)
-      unlock(force) or raise UnlockError, "failed to release lock #{key.inspect}"
-    end
-
-    class << self
-      def sweep
-        return 0 if (all_keys = keys).empty?
-
-        now = Time.now.to_f
-        values = mget(*all_keys)
-
-        expired_keys = all_keys.zip(values).select do |key, time|
-          time && time.to_f <= now
-        end
-
-        expired_keys.each do |key, _|
-          # Make extra sure that anyone haven't extended the lock
-          del(key) if getset(key, now + DEFAULT_EXPIRE).to_f <= now
-        end
-
-        expired_keys.size
-      end
-
-      def lock(object, options = {})
-        raise_assertion_error if block_given?
-        new(object, options).lock
-      end
-
-      def lock!(object, options = {})
-        new(object, options).lock!
-      end
-
-      def with_lock(object, options = {}, &block)
-        new(object, options).with_lock(&block)
-      end
-
-      def raise_assertion_error
-        raise AssertionError, 'block syntax has been removed from #lock, use #with_lock instead'
-      end
-    end
-  end
-end

data/lib/redis/mutex/macro.rb

@@ -1,58 +0,0 @@
-class Redis
-  class Mutex
-    module Macro
-      def self.included(base)
-        base.extend ClassMethods
-        base.class_eval do
-          class << self
-            attr_accessor :auto_mutex_methods
-          end
-          @auto_mutex_methods = {}
-        end
-      end
-
-      module ClassMethods
-        def auto_mutex(target, options={})
-          self.auto_mutex_methods[target] = options
-        end
-
-        def method_added(target)
-          return if target.to_s =~ /^auto_mutex_methods/
-          return unless self.auto_mutex_methods[target]
-          without_method  = "#{target}_without_auto_mutex"
-          with_method     = "#{target}_with_auto_mutex"
-          after_method    = "#{target}_after_failure"
-          return if method_defined?(without_method)
-          options = self.auto_mutex_methods[target]
-
-          if options[:after_failure].is_a?(Proc)
-            define_method(after_method, &options[:after_failure])
-          end
-          target_argument_names = instance_method(target.to_sym).parameters.map(&:last)
-          on_arguments = Array(options[:on])
-          mutex_arguments = on_arguments & target_argument_names
-          unknown_arguments = on_arguments - target_argument_names
-          if unknown_arguments.any?
-            raise ArgumentError, "You are trying to lock on unknown arguments: #{unknown_arguments.join(', ')}"
-          end
-
-          define_method(with_method) do |*args|
-            named_arguments =  Hash[target_argument_names.zip(args)]
-            arguments  = mutex_arguments.map { |name| named_arguments.fetch(name) }
-            key = self.class.name << '#' << target.to_s << ":" << arguments.join(':')
-            begin
-              Redis::Mutex.with_lock(key, options) do
-                send(without_method, *args)
-              end
-            rescue Redis::Mutex::LockError
-              send(after_method, *args) if respond_to?(after_method)
-            end
-          end
-
-          alias_method without_method, target
-          alias_method target, with_method
-        end
-      end
-    end
-  end
-end