kanban 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f6f0f321b90145bc913fab9ee5b932908d16d2e8
-  data.tar.gz: 8f015ee628cc53a95d702f646a15ec6d7a47188c
+  metadata.gz: a02deca9fb7c7a28e7e8ad7098207514dd7f7923
+  data.tar.gz: 86cd0848296598c34ff29804f074982335ddb7ba
 SHA512:
-  metadata.gz: 9f51ccf582a838859c987187938554200e9a5ac471221a9928994cf46e370b8b1174ba4d168831ed6f1b3a55e77aabbf31727419bc1c2b4122830f9af62eb064
-  data.tar.gz: 796f6ca6814a854ac62163a3142daff394bde399b12280594f9cb7d3583f45d443c76f56ba0d17cf8d970142217b29f980da3969097fcbed2a68daef2bdfe9af
+  metadata.gz: 7e3c12bdac55a092b22cf08e144195e6f42bb061d8f549dc2b482c9effb0002f6df083a7d28638deb96a36b2d7fce1865971dca8491420689763f51b6e65fd1d
+  data.tar.gz: bdc4dd6c4a1bf249771f9fba20b7640daac28ec3c53cb7c4e29616ef372765fad3f9fc2c21b096af52875b5b32fe44b46a602e519b6af085d8c53c58f1e8fbf7

data/Gemfile

@@ -4,6 +4,7 @@ source "http://rubygems.org"
 #   gem "activesupport", ">= 2.3.5"
 
 gem 'redis'
+gem 'contracts'
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.

data/Gemfile.lock

@@ -4,6 +4,7 @@ GEM
     addressable (2.3.8)
     autotest-standalone (4.5.11)
     builder (3.2.2)
+    contracts (0.9)
     descendants_tracker (0.0.4)
       thread_safe (~> 0.3, >= 0.3.1)
     diff-lcs (1.2.5)
@@ -93,6 +94,7 @@ PLATFORMS
 DEPENDENCIES
   autotest-standalone
   bundler (~> 1.0)
+  contracts
   jeweler (~> 2.0.1)
   rdoc (~> 3.12)
   redis

data/README.md

@@ -1,2 +1,39 @@
 # kanban
 Because your code totally needed an Agile workflow.
+
+Description
+===========
+Kanban provides tools to model task flow in distributed apps.
+
+Create a Backlog
+----------------
+```ruby
+require 'redis'
+require 'kanban'
+
+backlog = Kanban::Backlog.new backend: Redis.new
+```
+
+Add some tasks to your shiny new Backlog
+----------------------------------------
+```ruby
+task = { 'foo' => 'bar' }
+5.times { backlog.add task }
+```
+
+(Elsewhere) Stake a claim on a task from the backlog
+----------------------------------------------------
+```ruby
+task_id = backlog.claim  # Will block until there is a task, if the backlog is empty or all tasks are being worked.
+details = backlog.get task_id
+```
+
+Mark a task as complete (or unworkable)
+---------------------------------------
+```ruby
+backlog.complete task_id
+# or backlog.unworkable task_id
+backlog.done? task_id  # => true
+```
+
+Claims expire after awhile (default 3 seconds), and become eligible to be worked by something else.

data/VERSION

@@ -1 +1 @@
-0.7.0
+0.8.0

data/kanban.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: kanban 0.7.0 ruby lib
+# stub: kanban 0.8.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "kanban"
-  s.version = "0.7.0"
+  s.version = "0.8.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Chris Olstrom"]
-  s.date = "2015-05-30"
+  s.date = "2015-06-02"
   s.description = "Because your code totally needed an Agile Workflow"
   s.email = "chris@olstrom.com"
   s.extra_rdoc_files = [
@@ -48,6 +48,7 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<redis>, [">= 0"])
+      s.add_runtime_dependency(%q<contracts>, [">= 0"])
       s.add_development_dependency(%q<rspec>, ["~> 3.2"])
       s.add_development_dependency(%q<yard>, ["~> 0.7"])
       s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
