resque-rate_limited 1.2.0 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 80fd71103be3c3e16a7a86a137f3cda8f0e81b69
-  data.tar.gz: 261ad5cf9c452a768d87502b7d7163df6477ae34
+  metadata.gz: 1a577c3a5760f78c7d2bcc9a09f88f760a912659
+  data.tar.gz: 9daa34e0d508084219855c54a265c732a4432be6
 SHA512:
-  metadata.gz: 27615639de42565e0a074593961b70078214c09eed73b665b507096c7d08bb2a29288e12d960c998e70021db740ab972a5ebe6ec5b83f342223abda7c5d6b1e9
-  data.tar.gz: 5b7fe9fb6883617feb2e3c802b8beae1bf8be647b75bc0a4c24fa0242f0cbfdf4e7f19d7f898fc756c0688921ed737d8b5d4ec9139a1547f95afaad5ca2db9b1
+  metadata.gz: 83ac5456c7bc19657ef0dd753f3cc9ef2cc5bd0b1f74bb0db0aae7a560c0e1f3440757006f69fc348fe635b33a73e932cd2684c6faa447be9316c0d14778df8b
+  data.tar.gz: 798a48a1325d621a5a86bde14921f7b212da93d0a54122c9d5e06d4c54fe642159b19cf3939fa46a620035b0f887a5221a7bb3ffc6b6bb6b400fc3a32a1cafa8

data/.codelimate.yml

@@ -0,0 +1,17 @@
+---
+engines:
+  duplication:
+    enabled: true
+    config:
+      languages:
+      - ruby
+  fixme:
+    enabled: true
+  rubocop:
+    enabled: true
+ratings:
+  paths:
+  - "**.rb"
+exclude_paths:
+- script/
+- spec/

data/.rspec

@@ -1,2 +1,2 @@
 --color
---format progress
+--require spec_helper

data/.rubocop.yml

@@ -1,9 +1,10 @@
 ---
 AllCops:
+  TargetRubyVersion: 2.0
+  DisplayCopNames: true
   Exclude:
     - 'tmp/**/*'
     - 'coverage/**/*'
-    - 'spec/dummy/**/*'
 
 #-------------------------------------------------------------------------------
 # Project standards
@@ -25,11 +26,6 @@ FileName:
   Description: 'Use snake_case for source file names.'
   Enabled: true
 
-Style/SymbolArray:
-  Description: 'Use %i or %I for arrays of symbols.'
-  StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#percent-i'
-  Enabled: false # Only available in Ruby 2.0+
-
 Style/ExtraSpacing:
   Description: 'Do not use unnecessary spacing.'
   Enabled: true
@@ -38,9 +34,21 @@ Lint/LiteralInInterpolation:
   Description: 'Avoid interpolating literals in strings'
   AutoCorrect: true
 
-#-------------------------------------------------------------------------------
-# These rules have been relaxed because of existing code
-# We should tighten these up over time
-#-------------------------------------------------------------------------------
-LineLength:
-  Max: 166 # project standard is 120
+Style/PercentLiteralDelimiters:
+  # Hound and CodeClimate are currently using an old version of Rubocop with
+  # different defaults, so we set them explicitly here.
+  PreferredDelimiters:
+    default: ()
+    '%i': '[]'
+    '%I': '[]'
+    '%r': '{}'
+    '%w': '[]'
+    '%W': '[]'
+
+Metrics/LineLength:
+  Max: 120
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*_spec.rb'
+    - '*.gemspec'

data/.travis.yml

