kthxbye 1.0.1 → 1.0.2

data/VERSION

@@ -1 +1 @@
-1.0.1
+1.0.2

data/config.ru

@@ -4,4 +4,4 @@ $LOAD_PATH.unshift ::File.expand_path(::File.dirname(__FILE__) + '/lib')
 require 'kthxbye'
 require 'kthxbye/web_interface'
 
-Kthxbye::WebInterface.run! :host => "localhost", :port => 4567
+Kthxbye::WebInterface.run! :host => ARGV[0], :port => ARGV[1]

data/lib/kthxbye.rb

@@ -18,15 +18,58 @@ require 'kthxbye/version'
 
 require 'kthxbye/exceptions'
 
+# Kthxbye is a light-weight, distributed delayed-job processor. It is meant
+# to take the load of long running processes off of your web-server any place 
+# it in the capable hands of a backend processor. It is unique in that it 
+# provides results delievery post-processing so that your front-end can actually
+# have its results back. 
+#
+# Most delayed job processors out there are meant for running processes that we
+# don't need to get a result from. For example mass-mailings or image processing.
+# However I've found many a case in which I need the result of a long process but
+# my web server is bogging down watiting for a response.
+#
+# And this is where Kthxbye shines.
+#
+# Okay, you say, enough glowing, let's see this thinger work. Simple enough.
+#
+# On your front-end (e.g. a Rails app) initialization process, run
+#   Kthxbye::Config.setup(:redis_server => "localhost", :redis_port => 9876)
+#
+# Then somewhere accessable to both your app and your workers (maybe a separate
+# job class file in you /lib dir) create your job class with a class method
+# perform:
+#   class MyJob
+#     def self.perform(param1, param2)
+#       puts "I'm here with data!"
+#       # perform stuff with data
+#       result = param1 + param2
+#       return result
+#     end
+#   end
+# 
+# Then all that's left is to queue up the job at the appropriate time:
+#   Kthxbye.enqueue("job-queue", MyJob, 6, 4)
+# 
+# Your job is now queued for processing! To work this job, its even simpler.
+#   require 'whatever/file/my_job/class/is/in'
+#   worker = Kthxbye::Worker.new("job-queue")
+#   worker.run
+#
+# Let the processing commence!
 module Kthxbye
   include Helper
   extend self
 
-  #takes in an existing redis instance or simply connects a new instance
+  # This is not necessary to call. Any of the methods that use redis
+  # Will make an inital call to connect to redis.
+  # Useful if you want to connect to an existing redis instance. Othewise, if 
+  # called without params, it simply connects a new instance of redis.
   def connect( redis_instance=nil )
     @redis = ( redis_instance || Redis.new( :host => Config.options[:redis_server], :port => Config.options[:redis_port] ) )
   end
 
+  # Returns the Redis instance for direct calls to the Redis db
   def redis
     return @redis if @redis
     Config.setup
@@ -34,22 +77,32 @@ module Kthxbye
     self.redis
   end
 
+  # Returns a hash of all existing Redis keys.
   def keys
     redis.keys("*")
   end
 
-  # 
+  # Queues jobs. Takes at minimum two paramters
+  #   1) A string representing a queue
+  #   2) The class of the job being queued.
+  #
+  # You can optionally pass in additional params to the perform method within
+  # the class. You will need to match the number of args in the perform method
+  # when you queue the job. Otherwise this will throw an exception.
   def enqueue(queue, klass, *args)
     Job.create(queue, klass, *args)    
   end
 
-  # gets the size of a given queue
+  # Takes a string that represents a job queue.
+  # Returns the size of the given queue.
   def size(queue)
     redis.llen("queue:#{queue}").to_i
   end
 
-  # gets the latest latest job off the given queue
-  # returns a Job object
+  # This method is used mostly internally to pop the next job off of the given
+  # queue. It takes in a string representing a queue and will return a 
+  # Kthxbye::Job object if a job exists on the queue. This is destructive on
+  # the queue as it will REMOVE the next job off queue and return the job object.
   def salvage(q)
     id = redis.lpop( "queue:#{q}" ) 
     if id 