@@ -60,6 +61,7 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<rspec-autotest>, [">= 0"])
     else
       s.add_dependency(%q<redis>, [">= 0"])
+      s.add_dependency(%q<contracts>, [">= 0"])
       s.add_dependency(%q<rspec>, ["~> 3.2"])
       s.add_dependency(%q<yard>, ["~> 0.7"])
       s.add_dependency(%q<rdoc>, ["~> 3.12"])
@@ -73,6 +75,7 @@ Gem::Specification.new do |s|
     end
   else
     s.add_dependency(%q<redis>, [">= 0"])
+    s.add_dependency(%q<contracts>, [">= 0"])
     s.add_dependency(%q<rspec>, ["~> 3.2"])
     s.add_dependency(%q<yard>, ["~> 0.7"])
     s.add_dependency(%q<rdoc>, ["~> 3.12"])

data/lib/kanban.rb

@@ -1,9 +1,11 @@
 require 'redis'
+require 'contracts'
 require_relative 'kanban/hash_safety'
 
 module Kanban
   class Backlog
     using HashSafety
+    include Contracts
 
     attr_reader :namespace, :queue, :item
 
@@ -14,77 +16,105 @@ module Kanban
       @backend = backend
     end
 
+    Contract Num => Hash
     def get(id)
       @backend.hgetall "#{@item}:#{id}"
     end
 
+    Contract None => Num
     def next_id
       @backend.incr "#{@queue}:id"
     end
 
+    Contract None => ArrayOf[Num]
     def todo
       @backend.lrange("#{@queue}:todo", 0, -1).map(&:to_i)
     end
 
+    Contract HashOf[String, Any] => Num
     def add(task)
-      fail TypeError if task.keys_contain_symbols?
       id = next_id
       @backend.hmset "#{@item}:#{id}", *task.to_a
       @backend.lpush "#{@queue}:todo", id
       id
     end
 
+    Contract Hash => Num
     def add!(task)
       safe = task.with_string_keys
       add(safe)
     end
 
+    Contract Maybe[({ duration: Num })] => Num
     def claim(duration: 3)
       id = @backend.brpoplpush("#{@queue}:todo", "#{@queue}:doing")
       @backend.set "#{@item}:#{id}:claimed", true, ex: duration
       id.to_i
     end
 
+    Contract Num => Bool
     def claimed?(id)
       @backend.exists "#{@item}:#{id}:claimed"
     end
 
+    Contract None => ArrayOf[Num]
     def doing
       @backend.lrange("#{@queue}:doing", 0, -1).map(&:to_i)
     end
 
+    Contract Num => Bool
     def complete(id)
       @backend.setbit("#{@queue}:completed", id, 1).zero?
     end
 
+    Contract Num => Bool
     def completed?(id)
       @backend.getbit("#{@queue}:completed", id) == 1
     end
 
+    Contract Num => Bool
     def unworkable(id)
       @backend.setbit("#{@queue}:unworkable", id, 1).zero?
     end
 
+    Contract Num => Bool
     def unworkable?(id)
       @backend.getbit("#{@queue}:unworkable", id) == 1
     end
 
+    Contract Num => Bool
     def done?(id)
       completed?(id) || unworkable?(id)
     end
 
+    Contract Num => Bool
     def release(id)
       expire_claim id
       @backend.lrem("#{@queue}:doing", 0, id) > 0
     end
 
+    Contract Num => Bool
     def expire_claim(id)
       @backend.expire "#{@item}:#{id}:claimed", 0
     end
 
+    Contract Num => Bool
     def requeue(id)
       release id
       @backend.lpush("#{@queue}:todo", id) > 0
     end
+
+    Contract None => ArrayOf[Num]
+    def groom
+      doing.map do |id|
+        # puts "#{id} has active claim" if claimed? id
+        next if claimed? id
+        if done? id
+          id if release id
+        else
+          id if requeue id
+        end
+      end.compact
+    end
   end
 end

data/spec/kanban_spec.rb