@@ -0,0 +1,15 @@
+---
+services:
+  - redis-server
+language: ruby
+dist: trusty
+rvm:
+  - 2.4.0
+  - 2.3
+  - 2.2
+  - 2.1
+  - 2.0
+before_install:
+  - gem update bundler
+script: bundle exec rspec
+after_success: bundle exec codeclimate-test-reporter

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Change Log
+
+## [1.2.1](https://github.com/Xenapto/resque-rate_limited/tree/1.2.1) (2017-04-26)
+[Full Changelog](https://github.com/Xenapto/resque-rate_limited/compare/v1.2.0...1.2.1)
+
+**Merged pull requests:**
+
+- Prepare for more recent rubies [\#1](https://github.com/Xenapto/resque-rate_limited/pull/1) ([dominicsayers](https://github.com/dominicsayers))
+
+## [v1.2.0](https://github.com/Xenapto/resque-rate_limited/tree/v1.2.0) (2016-10-07)
+[Full Changelog](https://github.com/Xenapto/resque-rate_limited/compare/v1.1.0...v1.2.0)
+
+## [v1.1.0](https://github.com/Xenapto/resque-rate_limited/tree/v1.1.0) (2016-10-03)
+
+
+\* *This Change Log was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)*

data/Gemfile

@@ -1,4 +1,21 @@
 source 'https://rubygems.org'
-
-# Specify your gem's dependencies in resque_rate_limited.gemspec
 gemspec
+ruby RUBY_VERSION
+
+group :development do
+  gem 'bundler'
+  gem 'gem-release'
+  gem 'github_changelog_generator'
+  gem 'guard'
+  gem 'guard-rspec'
+  gem 'guard-rubocop'
+end
+
+group :test do
+  gem 'codeclimate-test-reporter'
+  gem 'coveralls'
+  gem 'fuubar'
+  gem 'rspec'
+  gem 'rspec_junit_formatter'
+  gem 'simplecov'
+end

data/README.md

@@ -1,16 +1,23 @@
-# Resque Rate Limited
+## Resque rate-limited
 
-A Resque plugin which makes handling jobs that use rate limited apis easier
+[![Gem version](https://badge.fury.io/rb/resque-rate_limited.svg)](https://rubygems.org/gems/resque-rate_limited)
+[![Gem downloads](https://img.shields.io/gem/dt/resque-rate_limited.svg)](https://rubygems.org/gems/resque-rate_limited)
+[![Build Status](https://travis-ci.org/Xenapto/resque-rate_limited.svg?branch=master)](https://travis-ci.org/Xenapto/resque-rate_limited)
+[![Code Climate](https://codeclimate.com/github/Xenapto/resque-rate_limited/badges/gpa.svg)](https://codeclimate.com/github/Xenapto/resque-rate_limited)
+[![Test Coverage](https://codeclimate.com/github/Xenapto/resque-rate_limited/badges/coverage.svg)](https://codeclimate.com/github/Xenapto/resque-rate_limited/coverage)
+[![Dependency Status](https://gemnasium.com/badges/github.com/Xenapto/resque-rate_limited.svg)](https://gemnasium.com/github.com/Xenapto/resque-rate_limited)
+[![Security](https://hakiri.io/github/Xenapto/resque-rate_limited/master.svg)](https://hakiri.io/github/Xenapto/resque-rate_limited/master)
 
-If you have a series of jobs in a queue, this gem will pause the queue when one of the jobs hits a rate limit, and re-start the queue when the rate limit has expired.
+A Resque plugin which makes handling jobs that use rate-limited APIs easier
 
-There are two ways to use the gem.
+If you have a series of jobs in a queue, this gem will pause the queue when one of the jobs hits a rate limit, and re-start the queue when the rate limit has expired.
 
-If the api you are using has a dedicated queue included in the gem (currently Twitter, Angellist and Evernote) then you just need to make some very minor changes to how you queue jobs, and the gem will do the rest.
+There are two ways to use the gem:
 
-If you are using another API, then you need to write a little code that catches the rate limit signal.
+1.  If the API you are using has a dedicated queue included in the gem (currently Twitter, Angellist and Evernote) then you just need to make some very minor changes to how you queue jobs, and the gem will do the rest.
+1.  If you are using another API, then you need to write a little code that catches the rate limit signal.
 
-## Installation
+### Installation
 
 Add this line to your application's Gemfile:
 
@@ -26,15 +33,15 @@ Or install it yourself as:
 
     $ gem install resque-rate_limited
 
-## Usage
+### Usage
 
-### Configuration
 #### Redis
 The gem uses [redis-mutex](https://github.com/kenn/redis-mutex ) which requires you to register the Redis server: (e.g. in `config/initializers/redis_mutex.rb` for Rails)
 
 ```ruby
 RedisClassy.redis = Redis.new
 ```
+
 Note that Redis Mutex uses the `redis-classy` gem internally.
 
 #### Un Pause
@@ -51,28 +58,33 @@ Resque::Plugins::RateLimited::UnPause.queue = :my_queue
 Please see the section below on how to unpause on heroku as an alternative. If you don't install `resque-scheduler` AND configure the queue, then the gem will not schedule unpause jobs this way.
 
 #### Workers
-Queues are paused by renaming them, so a resque queue called 'twitter\_api' will be renamed 'twitter\_api\_paused' when it hits a rate limit. Of course this will only work if your resque workers are not also taking jobs from the 'twitter\_api\_paused' queue. So your worker commands need to look like:
+Queues are paused by renaming them, so a resque queue called `twitter_api` will be renamed `twitter_api_paused` when it hits a rate limit. Of course this will only work if your resque workers are not also taking jobs from the `twitter_api_paused` queue. So your worker commands need to look like:
 
 Either
+
 ```ruby
 bin/resque work --queues=high,low,twitter_api
 ```
 or
+
 ```ruby
 env QUEUES=high,low,twitter_api bundle exec rake jobs:work
 ```
 
 NOT
+
 ```ruby
 bin/resque work --queues=*
 ```
-or NOT
+
+and NOT
+
 ```ruby
 env QUEUES=* bundle exec rake jobs:work
 ```
 
 #### Unpausing on heroku
-The built in schedler on heroku doesn't support dynamic scheduling from an API, so unless you want to provision an extra worker to run resque-scheduler - the best option is just to unpause all your queues on a regular basis. If they aren't paused this is a harmless no-op. If not enough time has elapsed the jobs will just hit the rate_limit and get paused again. We've found that a hourly 'rake unpause' job seems to work well. The rake task would need to call:
+The built in schedler on heroku doesn't support dynamic scheduling from an API, so unless you want to provision an extra worker to run resque-scheduler - the best option is just to unpause all your queues on a regular basis. If they aren't paused this is a harmless no-op. If not enough time has elapsed the jobs will just hit the rate_limit and get paused again. We've found that a hourly `rake unpause` job seems to work well. The rake task would need to call:
 
 ```ruby
 Resque::Plugins::RateLimited.TwitterQueue.un_pause
@@ -80,12 +92,12 @@ Resque::Plugins::RateLimited.AngellistQueue.un_pause
 MyQueue.un_pause
 MyJob.un_pause
 ```
-### A pausable job using one of the build-in queues (Twitter, Angellist, Evernote)
-If you're using the [twitter gem](https://github.com/sferik/twitter), this is really simple. Instead of queuing using Resque.enqueue, you just use Resque::Plugins::RateLimited:TwitterQueue.enqueue.
+#### A pausable job using one of the build-in queues (Twitter, Angellist, Evernote)
+If you're using the [twitter gem](https://github.com/sferik/twitter), this is really simple. Instead of queuing using `Resque.enqueue`, you just use `Resque::Plugins::RateLimited:TwitterQueue.enqueue`.
 
-Make sure your code in perform doesn't catch the rate_limit exception.
+Make sure your code in perform doesn't catch the rate limit exception.
 
-The TwitterQueue will catch the exception and pause the queue (as well as re-scheduling the jobs and scheduling an un pause (if you are using resque-scheduler)). Any jobs you add while the queue is paused will be added to the paused queue
+The TwitterQueue will catch the exception and pause the queue (as well as re-scheduling the jobs and scheduling an un pause (if you are using `resque-scheduler`)). Any jobs you add while the queue is paused will be added to the paused queue
 
 ```ruby
 class TwitterJob
@@ -101,8 +113,8 @@ class TwitterJob
 end
 ```
 
-### A single class of pausable job using a new api
-If you only have one class of job you want to queue using the api, then you can use the PauseQueue module directly
+#### A single class of pausable job using a new API
+If you only have one class of job you want to queue using the API, then you can use the `PauseQueue` module directly
 
 ```ruby
 class MyApiJob
@@ -121,10 +133,10 @@ class MyApiJob
     rate_limited_enqueue(self, *params)
   end
 end
-````
+```
 
-### Multiple classes of pausable job using a new api
-If you have more than one class of job you want to queue to the api, then you need to add another Queue class. This isn't hard
+#### Multiple classes of pausable job using a new API
+If you have more than one class of job you want to queue to the API, then you need to add another Queue class. This isn't hard
 
 ```ruby
 class MyApiQueue < Resque::Plugins::RateLimited::BaseApiQueue
@@ -138,32 +150,37 @@ class MyApiQueue < Resque::Plugins::RateLimited::BaseApiQueue
     rate_limited_requeue(self, klass, *params)
   end
 end
-````
+```
+
 If you do this - please contribute - and I'll add to the gem.
 
-## Development Documentation
+### Development Documentation
 All the functions are class methods
 
 ```ruby
 rate_limited_enqueue(klass, *params)
 rate_limited_requeue(klass, *params)
-````
+```
+
 Queue the job specified to the resque queue specified by `@queue`. `rate_limited_requeue` is intended for use when you need the job to be pushed back to the queue; there are two reasons to split this from `rate_limited_enqueue`. Firstly it makes testing with stubs easier - secondly there is a boundary condition when you need to requeue the last job in the queue.
 
 ```ruby
 pause
-````
+```
+
 Pauses the queue specified by `@queue`, if it is not already paused.
 In most cases you should call `pause_until` to pause a queue when you hit a rate limit.
 
 ```ruby
 un_pause
-````
+```
+
 Un-pauses the queue specified by `@queue`, if it is paused.
 
 ```ruby
 pause_until(timestamp)
-````
+```
+
 Pauses the queue (specified by `@queue`) and then queues a job to unpause the queue specified by `@queue`, using resque-scheduler to the queue specified by `Resque::Plugins::RateLimited::UnPause.queue` at the timestamp specified.
 If `resque-schedule` is not included, or `UnPause.queue` isn't specified this will just pause the queue.
 
@@ -171,26 +188,29 @@ This is the prefered function to call when you hit a rate limit, since it with w
 
 ```ruby
 paused?
-````
+```
+
 This returns true or false to indicate wheher the queue is paused. Be aware that the queue state could change get after the call returns, but before your code executes. Use `with_lock` if you need to avoid this.
 
 ```ruby
 paused_queue_name
-````
+```
+
 Returns the name of the queue when it is paused.
 
 ```ruby
 with_lock(&block)
-````
+```
+
 Takes ownership of the PauseQueue semaphor before executing the block passed. Useful if you need to test the state of the queue and take some action without the state changing.
 
 ```ruby
 find_class(klass)
-````
-Takes the parameter passed, and if it's a string class name, tries to turn it into a class.
+```
 
+Takes the parameter passed, and if it's a string class name, tries to turn it into a class.
 
-## Contributing
+### Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/resque_rate_limited/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
@@ -198,18 +218,7 @@ Takes the parameter passed, and if it's a string class name, tries to turn it in
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
 
-
-## Version history
-
-0.0.x Mostly pre-release versions
-
-1.0.0 First release version. Breaking change - renamed  `pause_for` to be `pause_until` to better reflect function
-
-1.1.0 Enqueues underlying job instead of directly performing it
-
-
-
-## Final thoughts
+### Final thoughts
 Thanks to [Dominic](https://github.com/dominicsayers) for idea of renaming the redis key - and the sample code that does this.
 
 This is my first gem - so please forgive any errors - and feedback very welcome

data/Rakefile

@@ -1 +1,11 @@
 require 'bundler/gem_tasks'
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+
+  task default: :spec
+rescue LoadError
+  puts 'rspec is not available'
+end

data/lib/resque-rate_limited/version.rb

@@ -1,3 +1,3 @@
 module RateLimited
-  VERSION = '1.2.0'.freeze
+  VERSION = '1.2.2'.freeze
 end

data/resque-rate_limited.gemspec

@@ -1,43 +1,31 @@
-# coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'resque-rate_limited/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = 'resque-rate_limited'
-  spec.version       = RateLimited::VERSION
-  spec.authors       = ['Greg Dowling']
-  spec.email         = ['mail@greddowling.com']
-  spec.summary     = 'A Resque plugin to help manage jobs that use rate limited apis, pausing when you hit the limits and restarting later.'
-  spec.description = 'A Resque plugin which allows you to create dedicated queues for jobs that use rate limited apis.
-These queues will pause when one of the jobs hits a rate limit, and unpause after a suitable time period.
-The rate_limited can be used directly, and just requires catching the rate limit exception and pausing the
-queue. There are also additional queues provided that already include the pause/rety logic for twitter, angelist
-and evernote; these allow you to support rate limited apis with minimal changes.'
+  spec.name           = 'resque-rate_limited'
+  spec.version        = RateLimited::VERSION
+  spec.authors        = ['Greg Dowling']
+  spec.email          = ['mail@greddowling.com']
+  spec.summary        = 'A Resque plugin to help manage jobs that use rate-limited APIs, pausing when you hit the '\
+                        'limits and restarting later.'
+  spec.description    = 'A Resque plugin which allows you to create dedicated queues for jobs that use rate-limited '\
+                        'APIs. These queues will pause when one of the jobs hits a rate limit, and unpause after a '\
+                        'suitable time period. The rate-limited queue can be used directly, and just requires '\
+                        'catching the rate limit exception and pausing the queue. There are also additional queues '\
+                        'provided that already include the pause/retry logic for Twitter, AngelList and Evernote; '\
+                        'these allow you to support rate-limited APIs with minimal changes.'
+  spec.homepage       = 'http://github.com/Xenapto/resque-rate_limited'
+  spec.license        = 'MIT'
 
-  spec.homepage      = 'http://github.com/Xenapto/resque-rate_limited'
-  spec.license       = 'MIT'
-
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ['lib']
+  spec.files          = `git ls-files`.split($INPUT_RECORD_SEPARATOR).reject { |f| f =~ %r{^spec/} }
+  spec.executables    = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files     = spec.files.grep(%r{^(test|spec|features|coverage|script)/})
+  spec.require_paths  = ['lib']
 
   spec.add_dependency 'resque', '~> 1.9', '>= 1.9.10'
   spec.add_dependency 'redis-mutex', '~> 4.0', '>= 4.0.0'
-
   spec.add_dependency 'angellist_api', '~> 1.0', '>= 1.0.7'
   spec.add_dependency 'evernote-thrift', '~> 1.25', '>= 1.25.1'
-  spec.add_dependency 'twitter', '~> 5.11', '>= 5.11.0'
-
-  spec.add_development_dependency 'rake', '~> 10'
-  spec.add_development_dependency 'rspec', '~> 2'
-  spec.add_development_dependency 'simplecov', '~> 0'
-  spec.add_development_dependency 'rubocop', '~> 0'
-  spec.add_development_dependency 'reek', '~> 4'
-  spec.add_development_dependency 'listen', '~> 3.0', '< 3.1' # Dependency of guard, 3.1 requires Ruby 2.2+
-  spec.add_development_dependency 'guard', '~> 2'
-  spec.add_development_dependency 'guard-rspec', '~> 4'
-  spec.add_development_dependency 'guard-rubocop', '~> 1'
-  spec.add_development_dependency 'gem-release', '~> 0'
+  spec.add_dependency 'twitter', '>= 5.11.0'
 end

data/script/console

@@ -0,0 +1,2 @@
+#!/bin/sh
+bundle exec irb -rubygems -I lib -r resque/rate_limited.rb

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: resque-rate_limited
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.2
 platform: ruby
 authors:
 - Greg Dowling
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-07 00:00:00.000000000 Z
+date: 2017-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: resque
@@ -94,9 +94,6 @@ dependencies:
   name: twitter
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.11'
     - - ">="
       - !ruby/object:Gem::Version
         version: 5.11.0
@@ -104,180 +101,34 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.11'
     - - ">="
       - !ruby/object:Gem::Version
         version: 5.11.0
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  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: rubocop
-  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: reek
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4'
-- !ruby/object:Gem::Dependency
-  name: listen
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3.1'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3.1'
-- !ruby/object:Gem::Dependency
-  name: guard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2'
-- !ruby/object:Gem::Dependency
-  name: guard-rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4'
-- !ruby/object:Gem::Dependency
-  name: guard-rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1'
-- !ruby/object:Gem::Dependency
-  name: gem-release
-  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: |-
-  A Resque plugin which allows you to create dedicated queues for jobs that use rate limited apis.
-  These queues will pause when one of the jobs hits a rate limit, and unpause after a suitable time period.
-  The rate_limited can be used directly, and just requires catching the rate limit exception and pausing the
-  queue. There are also additional queues provided that already include the pause/rety logic for twitter, angelist
-  and evernote; these allow you to support rate limited apis with minimal changes.
+description: A Resque plugin which allows you to create dedicated queues for jobs
+  that use rate-limited APIs. These queues will pause when one of the jobs hits a
+  rate limit, and unpause after a suitable time period. The rate-limited queue can
+  be used directly, and just requires catching the rate limit exception and pausing
+  the queue. There are also additional queues provided that already include the pause/retry
+  logic for Twitter, AngelList and Evernote; these allow you to support rate-limited
+  APIs with minimal changes.
 email:
 - mail@greddowling.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codelimate.yml"
 - ".gitignore"
 - ".hound.yml"
 - ".rspec"
 - ".rubocop.yml"
+- ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
-- circle.yml
 - lib/resque-rate_limited/version.rb
 - lib/resque/plugins/rate_limited/apis/angellist_queue.rb
 - lib/resque/plugins/rate_limited/apis/base_api_queue.rb
@@ -287,12 +138,7 @@ files:
 - lib/resque/plugins/rate_limited/rate_limited_un_pause.rb
 - lib/resque/rate_limited.rb
 - resque-rate_limited.gemspec
-- spec/apis/angellist_queue_spec.rb
-- spec/apis/evernote_queue_spec.rb
-- spec/apis/twitter_queue_spec.rb
-- spec/rate_limited_spec.rb
-- spec/rate_limited_un_pause_spec.rb
-- spec/spec_helper.rb
+- script/console
 homepage: http://github.com/Xenapto/resque-rate_limited
 licenses:
 - MIT
@@ -313,15 +159,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.7
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
-summary: A Resque plugin to help manage jobs that use rate limited apis, pausing when
+summary: A Resque plugin to help manage jobs that use rate-limited APIs, pausing when
   you hit the limits and restarting later.
 test_files:
-- spec/apis/angellist_queue_spec.rb
-- spec/apis/evernote_queue_spec.rb
-- spec/apis/twitter_queue_spec.rb
-- spec/rate_limited_spec.rb
-- spec/rate_limited_un_pause_spec.rb
-- spec/spec_helper.rb
+- script/console

data/circle.yml

@@ -1,10 +0,0 @@
-machine:
-  ruby:
-    version: 2.1.9
-  services:
-    - redis
-
-dependencies:
-  pre:
-    - echo "export rvm_ignore_gemsets_flag=1" >> ~/.rvmrc
-    - gem install bundler

data/spec/apis/angellist_queue_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-require 'resque/rate_limited'
-
-class RateLimitedTestQueueAL
-  def self.perform(succeed)
-    raise(AngellistApi::Error::TooManyRequests, 'error') unless succeed
-  end
-end
-
-describe Resque::Plugins::RateLimited::AngellistQueue do
-  before do
-    Resque::Plugins::RateLimited::AngellistQueue.stub(:paused?).and_return(false)
-  end
-
-  describe 'enqueue' do
-    it 'enqueues to the correct queue with the correct parameters' do
-      Resque.should_receive(:enqueue_to).with(
-        :angellist_api,
-        Resque::Plugins::RateLimited::AngellistQueue,
-        RateLimitedTestQueueAL.to_s,
-        true
-      )
-      Resque::Plugins::RateLimited::AngellistQueue
-        .enqueue(RateLimitedTestQueueAL, true)
-    end
-  end
-
-  describe 'perform' do
-    before do
-      Resque.inline = true
-    end
-    context 'with everything' do
-      it 'calls the class with the right parameters' do
-        RateLimitedTestQueueAL.should_receive(:perform).with('test_param')
-        Resque::Plugins::RateLimited::AngellistQueue
-          .enqueue(RateLimitedTestQueueAL, 'test_param')
-      end
-    end
-
-    context 'with rate limit exception' do
-      before do
-        Resque::Plugins::RateLimited::AngellistQueue.stub(:rate_limited_requeue)
-      end
-      it 'pauses queue when request fails' do
-        Resque::Plugins::RateLimited::AngellistQueue.should_receive(:pause_until)
-        Resque::Plugins::RateLimited::AngellistQueue
-          .enqueue(RateLimitedTestQueueAL, false)
-      end
-    end
-  end
-end

data/spec/apis/evernote_queue_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-require 'resque/rate_limited'
-
-class RateLimitDuration
-  def self.seconds
-    60
-  end
-end
-
-class RateLimitedTestQueueEn
-  def self.perform(succeed)
-    raise(
-      Evernote::EDAM::Error::EDAMSystemException,
-      errorCode: Evernote::EDAM::Error::EDAMErrorCode::RATE_LIMIT_REACHED,
-      rateLimitDuration: RateLimitDuration
-    ) unless succeed
-  end
-end
-
-class RateLimitedTestQueueOther
-  def self.perform
-    raise(Evernote::EDAM::Error::EDAMSystemException)
-  end
-end
-
-describe Resque::Plugins::RateLimited::EvernoteQueue do
-  before do
-    Resque::Plugins::RateLimited::EvernoteQueue.stub(:paused?).and_return(false)
-  end
-  describe 'enqueue' do
-    it 'enqueues to the correct queue with the correct parameters' do
-      Resque.should_receive(:enqueue_to).with(
-        :evernote_api,
-        Resque::Plugins::RateLimited::EvernoteQueue,
-        RateLimitedTestQueueEn.to_s,
-        true
-      )
-      Resque::Plugins::RateLimited::EvernoteQueue
-        .enqueue(RateLimitedTestQueueEn, true)
-    end
-  end
-
-  describe 'perform' do
-    before do
-      Resque.inline = true
-    end
-    context 'with everything' do
-      it 'calls the class with the right parameters' do
-        RateLimitedTestQueueEn.should_receive(:perform).with('test_param')
-        Resque::Plugins::RateLimited::EvernoteQueue
-          .enqueue(RateLimitedTestQueueEn, 'test_param')
-      end
-    end
-
-    context 'with rate limit exception' do
-      before do
-        Resque::Plugins::RateLimited::EvernoteQueue.stub(:rate_limited_requeue)
-      end
-      it 'pauses queue when request fails' do
-        Resque::Plugins::RateLimited::EvernoteQueue.should_receive(:pause_until)
-        Resque::Plugins::RateLimited::EvernoteQueue
-          .enqueue(RateLimitedTestQueueEn, false)
-      end
-    end
-
-    context 'with exception that is not rate limit' do
-      before do
-        Resque::Plugins::RateLimited::EvernoteQueue.stub(:rate_limited_requeue)
-      end
-      it 'raises the exception when request fails' do
-        expect do
-          Resque::Plugins::RateLimited::EvernoteQueue.enqueue(RateLimitedTestQueueOther)
-        end.to raise_error Evernote::EDAM::Error::EDAMSystemException
-      end
-    end
-  end
-end

data/spec/apis/twitter_queue_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-require 'resque/rate_limited'
-
-class RateLimitedTestQueueTw
-  def self.perform(succeed)
-    raise(Twitter::Error::TooManyRequests
-      .new('', 'x-rate-limit-reset' => (Time.now + 60).to_i)) unless succeed
-  end
-end
-
-describe Resque::Plugins::RateLimited::TwitterQueue do
-  before do
-    Resque::Plugins::RateLimited::TwitterQueue.stub(:paused?).and_return(false)
-  end
-
-  describe 'enqueue' do
-    it 'enqueues to the correct queue with the correct parameters' do
-      Resque.should_receive(:enqueue_to).with(
-        :twitter_api,
-        Resque::Plugins::RateLimited::TwitterQueue,
-        RateLimitedTestQueueTw.to_s,
-        true
-      )
-      Resque::Plugins::RateLimited::TwitterQueue
-        .enqueue(RateLimitedTestQueueTw, true)
-    end
-  end
-
-  describe 'perform' do
-    before do
-      Resque.inline = true
-    end
-    context 'with everything' do
-      it 'calls the class with the right parameters' do
-        RateLimitedTestQueueTw.should_receive(:perform).with('test_param')
-        Resque::Plugins::RateLimited::TwitterQueue
-          .enqueue(RateLimitedTestQueueTw, 'test_param')
-      end
-    end
-
-    context 'with rate limit exception' do
-      before do
-        Resque::Plugins::RateLimited::TwitterQueue.stub(:rate_limited_requeue)
-      end
-      it 'pauses queue when request fails' do
-        Resque::Plugins::RateLimited::TwitterQueue.should_receive(:pause_until)
-        Resque::Plugins::RateLimited::TwitterQueue
-          .enqueue(RateLimitedTestQueueTw, false)
-      end
-    end
-  end
-end

data/spec/rate_limited_spec.rb

@@ -1,243 +0,0 @@
-require 'spec_helper'
-require 'resque/rate_limited'
-
-class RateLimitedTestQueue
-  extend Resque::Plugins::RateLimited
-
-  @queue = :test
-
-  def self.perform(succeed)
-    rate_limited_requeue(self, succeed) unless succeed
-  end
-
-  def self.queue_name_private
-    @queue.to_s
-  end
-
-  def self.queue_private
-    @queue
-  end
-end
-
-describe Resque::Plugins::RateLimited do
-  it 'should be compliance with Resque::Plugin document' do
-    expect { Resque::Plugin.lint(Resque::Plugins::RateLimited) }.to_not raise_error
-  end
-
-  shared_examples_for 'queue' do |queue_suffix|
-    it 'should queue to the correct queue' do
-      queue_param = queue_suffix.empty? ? RateLimitedTestQueue.queue_private : "#{RateLimitedTestQueue.queue_name_private}#{queue_suffix}"
-      Resque.should_receive(:enqueue_to).with(queue_param, nil, nil)
-      RateLimitedTestQueue.rate_limited_enqueue(nil, nil)
-    end
-  end
-
-  context 'when queue is not paused' do
-    before do
-      RateLimitedTestQueue.stub(:paused?).and_return(false)
-    end
-
-    describe 'enqueue' do
-      include_examples 'queue', ''
-    end
-
-    describe 'paused?' do
-      it { RateLimitedTestQueue.paused?.should be false }
-    end
-
-    describe 'perform' do
-      it 'should requeue the job on failure' do
-        Resque.should_receive(:enqueue_to)
-        RateLimitedTestQueue.perform(false)
-      end
-
-      it 'should not requeue the job on success' do
-        Resque.should_not_receive(:enqueue_to)
-        RateLimitedTestQueue.perform(true)
-      end
-    end
-
-    describe 'pause' do
-      it 'should rename the queue to paused' do
-        Resque.redis.should_receive(:renamenx).with("queue:#{RateLimitedTestQueue.queue_name_private}", "queue:#{RateLimitedTestQueue.queue_name_private}_paused")
-        RateLimitedTestQueue.pause
-      end
-    end
-
-    describe 'un_pause' do
-      it 'should not unpause the queue' do
-        Resque.redis.should_not_receive(:renamenx).with("queue:#{RateLimitedTestQueue.queue_name_private}", "queue:#{RateLimitedTestQueue.queue_name_private}_paused")
-        RateLimitedTestQueue.un_pause
-      end
-    end
-
-    describe 'pause_until' do
-      before do
-        Resque.redis.stub(:renamenx).and_return(true)
-      end
-
-      it 'should pause the queue' do
-        RateLimitedTestQueue.should_receive(:pause)
-        RateLimitedTestQueue.pause_until(Time.now + (5 * 60 * 60))
-      end
-
-      it 'should schedule an unpause job' do
-        Resque::Plugins::RateLimited::UnPause.should_receive(:enqueue)
-                                                  .with(nil, 'RateLimitedTestQueue')
-        RateLimitedTestQueue.pause_until(nil)
-      end
-    end
-  end
-
-  context 'when queue is paused' do
-    before do
-      RateLimitedTestQueue.stub(:paused?).and_return(true)
-    end
-
-    describe 'enqueue' do
-      include_examples 'queue', '_paused'
-    end
-
-    describe 'paused?' do
-      it { RateLimitedTestQueue.paused?.should be true }
-    end
-
-    describe 'perform' do
-      it 'should not execute the block' do
-        Resque.should_receive(:enqueue_to).with("#{RateLimitedTestQueue.queue_name_private}_paused", RateLimitedTestQueue, true)
-        RateLimitedTestQueue.should_not_receive(:perform)
-        RateLimitedTestQueue.around_perform_with_check_and_requeue(true)
-      end
-    end
-
-    describe 'un_pause' do
-      it 'should rename the queue to live' do
-        Resque.redis.should_receive(:renamenx).with("queue:#{RateLimitedTestQueue.queue_name_private}_paused", "queue:#{RateLimitedTestQueue.queue_name_private}")
-        RateLimitedTestQueue.un_pause
-      end
-    end
-  end
-
-  describe 'when queue is paused and Resque is in inline mode' do
-    let(:resque_prefix) { Resque::Plugins::RateLimited::RESQUE_PREFIX }
-    let(:queue) { resque_prefix + RateLimitedTestQueue.queue_name_private }
-    let(:paused_queue) { resque_prefix + RateLimitedTestQueue.paused_queue_name }
-
-    before do
-      Resque.redis.stub(:exists).with(queue).and_return(false)
-      Resque.redis.stub(:exists).with(paused_queue).and_return(true)
-      Resque.inline = true
-    end
-
-    after do
-      Resque.inline = false
-    end
-
-    it 'would be paused' do
-      expect(Resque.redis.exists(queue)).to eq false
-      expect(Resque.redis.exists(paused_queue)).to eq true
-    end
-
-    it 'says it is not paused' do
-      expect(RateLimitedTestQueue.paused?).to eq false
-    end
-
-    it 'performs the job' do
-      expect do
-        # Stack overflow unless handled
-        RateLimitedTestQueue.rate_limited_enqueue(RateLimitedTestQueue, true)
-      end.not_to raise_error
-    end
-  end
-
-  describe 'find_class' do
-    it 'works with symbol' do
-      RateLimitedTestQueue.find_class(RateLimitedTestQueue).should eq RateLimitedTestQueue
-    end
-
-    it 'works with simple string' do
-      RateLimitedTestQueue.find_class('RateLimitedTestQueue').should eq RateLimitedTestQueue
-    end
-
-    it 'works with complex string' do
-      RateLimitedTestQueue.find_class('Resque::Plugins::RateLimited').should eq Resque::Plugins::RateLimited
-    end
-  end
-
-  context 'with redis errors' do
-    before do
-      RateLimitedTestQueue.stub(:paused?).and_return(true)
-    end
-    context 'with not found error' do
-      before do
-        Resque.redis.stub(:renamenx).and_raise(Redis::CommandError.new('ERR no such key'))
-      end
-
-      describe 'pause' do
-        it 'should not throw exception' do
-          expect { RateLimitedTestQueue.pause }.to_not raise_error
-        end
-      end
-
-      describe 'un_pause' do
-        it 'should not throw exception' do
-          expect { RateLimitedTestQueue.un_pause }.to_not raise_error
-        end
-      end
-    end
-
-    context 'with other errror' do
-      before do
-        Resque.redis.stub(:renamenx).and_raise(Redis::CommandError.new('ERR something else'))
-      end
-
-      describe 'pause' do
-        it 'should throw exception' do
-          expect { RateLimitedTestQueue.pause }.to raise_error(Redis::CommandError)
-        end
-      end
-
-      describe 'un_pause' do
-        it 'should throw exception' do
-          expect { RateLimitedTestQueue.un_pause }.to raise_error(Redis::CommandError)
-        end
-      end
-    end
-  end
-
-  describe 'paused?' do
-    context 'with paused queue' do
-      before do
-        Resque.redis.stub(:exists).with("queue:#{RateLimitedTestQueue.queue_name_private}_paused").and_return(true)
-        Resque.redis.stub(:exists).with("queue:#{RateLimitedTestQueue.queue_name_private}").and_return(false)
-      end
-
-      it 'should return the true if the paused queue exists' do
-        expect(RateLimitedTestQueue.paused?).to eq(true)
-      end
-    end
-
-    context 'with un paused queue' do
-      before do
-        Resque.redis.stub(:exists).with("queue:#{RateLimitedTestQueue.queue_name_private}_paused").and_return(false)
-        Resque.redis.stub(:exists).with("queue:#{RateLimitedTestQueue.queue_name_private}").and_return(true)
-      end
-
-      it 'should return the false if the main queue exists exist' do
-        expect(RateLimitedTestQueue.paused?).to eq(false)
-      end
-    end
-
-    context 'with unknown queue state' do
-      before do
-        Resque.redis.stub(:exists).with("queue:#{RateLimitedTestQueue.queue_name_private}_paused").and_return(false)
-        Resque.redis.stub(:exists).with("queue:#{RateLimitedTestQueue.queue_name_private}").and_return(false)
-      end
-
-      it 'should return the default' do
-        expect(RateLimitedTestQueue.paused?(true)).to eq(true)
-        expect(RateLimitedTestQueue.paused?(false)).to eq(false)
-      end
-    end
-  end
-end

data/spec/rate_limited_un_pause_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-require 'resque/rate_limited'
-
-class RateLimitedTestQueue
-end
-
-describe Resque::Plugins::RateLimited::UnPause do
-  describe 'perform' do
-    it 'unpauses the queue' do
-      RateLimitedTestQueue.should_receive(:un_pause)
-      Resque::Plugins::RateLimited::UnPause.perform(RateLimitedTestQueue)
-    end
-  end
-
-  describe 'enqueue' do
-    before { Resque.stub(:respond_to?).and_return(true) }
-    context 'with no queue defined' do
-      it 'does not queue the job' do
-        Resque.should_not_receive(:enqueue_at_with_queue)
-        Resque::Plugins::RateLimited::UnPause.enqueue(Time.now, RateLimitedTestQueue)
-      end
-    end
-
-    context 'with queue defined' do
-      before { Resque::Plugins::RateLimited::UnPause.queue = :queue_name }
-      it 'queues the job' do
-        Resque.should_receive(:enqueue_at_with_queue).with(
-          :queue_name,
-          nil,
-          Resque::Plugins::RateLimited::UnPause,
-          RateLimitedTestQueue
-        )
-
-        Resque::Plugins::RateLimited::UnPause.enqueue(nil, RateLimitedTestQueue)
-      end
-    end
-  end
-
-  describe 'class_from_string' do
-    it 'converts unqualified classes' do
-      expect(Resque::Plugins::RateLimited::UnPause.class_from_string(RateLimitedTestQueue.to_s))
-        .to eq(RateLimitedTestQueue)
-    end
-    it 'converts qualified classes' do
-      expect(Resque::Plugins::RateLimited::UnPause.class_from_string(Resque::Plugins::RateLimited::UnPause.to_s))
-        .to eq(Resque::Plugins::RateLimited::UnPause)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,18 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-
-require 'rspec'
-require 'redis-classy'
-require 'redis-mutex'
-
-require 'simplecov'
-
-SimpleCov.start
-
-RSpec.configure do |_config|
-  # Use database 15 for testing so we don't accidentally step on your real data.
-  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