@@ -61,8 +114,12 @@ module Kthxbye
     end
   end
 
-  # lets us peek at the data to be run with a job
-  # can lookup an entire queue or for a specific job id
+  # This is a generic queue peek method. It isn't used directly but is the basis
+  # for the "ghost" methods "data_peek" and "result_peek". This method takes in
+  # a string representing a redis hash store (only two in kthxbye: "data-store"
+  # and "result-store"), a string representing a queue, and optionally a job id.
+  # If a job id is given, it will return the data for that job only. Otherwise
+  # it returns all the data for all jobs/results.
   def peek(store, queue, id=nil)
     if id
       decode( redis.hget( "#{store}-store:#{queue}", id ) )
@@ -74,8 +131,7 @@ module Kthxbye
     end
   end
 
-  # handles a few of our dynamic methods
-  def method_missing(name, *args) 
+  def method_missing(name, *args) #:nodoc:
     method_name = name.id2name
     if method_name =~ /^(data|result)_peek$/
       Kthxbye.send(:peek, $1, *args)
@@ -85,36 +141,45 @@ module Kthxbye
 
   end
 
-  # returns all the queues Kthxbye knows about
+  # Returns all the queues Kthxbye knows about
   def queues
     redis.smembers( :queues ).sort
   end
 
-  # registers the queue in our "known queues" list
+  # This method takes a string and registers it as a queue in our "known queues" 
+  # list
   def register_queue(queue)
     redis.sadd(:queues, queue) unless redis.sismember(:queues, queue)
   end
 
-  # Removes the queue from the active queue listing, does not delete queue
-  # will lead to phantom queues. use delete_queue for complete removal of queue
+  # Removes the queue from the active queue listing, does not delete queue.
+  # This will lead to phantom queues. use delete_queue for complete removal 
+  # of queue.
   def unregister_queue(queue)
     redis.srem(:queues, queue)
   end
 
-  # Completely removes queue: unregisters it then deletes it
-  # should return true in all cases
+  # Completely removes queue: Unregisters it then deletes it should return true 
+  # in all cases (including if we try to delete a non-existent queue).
   def delete_queue(queue)
     unregister_queue(queue)
     redis.del( "queue:#{queue}" ) || true 
   end
 
-  # returns all our registered workers
+  # Returns all workers registered with Kthxbye by the Kthxbye::Worker class.
+  # Special note: Workers are only registered once you call #run on the worker.
+  # You may also run #register_worker on the worker to manually register it, but
+  # this also occurs once the worker is run so there is no need to run this 
+  # manually.
   def workers
     workers = redis.smembers( :workers )
     workers.map {|x| Worker.find( x ) }
   end
 
-  # returns all our active workers and the job they are working
+  # Returns all of the workers that are currently working a job.
+  # Also returns the job id and started time of the worker as a hash as follows:
+  #
+  #   [worker_id, {:job_id, :started}]
   def working
     workers = redis.smembers( :working ) 
     data = []
@@ -124,8 +189,9 @@ module Kthxbye
     return data
   end
 
-  # returns either the job results for a specific job (if id specified)
-  # or all the results for all the jobs on a queue
+  # Returns either the job results for a specific job (if id specified).
+  # If a job is not specified, it returns all the job results for the given
+  # queue.
   def job_results(queue, id=nil)
     if id
       decode( redis.hget( "result-store:#{queue}", id ) )
@@ -134,6 +200,7 @@ module Kthxbye
     end
   end
 