@@ -2,10 +2,12 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 require 'timeout'
 
 describe 'Backlog' do
+  let(:redis) { Redis.new }
+  let(:backlog) { Kanban::Backlog.new backend: redis, namespace: 'kanban:test' }
+
   before do
-    @backlog = Kanban::Backlog.new backend: Redis.new, namespace: 'kanban:test'
     task = { 'test' => 'data' }
-    5.times { @backlog.add(task) }
+    5.times { backlog.add(task) }
   end
 
   after(:all) do
@@ -15,159 +17,363 @@ describe 'Backlog' do
     end
   end
 
-  it 'instantiates without error' do
-    expect(@backlog).to be_an_instance_of(Kanban::Backlog)
-  end
+  describe '#new' do
+    it 'should require a backend' do
+      expect { Kanban::Backlog.new }.to raise_error(ArgumentError)
+    end
 
-  it 'should allow namespace configuration at initialization' do
-    expect(@backlog.namespace).to eq 'kanban:test'
-  end
+    subject { backlog }
+    it { is_expected.to be_an_instance_of Kanban::Backlog }
 
-  it 'should prefix queue keys with the namespace' do
-    expect(@backlog.queue).to start_with('kanban:test')
-  end
+    context 'when no optional parameters are given' do
+      let(:backlog) { Kanban::Backlog.new backend: redis }
 
-  it 'should prefix item keys with the namespace' do
-    expect(@backlog.item).to start_with('kanban:test')
-  end
+      describe '.namespace' do
+        subject { backlog.namespace }
+        it { is_expected.to eq 'default' }
+      end
 
-  it 'should require a backend' do
-    expect { Kanban::Backlog.new }.to raise_error(ArgumentError)
-  end
+      describe '.queue' do
+        subject { backlog.queue }
+        it { is_expected.to eq 'default:tasks' }
+      end
 
-  it 'should be able to get a task' do
-    expect(@backlog.get(0)).to be_a Hash
-  end
+      describe '.item' do
+        subject { backlog.item }
+        it { is_expected.to eq 'default:task' }
+      end
+    end
 
-  it 'shoud provide the next ID to assign to a task' do
-    expect(@backlog.next_id).to be_a Fixnum
-  end
+    context 'when :namespace is "testing"' do
+      let(:backlog) { Kanban::Backlog.new backend: redis, namespace: 'testing' }
 
-  it 'should not reuse IDs' do
-    expect(@backlog.next_id).to eq (@backlog.next_id - 1)
-  end
+      describe '.namespace' do
+        subject { backlog.namespace }
+        it { is_expected.to eq 'testing' }
+      end
+    end
 
-  it 'should have a list of tasks waiting to be done' do
-    expect(@backlog.todo).to be_an Array
-  end
+    context 'when :queue is "tests"' do
+      let(:backlog) { Kanban::Backlog.new backend: redis, queue: 'tests' }
+      describe '.queue' do
+        subject { backlog.queue }
+        it { is_expected.to eq 'default:tests' }
+      end
+    end
 
-  it 'should throw a TypeError if passed a Hash with Symbol keys' do
-    task = { foo: 'bar' }
-    expect { @backlog.add task }.to raise_error(TypeError)
+    context 'when :item is "test"' do
+      let(:backlog) { Kanban::Backlog.new backend: redis, item: 'test' }
+      describe '.item' do
+        subject { backlog.item }
+        it { is_expected.to eq 'default:test' }
+      end
+    end
   end
 
-  it 'should return the ID of a newly added task' do
-    task = { 'foo' => 'bar' }
-    expect(@backlog.add(task)).to be_a Fixnum
-  end
+  describe '#get' do
+    context 'when the task does not exist' do
+      subject { backlog.get 0 }
+      it { is_expected.to be_empty }
+    end
 
