mario-redis-lock 1.0.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2853868a970109fa52abc01236f6107c2d4dbded
-  data.tar.gz: 6cdecec78e8585b1b24c142100d80900a75ea16e
+  metadata.gz: e1f96fb381f15d6699a71780455f6328569d67f3
+  data.tar.gz: 059591adc0ec6438f6d8c9990f16b8bf027aee7b
 SHA512:
-  metadata.gz: 48204bca5b65a3073ccbfe5edbf54a71424388381daf698c8ecc11689496063fe5039d41acbe222d4e1d6d87cb13bdab692db1911aa47a939da061518fedd3b6
-  data.tar.gz: ee01cdf3e836303897dd3c459ca0e6ec6b07979358c75115025c26c254fc1816d7472dda43873e33ef212c9589499d97f57788936430b6d8229ac741dc64db4b
+  metadata.gz: 6c907b7305b4c0470d50559cae339764b9d5d825ea115c251971604b734b27d11e30bdae9b0a79aabc5629bff40d4dadfbcd7f203bf1c4c14aa903515b722031
+  data.tar.gz: 4b9290554e5061faeb847a6137f891396f1e6e99964e2bffd6376fe61369626f02ca6b722d53eee1090c365f3bdd6b4fc848fee73028ec50c9d0247f30e7a95d

data/EXAMPLE_BEER_WAITER.md

@@ -0,0 +1,46 @@
+## Example: Beer Waiter
+
+In this game, everybody wants a beer but there is only one waiter to attend. Each thread is a thirsty customer, and the Redis lock is the waiter.
+
+This example can be copy-pasted, just make sure you have redis in localhost (default `Redis.new` instance) and the mario-redis-lock gem installed.
+
+```ruby
+require 'redis_lock'
+
+N = 15 # how many people in the bar
+puts "Starting with #{N} new thirsty customers ..."
+puts
+
+RedisLock.configure do |conf|
+  conf.retry_sleep = 1    # call the waiter every second
+  conf.retry_timeout = 10 # wait up to 10 seconds before giving up
+  conf.autorelease = 3    # the waiter will wait a maximun of 3 seconds to be "released" before giving the lock to someone else
+end
+
+# Code for a single Thread#i
+def try_to_get_a_drink(i)
+  name = "Thread##{i}"
+  RedisLock.acquire do |lock|
+    if lock.acquired?
+      puts "<< #{name} gets barman's attention (lock acquired)"
+      sleep 0.2 # time do decide
+      beer = %w(lager pale_ale ipa stout sour)[rand 5]
+      puts ".. #{name} orders a #{beer}"
+      sleep 0.4 # time for the waiter to serve the beer
+      puts ">> #{name} takes the #{beer} and leaves happy :)"
+      puts
+    else
+      puts "!! #{name} is bored of waiting and leaves angry (timeout)"
+    end
+  end
+end
+
+# Start N threads that will be executed in parallel
+threads = []
+N.times(){|i| threads << Thread.new(){ try_to_get_a_drink(i) }}
+threads.each{|thread| thread.join} # do not exit until all threads are done
+
+puts "DONE"
+```
+
+It uses threads for concurrency, but you can also execute this script from different places at the same time in parallel, they share the same lock as far as they use the same Redis instance.

data/EXAMPLE_DOG_PILE_EFFECT.md

@@ -0,0 +1,113 @@
+## Example: Avoid the Dog-Pile effec when invalidating some cached value
+
+The Dog-Pile effect is a specific case of the [Thundering Herd problem](http://en.wikipedia.org/wiki/Thundering_herd_problem),
+that happens when a cached value expires and suddenly too many threads try to calculate the new value at the same time.
+
+Sometimes, the calculation takes expensive resources and it is just fine to do it from just one thread.
+
+Assume you have a simple cache, a `fetch` function that uses a redis instance.
+
+Without the lock:
+
+```ruby
+# Retrieve the cached value from the redis key.
+# If the key is not available, execute the block
+# and store the new calculated value in the redis key with an expiration time.
+def fetch(redis, key, expire, &block)
+  redis.get(key) or (
+    val = block.call
+    redis.setex(key, expire, val) if val
+    val
+  )
+end
+```
+
+Whith this method, it is easy to optimize slow operations by caching them in Redis.
+For example, if you want to do a `heavy_database_query`:
+
+```ruby
+require 'redis'
+redis = Redis.new(url: "redis://:p4ssw0rd@host:6380")
+expire = 60 # keep the result cached for 1 minute
+key = 'heavy_query'
+
+val = fetch redis, key, expire do
+  heavy_database_query # Recalculate if not cached (SLOW)
+end
+
+puts val
+```
+
+But this fetch could block the database if executed from too many threads, because when the Redis key expires all of them will do the same "heavy_database_query" at the same time.
+
+To avoid this problem, you can make a `fetch_with_lock` method using a `RedisLock`:
+
+```ruby
+# Retrieve the cached value from the redis key.
+# If the key is not available, execute the block
+# and store the new calculated value in the redis key with an expiration time.
+# The block is executed with a RedisLock to avoid the dog pile effect.
+# Use the following options:
+#   * :retry_timeout => (default 10) Seconds to stop trying to get the value from redis or the lock.
+#   * :retry_sleep => (default 0.1) Seconds to sleep (block the process) between retries.
+#   * :lock_autorelease => (default same as :retry_timeout) Maximum time in seconds to execute the block. The lock is released after this, assuming that the process failed.
+#   * :lock_key => (default "#{key}_lock") The key used for the lock.
+def fetch_with_lock(redis, key, expire, opts={}, &block)
+  # Options
+  opts[:retry_timeout] ||= 10
+  opts[:retry_sleep] ||= 0.1
+  opts[:first_try_time] ||= Time.now # used as memory for next retries
+  opts[:lock_key] ||= "#{key}_lock"
+  opts[:lock_autorelease] ||= opts[:retry_timeout]
+
+  # Try to get from redis.
+  val = redis.get(key)
+  return val if val
+
+  # If not in redis, calculate the new value (block.call), but with a RedisLock.
+  RedisLock.acquire({
+    redis: redis,
+    key: opts[:lock_key],
+    autorelease: opts[:lock_autorelease],
+    retry: false,
+  }) do |lock|
+    if lock.acquired?
+      val = block.call # execute block, load/calculate heavy stuff
+      redis.setex(key, expire, val) if val # store in the redis cache
+    end
+  end
+  return val if val
+
+  # If the lock was not available, then someone else was already re-calculating the value.
+  # Just wait a little bit and try again.
+  if (Time.now - opts[:first_try_time]) < opts[:retry_timeout] # unless timed out
+    sleep opts[:retry_sleep]
+    return fetch_with_lock(redis, key, expire, opts, &block)
+  end
+
+  # If the lock is still unavailable after the timeout, desist and return nil.
+  nil
+end
+
+```
+
+Now with this new method, is easy to do the "heavy_database_query", cached in redis and with a lock:
+
+
+```ruby
+require 'redis'
+require 'redis_lock'
+redis = Redis.new(url: "redis://:p4ssw0rd@host:6380")
+expire = 60 # keep the result cached for 1 minute
+key = 'heavy_query'
+
+val = fetch_with_lock redis, key, expire, retry_timeout: 10, retry_sleep: 1 do
+  heavy_database_query # Recalculate if not cached (SLOW)
+end
+
+puts val
+```
+
+In this case, the script could be executed from as many threads as we want at the same time, because the "heavy_database_query" is done only once while the other threads wait until the value is cached again or the lock is released.
+
+

data/README.md

@@ -1,13 +1,18 @@
 # RedisLock
 
-Yet another distributed lock for Ruby using Redis, with emphasis in the documentation.
+Yet another Ruby distributed lock using Redis, with emphasis in transparency.
 
+Implements the locking algorithm described in the [Redis SET command documentation](http://redis.io/commands/set):
 
-## Why another redis lock gem?
+  * Acquire lock with `SET {{key}} {{uuid_token}} NX PX {{ms_to_expire}}`
+  * Release lock with `EVAL "if redis.call('get',KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) else return nil end" {{key}} {{uuid_token}}`
+  * Auto release lock if expires
 
-Other redis locks for ruby: [redis-mutex](https://rubygems.org/gems/redis-mutex), [mlanett-redis-lock](https://rubygems.org/gems/mlanett-redis-lock), [redis-lock](https://rubygems.org/gems/redis-lock), [jashmenn-redis-lock](https://rubygems.org/gems/jashmenn-redis-lock), [ruby_redis_lock](https://rubygems.org/gems/ruby_redis_lock), [robust-redis-lock](https://rubygems.org/gems/robust-redis-lock), [bfg-redis-lock](https://rubygems.org/gems/bfg-redis-lock), etc.
+It has the properties:
 
-Looking at those other gems I realized that it was not easy to know what was exactly going on with the locks. Then I made this one to be simple but explicit, to be used with confidence in my high scale production applications.
+  * Mutual exclusion: At any given moment, only one client can hold a lock
+  * Deadlock free: Eventually it is always possible to acquire a lock, even if the client that locked a resource crashed or gets partitioned
+  * NOT fault tolerant: if the REDIS instance goes down, the lock doesn't work. For a lock wiht liveness guarantee, see [redlock-rb](https://github.com/antirez/redlock-rb), that can use multiple REDIS instances to handle the lock.
 
 
 ## Installation
@@ -17,7 +22,7 @@ Requirements:
   * [Redis](http://redis.io/) >= 2.6.12
   * [redis gem](https://rubygems.org/gems/redis) >= 3.0.5
 
-The required versions are needed for the new syntax of the SET command, to easily implement the robust locking algorithm described in the [SET command documentation](http://redis.io/commands/set).
+The required versions are needed for the new syntax of the SET command (using NX and EX/PX).
 
 Install from RubyGems:
 
@@ -30,14 +35,14 @@ Or include it in your project's `Gemfile` with Bundler:
 
 ## Usage
 
-Acquire the lock to do "exclusive stuff":
+Acquire the lock to `do_exclusive_stuff`:
 
 ```ruby
-RedisLock.adquire do |lock|
+RedisLock.acquire do |lock|
   if lock.acquired?
-    do_exclusive_stuff # you are the one with the lock, hooray!
+    do_exclusive_stuff # you are the only process with the lock, hooray!
   else
-    oh_well # someone else has the lock
+    oh_well # timeout, some other process has the lock and didn't release it before the retry_timeout
   end
 end
 ```
@@ -49,42 +54,31 @@ Or (equivalent)
 lock = RedisLock.new
 if lock.acquire
   begin
-    do_exclusive_stuff # you are the one with the lock, hooray!
+    do_exclusive_stuff # you are the only process with the lock, hooray!
   ensure
     lock.release
   end
 else
-  oh_well # someone else has the lock
+  oh_well # timeout, some other process has the lock and didn't release it before the retry_timeout
 end
 ```
 
-The class method `RedisLock.adquire(options, &block)` is more concise and releases the lock at the end of the block, even if `do_exclusive_stuff` raises an exception.
-But the second alternative is a little more flexible.
+The class method `RedisLock.acquire(options, &block)` is more concise and releases the lock at the end of the block, even if `do_exclusive_stuff` raises an exception.
+The second alternative is a little more flexible.
+
+#### Detailed Usage Examples
 
+  * [Beer Waiter](EXAMPLE_BEER_WAITER.md): Run many threads at the same time, all them try to get a beer in 3 seconds using the same lock. Some will get it, some will timeout.
+  * [Dog Pile Effect](EXAMPLE_DOG_PILE_EFFECT.md): See how to implement a `fetch_with_lock` method, that works like most `Cache.fetch(key, &block)` methods out there (if value is cached in that given key, return the cached value, otherwise run the block), but only executes the block from one of the processes that share that cache, avoiding the case when the cache is invalidated and all processes execute an expensive operation at the same time.
 
 ### Options
 
   * **redis**: (default `Redis.new`) an instance of Redis, or an options hash to initialize an instance of Redis (see [redis gem](https://rubygems.org/gems/redis)). You can also pass anything that "quaks" like redis, for example an instance of [mock_redis](https://rubygems.org/gems/mock_redis), for testing purposes.
   * **key**: (default `"RedisLock::default"`) Redis key used for the lock. If you need multiple locks, use a different (unique) key for each lock.
   * **autorelease**: (default `10.0`) seconds to automatically release (expire) the lock after being acquired. Make sure to give enough time for your "exclusive stuff" to be executed, otherwise other processes could get the lock and start messing with the "exclusive stuff" before this one is done. The autorelease time is important, even when manually doing `lock.realease`, because the process could crash before releasing the lock. Autorelease (expiration time) guarantees that the lock will always be released.
-  * **retry**: (default `true`) boolean to enable/disable consecutive acquire retries in the same `acquire` call. If true, use `retry_timeout` and `retry_sleep` to specify how long and hot often should the `acquire` method be blocking the thread until is able to get the lock.
-  * **retry_timeout**: (default `10.0`) time in seconds to specify how long should this thread be waiting for the lock to be released. Note that the execution thread is put to sleep while waiting. For a non-blocking approach, set `retry` to false.
-  * **retry_sleep**: (default `0.1`) seconds to sleep between retries. For example: `RedisLock.adquire(retry_timeout: 10.0, retry_sleep: 0.1) do |lock|`, in the worst case scenario, will do 99 or 100 retries (one every 100 milliseconds, plus a little extra for the acquire attempt) during 10 seconds, and finally yield with `lock.acquired? == false`.
-
-Configure the default values with `RedisLock.configure`:
-
-```ruby
-RedisLock.configure do |defaults|
-  defaults.redis = Redis.new
-  defaults.key = "RedisLock::default"
-  defaults.autorelease = 10.0
-  defaults.retry = true
-  defaults.retry_timeout = 10.0
-  defaults.retry_sleep = 0.1
-end
-```
-
-A good place to set defaults in a Rails app would be in an initializer `conf/initializers/redis_lock.rb`.
+  * **retry**: (default `true`) boolean to enable/disable consecutive acquire retries in the same `acquire` call. If true, use `retry_timeout` and `retry_sleep` to specify how long and how often should the `acquire` method block the thread (sleep) until able to get the lock.
+  * **retry_timeout**: (default `10.0`) seconds before giving up before the lock is released. Note that the execution thread is put to sleep while waiting. For a non-blocking approach, set `retry` to false.
+  * **retry_sleep**: (default `0.1`) seconds to sleep between retries. For example: `RedisLock.acquire(retry_timeout: 10.0, retry_sleep: 0.1){|lock| ... }` if the lock was acquired by other process and never released, will do almost 100 retries (a rerty every 0.1 seconds, plus a little extra to run the the `SET` command) during 10 seconds, and finally yield with `lock.acquired? == false`.
 
 Options can be set to other than the defaults when calling `RedisLock.acquire`:
 
@@ -99,127 +93,34 @@ end
 Or when creating a new lock instance:
 
 ```ruby
-lock = RedisLock.new(key: 'exclusive_stuff', retry: false)
+lock = RedisLock.new(key: 'exclusive_stuff', retry: false, autorelease: 0.1)
 if lock.acquire
-  begin
-    do_exclusive_stuff
-  ensure
-    lock.release
-  end
+  do_exclusive_stuff_or_not
 end
 ```
 
-### Example: Shared Photo Booth that can only take one photo at a time
-
-If we have a `PhotoBooth` shared resource, we can use a `RedisLock` to ensure it is used only by one thread at a time:
+You can also configure default values with `RedisLock.configure`:
 
 ```ruby
-require 'redis_lock'
-require 'photo_booth' # made up shared resource
-
-RedisLock.configure do |c|
-  c.redis = {url: "redis://:p4ssw0rd@10.0.1.1:6380/15"}
-  c.key   = 'photo_booth_lock'
-
-  c.autorelease   = 60 # assume it never takes more than one minute to make a picture
-  c.retry_timeout = 300 # retry for 5 minutes
-  c.retry_sleep   = 1   # retry once every second
-end
-
-RedisLock.acquire do |lock|
-  if lock.acquired?
-    PhotoBooth.take_photo
-  else
-    raise "I'm bored of waiting and I'm getting out"
-  end
-end
-```
-
-This script can be executed from many different places at the same time, as far as they have access to the shared PhotoBooth and Redis instances. Only one photo will be taken at a time.
-Note that the options `autorelease`, `retry_timeout` and `retry_sleep` should be tuned differently depending on the frequency of the operation and the known speed of the `PhotoBooth.take_photo` operation.
-
-
-### Example: Avoid the Dog-Pile effec when invalidating some cached value
-
-The Dog-Pile effect is a specific case of the [Thundering Herd problem](http://en.wikipedia.org/wiki/Thundering_herd_problem),
-that happens when a cached value expires and suddenly too many threads try to calculate the new value at the same time.
-
-Sometimes, the calculation takes expensive resources and it is just fine to do it from just one thread.
-
-Assume you have a simple cache, a `fetch` function that uses a redis instance.
-
-Without the lock:
-
-```ruby
-# Retrieve the cached value from the redis key.
-# If the key is not available, execute the block
-# and store the new calculated value in the redis key with an expiration time.
-def fetch(redis, key, expire, &block)
-  val = redis.get(key)
-  if not val
-    val = block.call
-    redis.setex(key, expire, val) unless val.nil? # do not set anything if the value is nil
-  end
-  val
-end
-```
-
-Whith this method, it is easy to optimize slow operations by caching them in Redis.
-For example, if you want to do a `heavy_database_query`:
-
-```ruby
-require 'redis'
-redis = Redis.new(url: "redis://:p4ssw0rd@host:6380")
-
-val = fetch redis, 'heavy_query', 10 do
-  heavy_database_query # Recalculate if not cached (SLOW)
+RedisLock.configure do |defaults|
+  defaults.redis = Redis.new
+  defaults.key = "RedisLock::default"
+  defaults.autorelease = 10.0
+  defaults.retry = true
+  defaults.retry_timeout = 10.0
+  defaults.retry_sleep = 0.1
 end
-
-puts val
 ```
 
-But this fetch could block the database if executed from too many threads, because when the Redis key expires all of them will do the `heavy_database_query` at the same time.
-
-Avoid this problem with a `RedisLock`:
-
-```ruby
-require 'redis'
-require 'redis_lock'
-redis = Redis.new(url: "redis://:p4ssw0rd@host:6380")
-
-RedisLock.configure do |c|
-  c.redis = redis
-  c.key = 'heavy_query_lock'
-  c.autorelease = 20 # assume it never takes more than 20 seconds to do the slow query
-  c.retry = false # try to acquire only once, if the lock is already taken then the new value should be cached again soon
-end
+A good place to set defaults in a Rails app would be in an initializer like `conf/initializers/redis_lock.rb`.
 
-def fetch_with_lock(retries = 10)
-  val = fetch redis, 'heavy_query', 10 do
-    # If we need to recalculate val,
-    # use a lock to make sure that heavy_database_query is only done by one process
-    RedisLock.acquire do |lock|
-      if lock.acquired?
-        heavy_database_query
-      else
-        nil # do not store in cache and return val = nil
-      end
-    end
-  end
 
-  # Try again if cache miss, and the lock was acquired by other process.
-  if val.nil? and retries > 0
-    fetch_with_lock(retries - 1)
-  else
-    val
-  end
-end
+## Why another Redis lock gem?
 
-val = fetch_with_lock()
-puts val
-```
+There are other Redis locks for Ruby: [redlock-rb](https://github.com/antirez/redlock-rb), [redis-mutex](https://rubygems.org/gems/redis-mutex), [mlanett-redis-lock](https://rubygems.org/gems/mlanett-redis-lock), [redis-lock](https://rubygems.org/gems/redis-lock), [jashmenn-redis-lock](https://rubygems.org/gems/jashmenn-redis-lock), [ruby_redis_lock](https://rubygems.org/gems/ruby_redis_lock), [robust-redis-lock](https://rubygems.org/gems/robust-redis-lock), [bfg-redis-lock](https://rubygems.org/gems/bfg-redis-lock), etc.
 
-In this case, the script could be executed from as many threads as we want at the same time, because the heavy_database_query is done only once while the other threads wait until the value is cached again or the lock is released.
+I realized I was not sure how most of them exactly work. What is exactly going on with the lock? When does it expire? How many times needs to retry? Is the thread put to sleep meanwhile?.
+By the time I learned how to tell if a lock is good or not, I learned enough to write my own, making it simple but explicit, to be used with confidence in my high scale production applications.
 
 
 ## Contributing
@@ -232,3 +133,4 @@ In this case, the script could be executed from as many threads as we want at th
 
 Make sure you have installed Redis in localhost:6379. The DB 15 will be used for tests (and flushed after every test).
 There is a rake task to play with an example: `rake smoke_and_pass`
+

data/lib/redis_lock.rb

@@ -4,7 +4,7 @@ require 'securerandom' # SecureRandom (from stdlib)
 class RedisLock
 
   # Gem version
-  VERSION = "1.0.1"
+  VERSION = "1.2.0"
 
   # Original defaults
   DEFAULT_ATTRS = {
@@ -37,15 +37,18 @@ class RedisLock
   # Acquire a lock. Use options to override defaults.
   # This method makes sure to release the lock as soon as the block is finalized.
   def self.acquire(opts={}, &block)
+    if block.arity != 1
+      raise ArgumentError.new('Expected lock parameter in block. Example: RedisLock.acquire(opts){|lock| do_stuff if lock.acquired? }')
+    end
     lock = RedisLock.new(opts)
     if lock.acquire
       begin
-        block.call(lock)
+        block.call(lock) # lock.acquired? => true
       ensure
-        lock.release
+        lock.release # Exception => release early
       end
     else
-      block.call(lock)
+      block.call(lock) # lock.acquired? => false
     end
   end
 
@@ -58,11 +61,12 @@ class RedisLock
     # Set attributes from options or defaults
     self.redis = opts[:redis] || @@config.redis || Redis.new
     self.redis = Redis.new(redis) if redis.is_a? Hash # allow to use Redis options instead of a redis instance
-    self.key           = opts[:key] || @@config.key
-    self.autorelease   = opts[:autorelease] || @@config.autorelease
+
+    self.key           = opts[:key]           || @@config.key
+    self.autorelease   = opts[:autorelease]   || @@config.autorelease
     self.retry         = opts.include?(:retry) ? opts[:retry] : @@config.retry
     self.retry_timeout = opts[:retry_timeout] || @@config.retry_timeout
-    self.retry_sleep   = opts[:retry_sleep] || @@config.retry_sleep
+    self.retry_sleep   = opts[:retry_sleep]   || @@config.retry_sleep
   end
 
   # Try to acquire the lock.

data/mario-redis-lock.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.version       = RedisLock::VERSION
   spec.authors       = ["Mario Izquierdo"]
   spec.email         = ["tomario@gmail.com"]
-  spec.summary       = %q{Yet another distributed lock for Ruby using Redis.}
-  spec.description   = %q{Yet another distributed lock for Ruby using Redis, with emphasis in the documentation. Requires Redis >= 2.6.12, because it uses the new syntax for SET to easily implement the robust algorithm described in the SET command documentation (http://redis.io/commands/set).}
+  spec.summary       = %q{Yet another Ruby distributed lock using Redis, with emphasis in transparency.}
+  spec.description   = %q{Yet another Ruby distributed lock using Redis, with emphasis in transparency. Requires Redis >= 2.6.12, because it uses the new syntax for SET to easily implement the robust algorithm described in the SET command documentation (http://redis.io/commands/set).}
   spec.homepage      = "https://github.com/marioizquierdo/mario-redis-lock"
   spec.license       = "MIT"
 
@@ -19,8 +19,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency 'redis', '>= 3.0.5' # Needed support for SET with EX, PX, NX, XX options: https://github.com/redis/redis-rb/pull/343
+  spec.add_runtime_dependency 'redis', '~> 3', '>= 3.0.5' # Needed support for SET with EX, PX, NX, XX options: https://github.com/redis/redis-rb/pull/343
 
-  spec.add_development_dependency "bundler", "~> 1.5"
-  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'bundler', '~> 1'
+  spec.add_development_dependency 'rake', '~> 10'
 end

data/spec/redis_lock_spec.rb

@@ -28,7 +28,7 @@ describe RedisLock do
   end
 
 
-  describe "configure" do
+  describe ".configure" do
     it "changes the defaults" do
       RedisLock.configure do |conf|
         conf.key = "mykey"
@@ -53,10 +53,12 @@ describe RedisLock do
     end
   end
 
-  describe "acquire" do
+  describe ".acquire" do
     describe "with bad redis connection" do
       it "raises a Redis::CannotConnectError" do
-        proc { RedisLock.acquire(redis: {url: "redis://localhost:1111/15"}){|l| }}.must_raise Redis::CannotConnectError
+        proc {
+          RedisLock.acquire(redis: {url: "redis://localhost:1111/15"}){|lock| }
+        }.must_raise Redis::CannotConnectError
       end
     end
 
@@ -82,6 +84,11 @@ describe RedisLock do
         lock.autorelease.must_equal 5555
       end
     end
+    it "does not allow to pass a block with no |lock|" do
+      proc {
+        RedisLock.acquire(){ puts "I should not have been printed" }
+      }.must_raise ArgumentError, "You should use lock"
+    end
   end
 
   describe "initialize" do

metadata

@@ -1,68 +1,75 @@
 --- !ruby/object:Gem::Specification
 name: mario-redis-lock
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Mario Izquierdo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-23 00:00:00.000000000 Z
+date: 2016-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.5
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: Yet another distributed lock for Ruby using Redis, with emphasis in the
-  documentation. Requires Redis >= 2.6.12, because it uses the new syntax for SET
-  to easily implement the robust algorithm described in the SET command documentation
-  (http://redis.io/commands/set).
+        version: '10'
+description: Yet another Ruby distributed lock using Redis, with emphasis in transparency.
+  Requires Redis >= 2.6.12, because it uses the new syntax for SET to easily implement
+  the robust algorithm described in the SET command documentation (http://redis.io/commands/set).
 email:
 - tomario@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
+- EXAMPLE_BEER_WAITER.md
+- EXAMPLE_DOG_PILE_EFFECT.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -80,19 +87,19 @@ 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.4.5
 signing_key: 
 specification_version: 4
-summary: Yet another distributed lock for Ruby using Redis.
+summary: Yet another Ruby distributed lock using Redis, with emphasis in transparency.
 test_files:
 - spec/redis_lock_spec.rb