+  # Returns a pretty inspect message about this instance of Kthxbye.
   def inspect
     {
       :version => Version,

data/lib/kthxbye/config.rb

@@ -1,31 +1,32 @@
 module Kthxbye
+  # This module handles the setting and retrival of configuration options for
+  # Kthxbye.
   module Config
 
-    # default options for Kthxbye
-    #
-    # redis_server = the ip to connect to by defaut
-    # 
-    # redis_port = default redis port
-    # 
-    # attempts = default number of attempts on a failing job
-    # before moving to the failed job store
-    #
-    # vervose = more output 
+    # Default options for Kthxbye 
     #
+    # * redis_server = "127.0.0.1" - the ip to connect to by defaut
+    # * redis_port = 9876 - default redis port
+    # * attempts = 1 -default number of attempts on a failing job before a Failure
+    # is generated 
+    # * vervose = false - more output in the worker log
     DEFAULT = {:redis_server => '127.0.0.1',
       :redis_port => 9876,
       :attempts => 1,
       :verbose => false}.freeze
     
-    # configures any other args input by the user. 
-    # can pull from a config.yaml file as well.
-    #
+    # This method takes override args input by the user. 
+    # Can pull from a config/kthxbye.yaml file as well. 
+    # 
+    # NEEDS TO BE REWORKED FOR RAILS APPS
     def self.setup( args=nil )
       @options = DEFAULT.dup
-      @options.merge!( YAML.load('config.yaml') ) if File.exist?( 'config.yaml' )
+      @options.merge!( YAML.load('./config/kthxbye.yaml') ) if File.exist?( './config/kthxbye.yaml' )
       @options.merge!( args ) if args
     end
 
+    # Quick access to the options hash. Works for setting individual options 
+    # during runtime.
     def self.options
       return @options if @options
       Config.setup

data/lib/kthxbye/exceptions.rb

@@ -1,4 +1,4 @@
 module Kthxbye
-  # raised when a worker is killed during processing
+  # Raised when a worker is killed during processing
   class ActiveWorkerKilled < RuntimeError; end
 end

data/lib/kthxbye/helper.rb

@@ -1,10 +1,8 @@
 module Kthxbye
-  module Helper
-
+  module Helper #:nodoc: all
     def redis
       Kthxbye.redis
     end
-
     def log(msg)
       if Kthxbye::Config.options[:verbose]
         puts "!! #{msg} - #{Time.now.strftime("%I:%M%p")}"

data/lib/kthxbye/job.rb

@@ -1,4 +1,7 @@
 module Kthxbye
+
+  # This class is our main job runner. It also handles the instantiation and
+  # the meat of the job queuing and retreival. 
   class Job
     include Helper
     extend Helper
@@ -6,11 +9,18 @@ module Kthxbye
     attr_accessor :id, :queue, :data, :worker
     attr_reader :failed_attempts
 
-    def self.add_to_queue(queue, id)
+    # Adds a job to the queue from a given job id
+    # and queue. useful for switching a job to another queue or adding a defined
+    # job to multiple queues.
+    def self.add_to_queue(id, queue)
       redis.rpush( "queue:#{queue}", id )
     end
 
-    # insert a job into the queue
+    # The bulk of the job queuing method. Takes a string representing a queue
+    # name, a job class, and arguments to pass to the perform method of the 
+    # job class. Returns a unique id for the job based on a redis "uniq_id" key
+    # (int) which is a simple incremented value. Queues the job in the given 
+    # queue and the job in the data-store hash.
     def self.create(queue, klass, *args)
       raise "Need a queue to store job in" if queue.to_s.empty?
       raise "No class to reference job type by" if klass.nil?
@@ -20,20 +30,23 @@ module Kthxbye
 
       Job.add_to_queue( queue, id )
       Kthxbye.register_queue( queue )
-      
+     
+      # mark job as inactive currently. will mark active when job is getting run
+      redis.redis.sadd("jobs:inactive", id)
       redis.hset( "data-store:#{queue}", id, encode( {:klass => klass, :payload => args} ) )
       log "Created job in queue #{queue} with an unique key of #{id}"
 
       return id.to_i
     end
 
+    # Returns a job object for a given job id off of a given queue.
     def self.find(id, queue)
       data = decode( redis.hget( "data-store:#{queue}", id ) )
       data ? Job.new(id, queue, data) : nil
     end
     
-    # removes all existence of this job and its data
-    # returns the last known status of the job
+    # Removes all existence of this job and its data
+    # Returns the last known status of the job
     def self.destroy(id, queue)
       ret = Job.find(id, queue).status
 
@@ -49,7 +62,9 @@ module Kthxbye
       return ret
     end
 
-    # instantiates a job for the worker to run
+    # Instantiates a job from a job id, a queue, and the job data.
+    # Most often used in the ::find method and for the worker to recreate
+    # the job for running.
     def initialize(id, queue, data)
       @id = id.to_i
       @queue = queue
@@ -57,11 +72,16 @@ module Kthxbye
       @failed_attempts =  Failure.fails_for_job(@id) # local tracking only, for rerun purposes
     end
 
-    # simply requeues a job
+    # Simply requeues the job to be rerun.
     def rerun
       Job.add_to_queue( @queue, @id )
     end
 
+    # Returns the job's status. Will be one of 4 things.
+    #   1) :succeeded - the job ran and has a result
+    #   2) :failed - the job failed and reported an error
+    #   3) :active - job is being run.
+    #   4) :inactive - job is waiting to be run.
     def status
       if result
         :succeeded
@@ -74,28 +94,34 @@ module Kthxbye
       end
     end
 
+    # Returns the job's result once it has been run.
     def result
       decode( redis.hget("result-store:#{@queue}", @id) )
     end
 
-    # simply removes this job from the active queue and places it
-    # on the inactive list.
-    # does not remove job payload
+    # Simply removes this job from the active queue and places it
+    # on the inactive list. Does not remove job payload from storage. It just
+    # removes its id from the actively run job queue.
     def dequeue
       redis.lrem("queue:#{@queue}", 0, @id) 
       inactive
     end
   
-    # does the heavy lifting of running a job
+    # Does all the heavy lifting of performing the job and storing the results.
+    # It will get the jobs class, payload and then run the job, storing the
+    # result in the result's store once complete. Also responsible for reporting
+    # errors and storing the job in the failure listing if an exception occurs.
     def perform
       begin
         @klass = Object.const_get(@data['klass'])
         @payload = @data['payload']
+        #set job active, getting ready to run
+        self.active
 
         result = @klass.send(:perform, *@payload)
         redis.hset( "result-store:#{@queue}", @id, encode( result ) )
         return result
-      rescue Exception => ex
+      rescue Object => ex
         @failed_attempts += 1
         log "Error occured: #{ex.message}. Try: #{@failed_attempts}/#{Kthxbye::Config.options[:attempts]}"
         return Kthxbye::Failure.create( self, ex ) if @failed_attempts >= Kthxbye::Config.options[:attempts]
@@ -103,7 +129,7 @@ module Kthxbye
       end
     end
 
-    # will allow us to track when this job is being worked
+    # Removes the job from the inactive queue.
     def active
       redis.srem("jobs:inactive", @id)
     end
@@ -112,11 +138,12 @@ module Kthxbye
       !redis.sismember("jobs:inactive", @id)
     end
 
+    # Places the job on the active queue
     def inactive
       redis.sadd("jobs:inactive", @id)
     end
 
-    def ==(obj)
+    def ==(obj) #:nodoc:
       return false if obj.nil?
       @data == obj.data &&
         @id == obj.id &&

data/lib/kthxbye/version.rb

@@ -1,5 +1,5 @@
 module Kthxbye
-  # may be a bad idea if only lib dir is installed...
+  # Returns current version of Kthxbye
   Version = VERSION = File.read(File.dirname(__FILE__)+'/../../VERSION').chomp
 end
 

data/lib/kthxbye/web_interface.rb

@@ -3,7 +3,7 @@ require 'haml'
 require 'kthxbye'
 
 module Kthxbye
-  class WebInterface < Sinatra::Base
+  class WebInterface < Sinatra::Base #:nodoc: all
     base = File.dirname( File.expand_path(__FILE__) )
 
     set :views, "#{base}/web_interface/views"

data/lib/kthxbye/worker.rb

@@ -1,16 +1,24 @@
 module Kthxbye
+  # This is the workhorse loop of the gem. Does all the dequeuing and running of jobs.
+  # It mostly makes a bunch of calls to the job methods to run the job. It simply handles
+  # the spawning off of processes to run the job and retry if necessary.
   class Worker
     include Helper
     extend Helper
 
     attr_accessor :sleep_for, :queues, :current_queue, :id
 
+    # Creates a worker for running jobs off of a given queue.
+    # Takes a queue or queues (csv style, e.g. test,other,bad) or the woldcard 
+    # (*) symbol to take in all queues in alphabetical order.
+    # Optionally takes in an interval param on how long it waits to check the
+    # queue for new jobs once it has exhausted the queue(s).
     def initialize(queues, sleep_for=5)
       setup_queues(queues)
       @sleep_for = sleep_for
     end
 
-    def setup_queues(queues) 
+    def setup_queues(queues) # :nodoc:
       if queues == "*"
         @queues = Kthxbye.queues.sort
       elsif queues.include? ?,
@@ -20,6 +28,8 @@ module Kthxbye
       end
     end
 
+    # Allows us to find a worker so that we can look at some of its internal data
+    # later on.
     def self.find(worker)
       if exists? worker
         qs = worker.split(':')[-1].split(",")
@@ -31,20 +41,21 @@ module Kthxbye
       end
     end
 
+    # Checks if a worker is registered.
     def self.exists?(id)
       redis.sismember( :workers, id )
     end
 
-    # gets the job a given worker is working on
-    # returns a hash with the 'job_id' and the 'started' time
+    # Gets the job a given worker is working on
+    # Returns a hash with the 'job_id' and the 'started' time
     def self.working_on(id)
       decode( redis.get( "worker:#{id}" ) )
     end
 
-    # major run loop. workhorse of a worker... sort of.
-    # in the end, this loop simply runs the jobs in separate
-    # processes by forking out the process then waiting for it
-    # to return. we only process one 
+    # This is the major run loop. Workhorse of a worker... sort of.
+    # In the end, this loop simply runs the jobs in separate processes by forking
+    # out the process then waiting for it to return. we only process one.
+    # Can optionally take in a block to run after the job has run.
     def run(&block)
       log "Starting Kthxbye::Worker #{self}"
       startup
@@ -75,23 +86,24 @@ module Kthxbye
       unregister_worker
     end
 
+    # Returns the queues this worker is attached toin alphabetical order.
     def queues
       @queues.sort
     end
 
-    # startup actions
-    def startup
+    # Run startup actions
+    def startup #:nodoc:
       register_worker
       register_signals
     end
 
-    # adds worker to the workers list
+    # Adds this worker to the worker registry
     def register_worker
       log "Registered worker #{self}"
       redis.sadd( :workers, self ) if !exists?
     end
 
-    # removes the worker from our workers list
+    # Removes the worker from our worker registry
     def unregister_worker
       log "Unregistered worker #{self}"
       if working?
@@ -104,14 +116,15 @@ module Kthxbye
       redis.srem :workers, self
     end
     
+    # Gets the current job this worker is working.
     def current_job
       return @current_job if @current_job
       data = decode( redis.get("worker:#{self}") )
       @current_job = Job.find( data['job_id'], @current_queue )
     end
 
-    # start working actions
-    def working(job)
+    # Run when the job starts running
+    def working(job) #:nodoc:
       redis.sadd( :working, self )
 
       data = encode( {:job_id => job.id, :started => Time.now.to_s} )
@@ -122,13 +135,13 @@ module Kthxbye
       job.active
     end
 
-    # must be in working list and have a current job
+    # Is this job working?
     def working? 
       redis.sismember( :working, self )
     end
 
     # job complete actions
-    def done
+    def done #:nodoc:
       redis.srem( :working, self )
       redis.del( "worker:#{self}" )
       log "Completed job #{@current_job}"
@@ -138,7 +151,7 @@ module Kthxbye
     #
     # thanks to http://github.com/defunkt/resque/blob/master/lib/resque/worker.rb for these signals
     #
-    def register_signals
+    def register_signals #:nordoc:
       trap('TERM') { shutdown! }
       trap('INT')  { shutdown! }
 
@@ -154,17 +167,19 @@ module Kthxbye
       log "Registered signals"
     end 
 
-    def shutdown
+    # Shuts down the worker gracefully (once process has completed
+    def shutdown #:nodoc:
       log "Shutting down worker #{self}"
       @terminate = true
     end
 
-    def shutdown!
+    # Hard kills the worker by killing the process.
+    def shutdown! #:nodoc:
       kill_child
       shutdown
     end
 
-    def kill_child
+    def kill_child #:nodoc:
       if @child
         log "Killing child at #{@child}"
         if system("ps -o pid,state -p #{@child}")
@@ -176,7 +191,8 @@ module Kthxbye
       end
     end
 
-    def grab_job
+    # Reserves a job off the queue
+    def grab_job #:nodoc:
       job = nil
       @queues.each do |q|
         @current_queue = q
@@ -188,32 +204,38 @@ module Kthxbye
       return job || false
     end
 
-    def exists?
+    # Checks if this worker is registered.
+    def exists? #:nodoc:
       redis.sismember( :workers, self )
     end
 
+    # Returns the hostname of the machine this worker is running on
     def hostname
       @hostname ||= `hostname`.chomp
     end
 
+    # Returns the process id of this worker.
     def pid
       Process.pid
     end
 
+    # Returns a useful id with the hostname:pid:queues listing 
+    # Same return as to_s
     def id
       @id ||= "#{hostname}:#{pid}:#{queues.join(",")}"
     end
     alias_method :to_s, :id
 
+    # nice inspect for the worker with the same info as #id
     def inspect
       "#<Worker: #{@id}>"
     end
 
-    def ==(other)
+    def ==(other) #:nodoc:
       to_s == other.to_s
     end
 
-    def <=>(other)
+    def <=>(other) #:nodoc:
       to_s <=> other.to_s
     end
 

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: kthxbye
 version: !ruby/object:Gem::Version 
-  hash: 21
   prerelease: false
   segments: 
   - 1
   - 0
-  - 1
-  version: 1.0.1
+  - 2
+  version: 1.0.2
 platform: ruby
 authors: 
 - Luke van der Hoeven
@@ -15,112 +14,105 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-23 00:00:00 -04:00
+date: 2010-09-24 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  prerelease: false
   name: redis
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
-  requirement: *id001
   type: :runtime
-- !ruby/object:Gem::Dependency 
   prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
   name: yajl-ruby
-  version_requirements: &id002 !ruby/object:Gem::Requirement 
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
-  requirement: *id002
   type: :runtime
-- !ruby/object:Gem::Dependency 
   prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
   name: sinatra
-  version_requirements: &id003 !ruby/object:Gem::Requirement 
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
-  requirement: *id003
   type: :runtime
-- !ruby/object:Gem::Dependency 
   prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
   name: shoulda
-  version_requirements: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
-  requirement: *id004
   type: :development
-- !ruby/object:Gem::Dependency 
   prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
   name: bundler
-  version_requirements: &id005 !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 23
         segments: 
         - 1
         - 0
         - 0
         version: 1.0.0
-  requirement: *id005
   type: :development
-- !ruby/object:Gem::Dependency 
   prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
   name: jeweler
-  version_requirements: &id006 !ruby/object:Gem::Requirement 
+  requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 270495430
         segments: 
         - 1
         - 5
         - 0
         - pre3
         version: 1.5.0.pre3
-  requirement: *id006
   type: :development
-- !ruby/object:Gem::Dependency 
   prerelease: false
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
   name: rcov
-  version_requirements: &id007 !ruby/object:Gem::Requirement 
+  requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
-  requirement: *id007
   type: :development
+  prerelease: false
+  version_requirements: *id007
 description: "Kthxbye is the answer to a fairly unique-yet-common problem: Background job processing when we care about the result."
 email: hungerandthirst@gmail.com
 executables: []
@@ -185,7 +177,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 387221811
       segments: 
       - 0
       version: "0"
@@ -194,7 +186,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"