-  it 'should allow Symbol keys with add! method' do
-    task = { foo: 'bar' }
-    expect(@backlog.add!(task)).to be_a Fixnum
+    context 'when the task is {"test"=>"data"}' do
+      let(:task) { ({ 'test' => 'data' }) }
+      let(:id) { backlog.add task }
+      subject { backlog.get id }
+      it { is_expected.to eq task }
+    end
   end
 
-  it 'should preserve the task details' do
-    task = { 'foo' => 'bar' }
-    expect(@backlog.get(@backlog.add(task))).to eq task
+  describe '#next_id' do
+    describe 'should return incrementing values' do
+      let!(:last_id) { backlog.next_id }
+      subject { backlog.next_id }
+      it { is_expected.to be > last_id }
+    end
   end
 
-  it 'should add new tasks to the list of tasks waiting to be done' do
-    task = { 'foo' => 'bar' }
-    id = @backlog.add(task)
-    expect(@backlog.todo).to include(id)
+  describe '#todo' do
+    context 'when there are no tasks pending' do
+      before { redis.del "#{backlog.queue}:todo" }
+      subject { backlog.todo }
+      it { is_expected.to be_empty }
+    end
+
+    context 'when there are tasks pending' do
+      let(:task) { ({ 'test' => 'data' }) }
+      let!(:id) { backlog.add task }
+      subject { backlog.todo }
+      it { is_expected.to_not be_empty }
+      it { is_expected.to include id }
+    end
+
+    context 'when a task is requeued' do
+      let(:id) { backlog.claim }
+      before { backlog.requeue id }
+      subject { backlog.todo }
+      it { is_expected.to include id }
+    end
   end
 
-  it 'should allow a task to be claimed' do
-    expect(@backlog.claim).to be_a Fixnum
+  describe '#add' do
+    context 'when task is a hash with symbol keys' do
+      let(:task) { ({ foo: 'bar' }) }
+      it 'should raise a ParamContractError' do
+        expect { backlog.add task }.to raise_error(ParamContractError)
+      end
+    end
+
+    context 'when task is a hash with string keys' do
+      let(:task) { ({ 'test' => 'data' }) }
+      let!(:id) { backlog.next_id + 1}
+      subject { backlog.add task }
+      it { is_expected.to eq id }
+    end
   end
 
-  it 'should track the claim separately from the queue it is in' do
-    id = @backlog.claim
-    expect(@backlog.claimed?(id)).to be true
+  describe '#add!' do
+    context 'when task is a hash with symbol keys' do
+      let(:task) { ({ test: 'data' }) }
+      let!(:id) { backlog.next_id + 1 }
+      subject { backlog.add! task }
+      it { is_expected.to eq id }
+    end
   end
 
-  it 'should allow claims to expire' do
-    id = @backlog.claim(duration: 1)
-    sleep 1.1
-    expect(@backlog.claimed?(id)).to be false
+  describe '#claimed?' do
+    context 'when a claim does not exist' do
+      subject { backlog.claimed? 0 }
+      it { is_expected.to be false }
+    end
+
+    context 'when a claim exists' do
+      let(:id) { backlog.claim }
+      subject { backlog.claimed? id }
+      it { is_expected.to be true }
+    end
+
+    context 'when a claim has expired' do
+      let!(:id) { backlog.claim duration: 1 }
+      before { sleep 1.1 }
+      subject { backlog.claimed? id }
+      it { is_expected.to be false }
+    end
+
+    context 'when a claim has been forcibly expired' do
+      let(:id) { backlog.claim }
+      before { backlog.expire_claim id }
+      subject { backlog.claimed? id }
+      it { is_expected.to be false }
+    end
+
+    context 'when a task has been released' do
+      let(:id) { backlog.claim }
+      before { backlog.release id }
+      subject { backlog.claimed? id }
+      it { is_expected.to be false }
+    end
   end
 
-  it 'should block if there are no pending tasks' do
-    redis = Redis.new
-    redis.del "#{@backlog.queue}:todo"
-    expect do
-      Timeout.timeout(0.1) do
-        @backlog.claim
+  describe '#claim' do
+    context 'when there are no pending tasks' do
+      before { redis.del "#{backlog.queue}:todo" }
+      it 'should block' do
+        expect do
+          Timeout.timeout(0.1) do
+            backlog.claim
+          end
+        end.to raise_error(Timeout::Error)
       end
-    end.to raise_error(Timeout::Error)
-  end
+    end
 
-  it 'should report if a task is claimed' do
-    id = @backlog.claim
-    expect(@backlog.claimed?(id)).to be true
-    expect(@backlog.claimed?(0)).to be false
+    context 'when there are pending tasks' do
+      before { backlog.add ({ 'test' => 'data' }) }
+      subject { backlog.claim }
+      it { is_expected.to be_a Fixnum }
+    end
   end
 
-  it 'should have a list of tasks being worked on' do
-    id = @backlog.claim
-    expect(@backlog.doing).to include(id)
-  end
+  describe '#doing' do
+    let!(:id) { backlog.claim }
+    subject { backlog.doing }
+    it { is_expected.to include id }
 
-  it 'should allow indicating completion of a task only once' do
-    expect(@backlog.complete(1)).to be true
-    expect(@backlog.complete(1)).to be false
+    context 'when a task is released' do
+      before { backlog.release id }
+      subject { backlog.doing }
+      it { is_expected.to_not include id }
+    end
+
+    context 'when a task is requeued' do
+      before { backlog.requeue id }
+      subject { backlog.doing }
+      it { is_expected.to_not include id }
+    end
   end
 
-  it 'should check if a task is completed' do
-    expect(@backlog.completed?(2)).to be false
-    @backlog.complete 2
-    expect(@backlog.completed?(2)).to be true
+  describe '#complete' do
+    context 'when task has not been marked complete' do
+      subject { backlog.complete 1 }
+      it { is_expected.to be true }
+    end
+
+    context 'when task has been marked complete' do
+      before { backlog.complete 1 }
+      subject { backlog.complete 1 }
+      it { is_expected.to be false }
+    end
   end
 
-  it 'should allow indicating a task should not be retried' do
-    expect(@backlog.unworkable(3)).to be true
-    expect(@backlog.unworkable(3)).to be false
+  describe '#completed?' do
+    context 'when task has not been marked complete' do
+      subject { backlog.completed? 2 }
+      it { is_expected.to be false }
+    end
+
+    context 'when task has been marked complete' do
+      before { backlog.complete 3 }
+      subject { backlog.completed? 3 }
+      it { is_expected.to be true }
+    end
   end
 
-  it 'should check if a task is unworkable' do
-    expect(@backlog.unworkable?(4)).to be false
-    @backlog.unworkable 4
-    expect(@backlog.unworkable?(4)).to be true
+  describe '#unworkable' do
+    context 'when task has not been marked unworkable' do
+      subject { backlog.unworkable 1 }
+      it { is_expected.to be true }
+    end
+
+    context 'when task has been marked unworkable' do
+      before { backlog.unworkable 1 }
+      subject { backlog.unworkable 1 }
+      it { is_expected.to be false }
+    end
   end
 
-  it 'should consider a task that is completed or unworkable to be done' do
-    expect(@backlog.done?(0)).to be false
-    @backlog.complete(5)
-    expect(@backlog.done?(5)).to be true
-    @backlog.unworkable(6)
-    expect(@backlog.done?(6)).to be true
+  describe '#unworkable?' do
+    context 'when task has not been marked unworkable' do
+      subject { backlog.unworkable? 2 }
+      it { is_expected.to be false }
+    end
+
+    context 'when task has been marked unworkable' do
+      before { backlog.unworkable 3 }
+      subject { backlog.unworkable? 3 }
+      it { is_expected.to be true }
+    end
   end
 
-  it 'should be able to release a task from being in progress' do
-    id = @backlog.claim
-    expect(@backlog.release(id)).to be true
-    expect(@backlog.release(id)).to be false
-    expect(@backlog.doing).to_not include(id)
+  describe '#done?' do
+    context 'when task has not been marked either complete or unworkable' do
+      subject { backlog.done? 0 }
+      it { is_expected.to be false }
+    end
+
+    context 'when task has been marked complete' do
+      before { backlog.complete 5 }
+      subject { backlog.done? 5 }
+      it { is_expected.to be true }
+    end
+
+    context 'when task has been marked unworkable' do
+      before { backlog.unworkable 6 }
+      subject { backlog.done? 6 }
+      it { is_expected.to be true }
+    end
   end
 
-  it 'should be able to forcibly expire a claim' do
-    expect(@backlog.expire_claim(0)).to be false
-    id = @backlog.claim
-    expect(@backlog.expire_claim(id)).to be true
-    expect(@backlog.claimed?(id)).to be false
+  describe '#release' do
+    context 'when task is claimed' do
+      let(:id) { backlog.claim }
+      subject { backlog.release id }
+      it { is_expected.to be true }
+    end
+
+    context 'when task was not claimed' do
+      subject { backlog.release 0 }
+      it { is_expected.to be false }
+    end
   end
 
-  it 'should expire any active claims when a task is released' do
-    id = @backlog.claim
-    expect(@backlog.claimed?(id)).to be true
-    @backlog.release(id)
-    expect(@backlog.claimed?(id)).to be false
+  describe '#expire_claim' do
+    context 'when task was not claimed' do
+      subject { backlog.expire_claim 0 }
+      it { is_expected.to be false }
+    end
+
+    context 'when task was claimed' do
+      let(:id) { backlog.claim }
+      subject { backlog.expire_claim id }
+      it { is_expected.to be true }
+    end
   end
 
-  it 'should be able to requeue a task' do
-    id = @backlog.claim
-    expect(@backlog.requeue(id)).to be true
-    expect(@backlog.todo).to include(id)
-    expect(@backlog.doing).to_not include(id)
+  describe '#groom' do
+    context 'when a task is claimed' do
+      let(:id) { backlog.claim }
+
+      context 'and the claim has expired' do
+        before { backlog.expire_claim id }
+        subject { backlog.groom }
+        it { is_expected.to include id }
+
+        context 'when #groom is called' do
+          before { backlog.groom }
+
+          describe '#todo' do
+            subject { backlog.todo }
+            it { is_expected.to include id }
+          end
+
+          describe '#doing' do
+            subject { backlog.doing }
+            it { is_expected.to_not include id }
+          end
+        end
+      end
+
+      context 'and the task is done' do
+        before { backlog.complete id }
+
+        context 'and the claim has expired' do
+          before { backlog.expire_claim id }
+
+          subject { backlog.groom }
+          it { is_expected.to include id }
+
+          context 'when #groom is called' do
+            before { backlog.groom }
+            describe '#todo' do
+              subject { backlog.todo }
+              it { is_expected.to_not include id }
+            end
+
+            describe '#doing' do
+              subject { backlog.doing }
+              it { is_expected.to_not include id }
+            end
+          end
+        end
+
+        context 'and the claim has not expired' do
+          subject { backlog.groom }
+          it { is_expected.to_not include id }
+
+          context 'when #groom is called' do
+            before { backlog.groom }
+
+            describe '#todo' do
+              subject { backlog.todo }
+              it { is_expected.to_not include id }
+            end
+
+            describe '#doing' do
+              subject { backlog.doing }
+              it { is_expected.to include id }
+            end
+          end
+        end
+      end
+    end
   end
 end

data/spec/spec_helper.rb

@@ -15,6 +15,8 @@ end
 
 ENV['COVERAGE'] && SimpleCov.start do
   add_filter '/.rvm/'
+  add_filter '/.rubies/'
+  add_filter '/vendor/'
 end
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
@@ -25,3 +27,9 @@ require 'kanban'
 # Requires supporting files with custom matchers and macros, etc,
 # in ./support/ and its subdirectories.
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kanban
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Chris Olstrom
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-30 00:00:00.000000000 Z
+date: 2015-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: contracts
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement