lock_and_cache 4.0.4 → 6.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4a3eaf745d9a9532d2062ea332fb63420fabbdd9
-  data.tar.gz: d1f4ec88da5e0f728da43d9b2f40d536c4224498
+SHA256:
+  metadata.gz: c89613cc8fdd7ed23861149ccfc49e664af988d6b917757f09c18b18b5415f0b
+  data.tar.gz: 286efd9473fedfbd8e7de5175d9a4ec374bde72757d103bd9c964faa6af1bc70
 SHA512:
-  metadata.gz: f34529d617b048841b0d33234619846f49a7367ff5627e653298098f0780401314f37df6aa9afe73d967ad358eeaffc3fd0d70ccbc043ecb6a8c1b360c2b61f7
-  data.tar.gz: d006e7f9e798425f6137d5611c3688b3e78fd906e15390ad0ff015f0834f3fd3e9a4d820c4ca546fa606f17f9ea481296d7f444dc0189cb48b4e368643251648
+  metadata.gz: 15f13a8204942588e436ddd5a0eec963148d179a10bf3268401316b8479f2857f50e5e83a47d324765c57f614c7e11b2656b7643c139ebbce6e6b67f1c2969ba
+  data.tar.gz: 28d901547a8b96a9065514151149176eef91c5ed9fb76274b7a7e655bba4f8f584b6246e20534342022ae1bddbfe4918cbe73cedcb7936fa886962b117c698bd

data/.travis.yml

@@ -1,6 +1,7 @@
 language: ruby
 sudo: false
 rvm:
-  - 2.1.2
+  - 2.3.0
+  - 2.4.1
 services:
   - redis-server

data/CHANGELOG

@@ -1,3 +1,40 @@
+6.0.1
+
+* Enhancements
+
+  * Use Redis#exists? to avoid deprec warning
+
+6.0.0
+
+* Breaking changes
+
+  * Set lock_storage and cache_storage separately
+
+5.0.0
+
+* Enhancements / breaking changes
+
+  * Propagate errors to all waiters up to 1 second after the error
+  * Stop using redlock, just use plain single-node Redis locking
+
+4.0.6
+
+* ?
+
+  * Don't test on ruby 2.1
+
+* Enhancements
+
+  * LockAndCache.cached?(*key_parts) to check if a value is cached
+
+4.0.5 / 2017-04-01
+
+* Enhancements
+
+  * allow dates and times in keys
+  * Test on ruby 2.3.0 and 2.4.1
+  * 2x faster key generation
+
 4.0.4 / 2016-04-11
 
 * Bug fixes

data/README.md

@@ -2,7 +2,6 @@
 
 [![Build Status](https://travis-ci.org/seamusabshere/lock_and_cache.svg?branch=master&v=2.2.0)](https://travis-ci.org/seamusabshere/lock_and_cache)
 [![Code Climate](https://codeclimate.com/github/seamusabshere/lock_and_cache/badges/gpa.svg?v=2.2.0)](https://codeclimate.com/github/seamusabshere/lock_and_cache)
-[![Dependency Status](https://gemnasium.com/seamusabshere/lock_and_cache.svg?v=2.2.0)](https://gemnasium.com/seamusabshere/lock_and_cache)
 [![Gem Version](https://badge.fury.io/rb/lock_and_cache.svg?v=2.2.0)](http://badge.fury.io/rb/lock_and_cache)
 [![Security](https://hakiri.io/github/seamusabshere/lock_and_cache/master.svg?v=2.2.0)](https://hakiri.io/github/seamusabshere/lock_and_cache/master)
 [![Inline docs](http://inch-ci.org/github/seamusabshere/lock_and_cache.svg?branch=master&v=2.2.0)](http://inch-ci.org/github/seamusabshere/lock_and_cache)
@@ -14,7 +13,8 @@ Most caching libraries don't do locking, meaning that >1 process can be calculat
 ## Quickstart
 
 ```ruby
-LockAndCache.storage = Redis.new
+LockAndCache.lock_storage = Redis.new db: 3
+LockAndCache.cache_storage = Redis.new db: 4
 
 LockAndCache.lock_and_cache(:stock_price, {company: 'MSFT', date: '2015-05-05'}, expires: 10, nil_expires: 1) do
   # get yer stock quote
@@ -27,9 +27,9 @@ end
 
 ## Sponsor
 
-<p><a href="http://faraday.io"><img src="http://cdn2.hubspot.net/hubfs/515497/img/logo.svg" alt="Faraday logo"/></a></p>
+<p><a href="https://www.faraday.io"><img src="https://s3.amazonaws.com/faraday-assets/files/img/logo.svg" alt="Faraday logo"/></a></p>
 
-We use [`lock_and_cache`](https://github.com/seamusabshere/lock_and_cache) for [data-driven marketing at Faraday](http://faraday.io).
+We use [`lock_and_cache`](https://github.com/seamusabshere/lock_and_cache) for [B2C customer intelligence at Faraday](https://www.faraday.io).
 
 ## TOC
 
@@ -70,21 +70,24 @@ We use [`lock_and_cache`](https://github.com/seamusabshere/lock_and_cache) for [
 
 As you can see, most caching libraries only take care of (1) and (4) (well, and (5) of course).
 
+If an error is raised during calculation, that error is propagated to all waiters for 1 second.
+
 ## Practice
 
 ### Setup
 
 ```ruby
-LockAndCache.storage = Redis.new
+LockAndCache.lock_storage = Redis.new db: 3
+LockAndCache.cache_storage = Redis.new db: 4
 ```
 
 It will use this redis for both locking and storing cached values.
 
 ### Locking
 
-Based on [antirez's Redlock algorithm](http://redis.io/topics/distlock).
+Just uses Redis naive locking with NX.
 
-Above and beyond Redlock, a 32-second heartbeat is used that will clear the lock if a process is killed. This is implemented using lock extensions.
+A 32-second heartbeat is used that will clear the lock if a process is killed.
 
 ### Caching
 
@@ -189,7 +192,7 @@ Most caching libraries don't do locking, meaning that >1 process can be calculat
 
 ### Heartbeat
 
-If the process holding the lock dies, we automatically remove the lock so somebody else can do it (using heartbeats and redlock extends).
+If the process holding the lock dies, we automatically remove the lock so somebody else can do it (using heartbeats).
 
 ### Context mode
 
@@ -203,14 +206,14 @@ You can expire nil values with a different timeout (`nil_expires`) than other va
 
 ## Tunables
 
-* `LockAndCache.storage=[redis]`
+* `LockAndCache.lock_storage=[redis]`
+* `LockAndCache.cache_storage=[redis]`
 * `ENV['LOCK_AND_CACHE_DEBUG']='true'` if you want some debugging output on `$stderr`
 
 ## Few dependencies
 
 * [activesupport](https://rubygems.org/gems/activesupport) (come on, it's the bomb)
 * [redis](https://github.com/redis/redis-rb)
-* [redlock](https://github.com/leandromoreira/redlock-rb)
 
 ## Known issues
 

data/benchmarks/allowed_in_keys.rb

@@ -0,0 +1,87 @@
+require 'set'
+require 'date'
+require 'benchmark/ips'
+
+ALLOWED_IN_KEYS = [
+  ::String,
+  ::Symbol,
+  ::Numeric,
+  ::TrueClass,
+  ::FalseClass,
+  ::NilClass,
+  ::Integer,
+  ::Float,
+  ::Date,
+  ::DateTime,
+  ::Time,
+].to_set
+parts = RUBY_VERSION.split('.').map(&:to_i)
+unless parts[0] >= 2 and parts[1] >= 4
+  ALLOWED_IN_KEYS << ::Fixnum
+  ALLOWED_IN_KEYS << ::Bignum  
+end
+
+EXAMPLES = [
+  'hi',
+  :there,
+  123,
+  123.54,
+  1e99,
+  123456789 ** 2,
+  1e999,
+  true,
+  false,
+  nil,
+  Date.new(2015,1,1),
+  Time.now,
+  DateTime.now,
+  Mutex,
+  Mutex.new,
+  Benchmark,
+  { hi: :world },
+  [[]],
+  Fixnum,
+  Struct,
+  Struct.new(:a),
+  Struct.new(:a).new(123)
+]
+EXAMPLES.each do |example|
+  puts "#{example} -> #{example.class}"
+end
+
+puts
+
+[
+  Date.new(2015,1,1),
+  Time.now,
+  DateTime.now,
+].each do |x|
+    puts x.to_s
+end
+
+puts
+
+EXAMPLES.each do |example|
+  a = ALLOWED_IN_KEYS.any? { |thing| example.is_a?(thing) }
+  b = ALLOWED_IN_KEYS.include? example.class
+  unless a == b
+    raise "#{example.inspect}: #{a.inspect} vs #{b.inspect}"
+  end
+end
+
+Benchmark.ips do |x|
+  x.report("any") do
+    example = EXAMPLES.sample
+    y = ALLOWED_IN_KEYS.any? { |thing| example.is_a?(thing) }
+    a = 1
+    y
+  end
+
+  x.report("include") do
+    example = EXAMPLES.sample
+    y = ALLOWED_IN_KEYS.include? example.class
+    a = 1
+    y
+  end
+
+end

data/lib/lock_and_cache.rb

@@ -3,7 +3,6 @@ require 'timeout'
 require 'digest/sha1'
 require 'base64'
 require 'redis'
-require 'redlock'
 require 'active_support'
 require 'active_support/core_ext'
 
@@ -21,16 +20,26 @@ module LockAndCache
 
   class TimeoutWaitingForLock < StandardError; end
 
-  # @param redis_connection [Redis] A redis connection to be used for lock and cached value storage
-  def LockAndCache.storage=(redis_connection)
+  # @param redis_connection [Redis] A redis connection to be used for lock storage
+  def LockAndCache.lock_storage=(redis_connection)
     raise "only redis for now" unless redis_connection.class.to_s == 'Redis'
-    @storage = redis_connection
-    @lock_manager = Redlock::Client.new [redis_connection], retry_count: 1
+    @lock_storage = redis_connection
   end
 
   # @return [Redis] The redis connection used for lock and cached value storage
-  def LockAndCache.storage
-    @storage
+  def LockAndCache.lock_storage
+    @lock_storage
+  end
+
+  # @param redis_connection [Redis] A redis connection to be used for cached value storage
+  def LockAndCache.cache_storage=(redis_connection)
+    raise "only redis for now" unless redis_connection.class.to_s == 'Redis'
+    @cache_storage = redis_connection
+  end
+
+  # @return [Redis] The redis connection used for cached value storage
+  def LockAndCache.cache_storage
+    @cache_storage
   end
 
   # @param logger [Logger] A logger.
@@ -43,13 +52,22 @@ module LockAndCache
     @logger
   end
 
-  # Flush LockAndCache's storage.
+  # Flush LockAndCache's cached value storage.
   #
   # @note If you are sharing a redis database, it will clear it...
   #
   # @note If you want to clear a single key, try `LockAndCache.clear(key)` (standalone mode) or `#lock_and_cache_clear(method_id, *key_parts)` in context mode.
-  def LockAndCache.flush
-    storage.flushdb
+  def LockAndCache.flush_cache
+    cache_storage.flushdb
+  end
+
+  # Flush LockAndCache's lock storage.
+  #
+  # @note If you are sharing a redis database, it will clear it...
+  #
+  # @note If you want to clear a single key, try `LockAndCache.clear(key)` (standalone mode) or `#lock_and_cache_clear(method_id, *key_parts)` in context mode.
+  def LockAndCache.flush_locks
+    lock_storage.flushdb
   end
 
   # Lock and cache based on a key.
@@ -83,6 +101,14 @@ module LockAndCache
     key.locked?
   end
 
+  # Check if a key is cached already
+  #
+  # @note Standalone mode. See also "context mode," where you mix LockAndCache into a class and call it from within its methods.
+  def LockAndCache.cached?(*key_parts)
+    key = LockAndCache::Key.new key_parts
+    key.cached?
+  end
+
   # @param seconds [Numeric] Maximum wait time to get a lock
   #
   # @note Can be overridden by putting `max_lock_wait:` in your call to `#lock_and_cache`
@@ -109,11 +135,6 @@ module LockAndCache
     @heartbeat_expires || DEFAULT_HEARTBEAT_EXPIRES
   end
 
-  # @private
-  def LockAndCache.lock_manager
-    @lock_manager
-  end
-
   # Check if a method is locked on an object.
   #
   # @note Subject mode - this is expected to be called on an object whose class has LockAndCache mixed in. See also standalone mode.

data/lib/lock_and_cache/action.rb

@@ -1,6 +1,8 @@
 module LockAndCache
   # @private
   class Action
+    ERROR_MAGIC_KEY = :lock_and_cache_error
+
     attr_reader :key
     attr_reader :options
     attr_reader :blk
@@ -30,8 +32,21 @@ module LockAndCache
       @lock_digest ||= key.lock_digest
     end
 
-    def storage
-      @storage ||= LockAndCache.storage or raise("must set LockAndCache.storage=[Redis]")
+    def lock_storage
+      @lock_storage ||= LockAndCache.lock_storage or raise("must set LockAndCache.lock_storage=[Redis]")
+    end
+
+    def cache_storage
+      @cache_storage ||= LockAndCache.cache_storage or raise("must set LockAndCache.cache_storage=[Redis]")
+    end
+
+    def load_existing(existing)
+      v = ::Marshal.load(existing)
+      if v.is_a?(::Hash) and (founderr = v[ERROR_MAGIC_KEY])
+        raise "Another LockAndCache process raised #{founderr}"
+      else
+        v
+      end
     end
 
     def perform
@@ -40,24 +55,25 @@ module LockAndCache
       raise "heartbeat_expires must be >= 2 seconds" unless heartbeat_expires >= 2
       heartbeat_frequency = (heartbeat_expires / 2).ceil
       LockAndCache.logger.debug { "[lock_and_cache] A1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
-      if storage.exists(digest) and (existing = storage.get(digest)).is_a?(String)
-        return ::Marshal.load(existing)
+      if cache_storage.exists?(digest) and (existing = cache_storage.get(digest)).is_a?(String)
+        return load_existing(existing)
       end
       LockAndCache.logger.debug { "[lock_and_cache] B1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
       retval = nil
-      lock_manager = LockAndCache.lock_manager
-      lock_info = nil
+      lock_secret = SecureRandom.hex 16
+      acquired = false
       begin
         Timeout.timeout(max_lock_wait, TimeoutWaitingForLock) do
-          until lock_info = lock_manager.lock(lock_digest, heartbeat_expires*1000)
+          until lock_storage.set(lock_digest, lock_secret, nx: true, ex: heartbeat_expires)
             LockAndCache.logger.debug { "[lock_and_cache] C1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
             sleep rand
           end
+          acquired = true
         end
         LockAndCache.logger.debug { "[lock_and_cache] D1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
-        if storage.exists(digest) and (existing = storage.get(digest)).is_a?(String)
+        if cache_storage.exists?(digest) and (existing = cache_storage.get(digest)).is_a?(String)
           LockAndCache.logger.debug { "[lock_and_cache] E1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
-          retval = ::Marshal.load existing
+          retval = load_existing existing
         end
         unless retval
           LockAndCache.logger.debug { "[lock_and_cache] F1 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
@@ -70,39 +86,50 @@ module LockAndCache
                 sleep heartbeat_frequency
                 break if done
                 LockAndCache.logger.debug { "[lock_and_cache] heartbeat2 #{key.debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
-                lock_manager.lock lock_digest, heartbeat_expires*1000, extend: lock_info
+                # FIXME use lua to check the value
+                raise "unexpectedly lost lock for #{key.debug}" unless lock_storage.get(lock_digest) == lock_secret
+                lock_storage.set lock_digest, lock_secret, xx: true, ex: heartbeat_expires
               end
             end
-            retval = blk.call
-            retval.nil? ? set_nil : set_non_nil(retval)
+            begin
+              retval = blk.call
+              retval.nil? ? set_nil : set_non_nil(retval)
+            rescue
+              set_error $!
+              raise
+            end
           ensure
             done = true
             lock_extender.join if lock_extender.status.nil?
           end
         end
       ensure
-        lock_manager.unlock lock_info if lock_info
+        lock_storage.del lock_digest if acquired
       end
       retval
     end
 
+    def set_error(exception)
+      cache_storage.set digest, ::Marshal.dump(ERROR_MAGIC_KEY => exception.message), ex: 1
+    end
+
     NIL = Marshal.dump nil
     def set_nil
       if nil_expires
-        storage.setex digest, nil_expires, NIL
+        cache_storage.set digest, NIL, ex: nil_expires
       elsif expires
-        storage.setex digest, expires, NIL
+        cache_storage.set digest, NIL, ex: expires
       else
-        storage.set digest, NIL
+        cache_storage.set digest, NIL
       end
     end
 
     def set_non_nil(retval)
       raise "expected not null #{retval.inspect}" if retval.nil?
       if expires
-        storage.setex digest, expires, ::Marshal.dump(retval)
+        cache_storage.set digest, ::Marshal.dump(retval), ex: expires
       else
-        storage.set digest, ::Marshal.dump(retval)
+        cache_storage.set digest, ::Marshal.dump(retval)
       end
     end
   end

data/lib/lock_and_cache/key.rb

@@ -1,3 +1,5 @@
+require 'date'
+
 module LockAndCache
   # @private
   class Key
@@ -22,8 +24,11 @@ module LockAndCache
       #
       # Recursively extract id from obj. Calls #lock_and_cache_key if available, otherwise #id
       def extract_obj_id(obj)
-        if ALLOWED_IN_KEYS.any? { |k| obj.is_a?(k) }
+        klass = obj.class
+        if ALLOWED_IN_KEYS.include?(klass)
           obj
+        elsif DATE.include?(klass)
+          obj.to_s
         elsif obj.respond_to?(:lock_and_cache_key)
           extract_obj_id obj.lock_and_cache_key
         elsif obj.respond_to?(:id)
@@ -43,7 +48,19 @@ module LockAndCache
       ::TrueClass,
       ::FalseClass,
       ::NilClass,
-    ]
+      ::Integer,
+      ::Float,
+    ].to_set
+    parts = ::RUBY_VERSION.split('.').map(&:to_i)
+    unless parts[0] >= 2 and parts[1] >= 4
+      ALLOWED_IN_KEYS << ::Fixnum
+      ALLOWED_IN_KEYS << ::Bignum  
+    end
+    DATE = [
+      ::Date,
+      ::DateTime,
+      ::Time,
+    ].to_set
     METHOD_NAME_IN_CALLER = /in `([^']+)'/
 
     attr_reader :context
@@ -81,14 +98,17 @@ module LockAndCache
     end
 
     def locked?
-      LockAndCache.storage.exists lock_digest
+      LockAndCache.lock_storage.exists? lock_digest
+    end
+
+    def cached?
+      LockAndCache.cache_storage.exists? digest
     end
 
     def clear
       LockAndCache.logger.debug { "[lock_and_cache] clear #{debug} #{Base64.encode64(digest).strip} #{Digest::SHA1.hexdigest digest}" }
-      storage = LockAndCache.storage
-      storage.del digest
-      storage.del lock_digest
+      LockAndCache.cache_storage.del digest
+      LockAndCache.lock_storage.del lock_digest
     end
 
     alias debug key

data/lib/lock_and_cache/version.rb

@@ -1,3 +1,3 @@
 module LockAndCache
-  VERSION = '4.0.4'
+  VERSION = '6.0.1'
 end

data/lock_and_cache.gemspec

@@ -20,8 +20,6 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency 'activesupport'
   spec.add_runtime_dependency 'redis'
-  # temporary until https://github.com/leandromoreira/redlock-rb/pull/20 is merged
-  spec.add_runtime_dependency 'redlock', '>=0.1.3'
 
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'bundler', '~> 1.6'

data/spec/lock_and_cache/key_spec.rb

@@ -21,13 +21,23 @@ describe LockAndCache::Key do
       expect(described_class.new(a: 1).send(:parts)).to eq(described_class.new([[:a, 1]]).send(:parts))
     end
     
+    now = Time.now
+    today = Date.today
     {
       [1]                                                => [1],
-      ["you"]                                            => ['you'],
-      [["you"]]                                          => [['you']],
-      [["you"], "person"]                                => [["you"], "person"],
-      [["you"], {:silly=>:person}]                       => [["you"], [[:silly, :person]] ],
-      { hi: 'you' }                                      => [[:hi, "you"]],
+      ['you']                                            => ['you'],
+      [['you']]                                          => [['you']],
+      [['you'], "person"]                                => [['you'], "person"],
+      [['you'], {:silly=>:person}]                       => [['you'], [[:silly, :person]] ],
+      [now]                                              => [now.to_s],
+      [[now]]                                            => [[now.to_s]],
+      [today]                                            => [today.to_s],
+      [[today]]                                          => [[today.to_s]],
+      { hi: 'you' }                                      => [[:hi, 'you']],
+      { hi: 123 }                                        => [[:hi, 123]],
+      { hi: 123.0 }                                      => [[:hi, 123.0]],
+      { hi: now }                                        => [[:hi, now.to_s]],
+      { hi: today }                                      => [[:hi, today.to_s]],
       [KeyTestId.new]                                    => ['id'],
       [[KeyTestId.new]]                                  => [['id']],
       { a: KeyTestId.new }                               => [[:a, "id"]],

data/spec/lock_and_cache_spec.rb

@@ -140,7 +140,8 @@ end
 
 describe LockAndCache do
   before do
-    LockAndCache.flush
+    LockAndCache.flush_locks
+    LockAndCache.flush_cache
   end
 
   it 'has a version number' do
@@ -337,6 +338,34 @@ describe LockAndCache do
       expect(count).to eq(1)
     end
 
+    it 'really caches' do
+      expect(LockAndCache.lock_and_cache('hello') { :red }).to eq(:red)
+      expect(LockAndCache.lock_and_cache('hello') { raise(Exception.new("stop")) }).to eq(:red)
+    end
+
+    it 'caches errors (briefly)' do
+      count = 0
+      expect {
+        LockAndCache.lock_and_cache('hello') { count += 1; raise("stop") }
+      }.to raise_error(/stop/)
+      expect(count).to eq(1)
+      expect {
+        LockAndCache.lock_and_cache('hello') { count += 1; raise("no no not me") }
+      }.to raise_error(/LockAndCache.*stop/)
+      expect(count).to eq(1)
+      sleep 1
+      expect {
+        LockAndCache.lock_and_cache('hello') { count += 1; raise("retrying") }
+      }.to raise_error(/retrying/)
+      expect(count).to eq(2)
+    end
+
+    it "can be queried for cached?" do
+      expect(LockAndCache.cached?('hello')).to be_falsy
+      LockAndCache.lock_and_cache('hello') { nil }
+      expect(LockAndCache.cached?('hello')).to be_truthy
+    end
+
     it 'allows expiry' do
       count = 0
       expect(LockAndCache.lock_and_cache('hello', expires: 1) { count += 1 }).to eq(1)

data/spec/spec_helper.rb

@@ -4,7 +4,8 @@ require 'lock_and_cache'
 require 'timeout'
 
 require 'redis'
-LockAndCache.storage = Redis.new
+LockAndCache.lock_storage = Redis.new db: 3
+LockAndCache.cache_storage = Redis.new db: 4
 
 require 'thread/pool'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lock_and_cache
 version: !ruby/object:Gem::Version
-  version: 4.0.4
+  version: 6.0.1
 platform: ruby
 authors:
 - Seamus Abshere
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-11 00:00:00.000000000 Z
+date: 2020-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -38,20 +38,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: redlock
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.3
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.3
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -167,6 +153,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmarks/allowed_in_keys.rb
 - lib/lock_and_cache.rb
 - lib/lock_and_cache/action.rb
 - lib/lock_and_cache/key.rb
@@ -194,8 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Lock and cache methods.
@@ -203,4 +189,3 @@ test_files:
 - spec/lock_and_cache/key_spec.rb
 - spec/lock_and_cache_spec.rb
 - spec/spec_helper.rb
-has_rdoc: