when-do 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b2fb127851bb13ec2d4211aeaa3f0e8c8dd8fb0e
+  data.tar.gz: 4bd1dab3156b0e7cc905f563594d586a1632db32
+SHA512:
+  metadata.gz: 363a63837074ccd823fe7caaa000c56cffcebbe0ad09d584da0b05d0a42f138dead9fbc07762ee27bd9075e2b3d53ada2065386b89e3ab137c154d88c7614e8e
+  data.tar.gz: 7ec2a8f9e72ecf1e6a629d500d1df66950e9b10dce13cadd00d96d572a40718ffa95121fa15fcaeb6723cf057ccdaf625d294f6234d2d90d1b658c020024075d

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+logs
+log
+config/*.yml

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+# Specify your gem's dependencies in when.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,5 @@
+guard :rspec, all_after_pass: true, all_on_start: true do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 TH
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,77 @@
+# When-do
+
+Reads schedules from Redis and moves them onto a Redis list at the correct time.
+
+Supports
+
+* Dynamic cron schedules
+* Delayed queueing
+
+Schedules are not cached and can be changed at will. Redundant processes can run without duplication of jobs as long as they point to the same Redis. Jobs will not be double-queued when DST resets time backwards, but will be skipped when DST moves time forward. Leap seconds should be fine.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'when-do'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install when-do
+
+## Usage
+From your project's main directory:
+
+    $ when-do -init
+
+Rename the example config and tweak as needed. For example, try setting your ```:worker_queue_key: 'queues:default'``` so Sidekiq picks up your jobs. Use symbols for all keys in the config.
+
+Then run in your console with default config:
+
+    $ when-do
+
+Or start a daemon that uses your config file and writes a pid file.
+
+    $ when-do -d -c 'config/when.yml' -e development
+
+I'd recommend using Monit to manage and monitor daemons. When-do is designed to let a different process handle failure notifications/restarting.
+
+Then, from your app...
+
+Queue a job now:
+
+    When.enqueue(WorkerClass, args, more_args, ...)
+
+Queue a job later (minute precision):
+
+    When.enqueue_at(Time.now + 60, WorkerClass, args, more_args, ...)
+
+Schedule a job (only numbers are supported in cron strings):
+
+    When.schedule('schedule_name', '0 * * * *', WorkerClass, args, more_args, ...)
+
+Unschedule a job:
+
+    When.unschedule('schedule_name')
+
+Clear schedules:
+
+    When.unschedule_all
+
+Check schedules:
+
+    When.schedules
+
+On my 2013 Macbook Air, 100k schedules can be analyzed in <3 seconds.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/when-do

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/when-do/cli'
+require_relative '../lib/when-do/do'
+
+cli = When::CLI.new
+cli.init
+When::Do.new(cli.options).start_loop

data/config/when.yml.example

@@ -0,0 +1,8 @@
+:development:
+  :schedule_key:      'when:schedules'
+  :worker_queue_key:  'when:queue:default'
+  :delayed_queue_key: 'when:delayed'
+  :log_path:          'log/when-do.log'
+  :log_level:         1
+  # :pid_file_path:     'tmp/pids/when-do.pid'
+  # :redis_config_path:      'config/redis.yml'

data/lib/when-do/cli.rb

@@ -0,0 +1,101 @@
+require 'when-cron'
+require 'json'
+require 'yaml'
+require 'redis'
+
+module When
+  class CLI
+    CANONICAL_KEYS = {
+      :sk => :schedule_key,
+      :wq => :worker_queue_key,
+      :dq => :delayed_queue_key,
+      :lp => :log_path,
+      :ll => :log_level,
+      :c  => :config_path,
+      :rc => :redis_config_path,
+      :d  => :daemonize,
+      :e  => :environment,
+      :pf => :pid_file_path
+    }
+
+    def init
+      cl_opts = canonicalize_keys(argv_to_hash)
+      copy_example_config if cl_opts.has_key? :init
+      @options = merge_redis_config_file(merge_config_file(cl_opts))
+    end
+
+    def options
+      @options ||= init
+    end
+
+    private
+
+    def copy_example_config
+      bin_path = File.expand_path(File.dirname(__FILE__))
+      system('mkdir config')
+      if system("cp #{bin_path}/../../config/when.yml.example config/")
+        puts "Example config copied to /config/when.yml.example"
+      else
+        puts 'Failed to copy example config.'
+      end
+      exit
+    end
+
+    def argv
+      ARGV
+    end
+
+    def argv_to_hash
+      argv.each.with_index.inject({}) do |opts, (arg, i)|
+        if arg[0] == '-'
+          values = argv_values_for(i)
+          key = arg.gsub(/\A-*/, '').to_sym
+          if values.count <= 1
+            opts[key] = values.first
+          else
+            opts[key] = values
+          end
+        end
+        opts
+      end
+    end
+
+    def argv_values_for(key_index)
+      first_val = key_index + 1
+      argv[first_val..-1].each_with_index do |arg, i|
+        return argv[first_val...first_val + i] if arg[0] == '-'
+      end
+    end
+
+    def canonicalize_keys(commandline_opts)
+      commandline_opts.inject({}) do |opts, (k, v)|
+        if new_key = CANONICAL_KEYS[k]
+          opts[new_key] = v
+        else
+          opts[k] = v
+        end
+        opts
+      end
+    end
+
+    def merge_config_file(commandline_opts)
+      config_path = commandline_opts[:config_path]
+      file_config = load_opts(config_path)
+      env         = commandline_opts[:environment] || :development
+      file_opts   = file_config[env.to_sym]        || {}
+      file_opts.merge(commandline_opts)
+    end
+
+    def merge_redis_config_file(merged_opts)
+      merged_opts.merge(redis_opts: load_opts(merged_opts[:redis_config_path]))
+    end
+
+    def load_opts(path)
+      if path
+        YAML.load(File.read(path))
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/when-do/do.rb

@@ -0,0 +1,153 @@
+require 'when-cron'
+require 'json'
+require 'redis'
+require 'logger'
+
+module When
+  class Do
+    attr_reader :schedule_key, :worker_queue_key, :delayed_queue_key, :redis, :logger, :pid_file_path
+
+    def initialize(opts={})
+      @logger            = init_logger(opts[:log_path], opts[:log_level])
+
+      Process.daemon(true) if opts.has_key?(:daemonize)
+
+      @pid_file_path = opts[:pid_file_path]
+      if pid_file_path
+        File.open(pid_file_path, 'w') { |f| f.write(Process.pid) }
+      end
+
+      redis_opts         = opts[:redis_opts]        || {}
+      @redis             = Redis.new(redis_opts)
+
+      @schedule_key      = opts[:schedule_key]      || 'when:schedules'
+      @worker_queue_key  = opts[:worker_queue_key]  || 'when:queue:default'
+      @delayed_queue_key = opts[:delayed_queue_key] || 'when:delayed'
+    end
+
+    def start_loop
+      logger.info("Starting...")
+      logger.info { "Schedule key: '#{schedule_key}', worker queue key: '#{worker_queue_key}', delayed queue key: '#{delayed_queue_key}'" }
+      logger.info { "PID file: #{pid_file_path}" } if pid_file_path
+
+      loop do
+        sleep_until_next_minute
+        logger.debug { "Using #{`ps -o rss -p #{Process.pid}`.chomp.split("\n").last.to_i} kb of memory." }
+        analyze_in_child_process
+      end
+
+    rescue SystemExit => e
+      raise e
+
+    rescue SignalException => e
+      logger.info(e.inspect)
+      File.delete(pid_file_path) if pid_file_path
+      raise e
+
+    rescue Exception => e
+      ([e.inspect] + e.backtrace).each { |line| logger.fatal(line) }
+      raise e
+    end
+
+    def analyze_in_child_process
+      if pid = fork
+        Thread.new {
+          pid, status = Process.wait2(pid)
+          if status.exitstatus != 0
+            raise "Child (pid: #{pid} exited with non-zero status. Check logs."
+          end
+        }.abort_on_exception = true
+      else
+        analyze
+      end
+    end
+
+    def analyze
+      ['HUP', 'INT', 'TERM'].each { |sig| Signal.trap(sig) { }}
+      started_at = Time.now
+      if running?(started_at)
+        logger.info('Another process is already analyzing.')
+      else
+        logger.debug { 'Analyzing.' }
+        queue_scheduled(started_at)
+        queue_delayed(started_at)
+      end
+      exit
+    end
+
+    def running?(started_at)
+      day_key = build_day_key(started_at)
+      min_key = build_min_key(started_at)
+
+      logger.debug { "Checking Redis using day_key: '#{day_key}' and min_key: '#{min_key}'"}
+      check_and_set_analyzed = redis.multi do
+        redis.hget(day_key, min_key)
+        redis.hset(day_key, min_key, 't')
+        redis.expire(day_key, 60 * 60 * 24)
+      end
+
+      check_and_set_analyzed[0]
+    end
+
+    def build_day_key(started_at)
+      "#{schedule_key}:#{started_at.to_s.split(' ')[0]}"
+    end
+
+    def build_min_key(started_at)
+      "#{started_at.hour}:#{started_at.min}"
+    end
+
+    def queue_scheduled(started_at)
+      schedules = redis.hvals(schedule_key)
+      logger.info("Analyzing #{schedules.count} schedules.")
+      scheduled_jobs = schedules.inject([]) do |jobs, s|
+        schedule = JSON.parse(s)
+        cron = When::Cron.new(schedule['cron'])
+        if cron == started_at
+          jobs << { 'jid' => SecureRandom.uuid, 'class' => schedule['class'], 'args' => schedule['args'] }.to_json
+        end
+        jobs
+      end
+      logger.debug { "Found #{scheduled_jobs.count} schedules due to be queued." }
+      enqueue(scheduled_jobs) if scheduled_jobs.any?
+    end
+
+    def queue_delayed(started_at)
+      logger.info("Checking for delayed jobs.")
+      delayed_jobs = redis.multi do
+        redis.zrevrangebyscore(delayed_queue_key, started_at.to_i, '-inf')
+        redis.zremrangebyscore(delayed_queue_key, '-inf', started_at.to_i)
+      end[0]
+      logger.debug { "Found #{delayed_jobs.count} delayed jobs." }
+      enqueue(delayed_jobs) if delayed_jobs.any?
+    end
+
+    def enqueue(jobs)
+      jobs.each do |job|
+        logger.info("Queueing: #{job}")
+      end
+      success = redis.lpush(worker_queue_key, jobs)
+      unless  success > 0
+        raise "Failed to queue all jobs. Redis returned #{success}."
+      end
+    end
+
+    private
+
+    def sleep_until_next_minute
+      to_sleep = 62 - Time.now.sec #handle up to 2 leap seconds
+      logger.debug { "Sleeping #{to_sleep} seconds."}
+      sleep(to_sleep)
+    end
+
+    def init_logger(log_path, log_level)
+      logger = if log_path
+        Logger.new(log_path, 100, 10_240_000)
+      else
+        Logger.new(STDOUT)
+      end
+      logger.level = log_level.to_i || 1
+      logger
+    end
+  end
+end

data/lib/when-do.rb

@@ -0,0 +1,116 @@
+require 'redis'
+require 'json'
+require 'yaml'
+require 'logger'
+
+module When
+  DEFAULT_CONFIG = {
+    schedule_key:      'when:schedules',
+    worker_queue_key:  'when:queue:default',
+    delayed_queue_key: 'when:delayed'
+  }
+
+  def self.schedule(name, cron, klass, *args)
+    schedule = {'class' => klass.to_s, 'cron' => cron, 'args' => args}
+    if redis.hset(schedule_key, name.to_s, schedule.to_json)
+      logger.info("Scheduled '#{name}' => #{schedule}.")
+    else
+      msg = "Could not schedule '#{name}' => #{schedule}."
+      logger.fatal(msg)
+      raise msg
+    end
+  end
+
+  def self.unschedule(name)
+    json_sched = redis.hget(schedule_key, name.to_s)
+    schedule = JSON.parse(json_sched) if json_sched
+    if redis.hdel(schedule_key, name.to_s) > 0
+      logger.info("Unscheduled '#{name}' => #{schedule}.")
+      true
+    else
+      logger.warn("Could not unschedule '#{name}'. No schedule by that name was found.")
+      false
+    end
+  end
+
+  def self.unschedule_all
+    count = redis.del(schedule_key)
+    logger.info("Cleared #{count} schedules.")
+    count
+  end
+
+  def self.schedules
+    schedules = redis.hgetall(schedule_key)
+    schedules.each { |k, v| schedules[k] = JSON.parse(v) }
+  end
+
+  def self.enqueue_at(time, klass, *args)
+    job = { 'jid' => SecureRandom.uuid, 'class' => klass, 'args' => args }
+    if redis.zadd(delayed_queue_key, time.to_i, job.to_json)
+      logger.info("Delayed: will enqueue #{job} to run at #{time}.")
+      job['jid']
+    else
+      msg = "Failed to enqueue #{job} to run at #{time}."
+      logger.fatal(msg)
+      raise msg
+    end
+  end
+
+  def self.enqueue(klass, *args)
+    job = { 'jid' => SecureRandom.uuid, 'class' => klass, 'args' => args }
+    if redis.lpush(worker_queue_key, job.to_json) > 0
+      job['jid']
+    else
+      msg = "Failed to enqueue #{job}."
+      logger.fatal(msg)
+      raise msg
+    end
+  end
+
+  def self.redis
+    @redis ||= if config[:redis_config_path]
+      Redis.new(YAML.load(File.read(config[:redis_config_path])))
+    else
+      Redis.new
+    end
+  end
+
+  def self.redis=(redis)
+    logger.info("Resetting redis to #{redis.inspect}")
+    @redis = redis
+  end
+
+  def self.config
+    @config ||= DEFAULT_CONFIG
+  end
+
+  def self.config=(new_config)
+    logger.info("Setting config to #{new_config.inspect}")
+    @config = new_config
+  end
+
+  def self.logger
+    @logger ||= if config[:log_path]
+      Logger.new(config[:log_path], 100, 10_240_000)
+    else
+      Logger.new(STDOUT)
+    end
+  end
+
+  def self.logger=(new_logger)
+    logger.info("Changing logger to #{new_logger.inspect}")
+    @logger = new_logger
+  end
+
+  def self.schedule_key
+    config[:schedule_key] || 'when:schedules'
+  end
+
+  def self.delayed_queue_key
+    config[:delayed_queue_key] || 'when:delayed'
+  end
+
+  def self.worker_queue_key
+    config[:worker_queue_key] || 'when:queue:default'
+  end
+end

data/spec/lib/when-do/cli_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+require 'when-do/cli'
+
+describe When::CLI do
+  let(:cli) { When::CLI.new }
+  describe '#options' do
+    context 'argv has an option with no following value' do
+      before do
+        cli.stub(:argv).and_return(['-option'])
+      end
+
+      it 'puts { :option => nil } into the options hash' do
+        expect(cli.options[:option]).to eq nil
+      end
+    end
+
+    context 'argv has an option with one following value' do
+      before do
+        cli.stub(:argv).and_return(['-option', 'value'])
+      end
+
+      it 'puts { :option => "value" } into the options hash' do
+        expect(cli.options[:option]).to eq('value')
+      end
+    end
+
+    context 'argv has an option with several following values' do
+      before do
+        cli.stub(:argv).and_return(['-option', 'value1', 'value2', 'value3'])
+      end
+
+      it 'puts { :option => ["value1", "value2", "value3"] } into the options hash' do
+        expect(cli.options[:option]).to eq(['value1', 'value2', 'value3'])
+      end
+    end
+
+    context 'argv has complex options and values with several following values' do
+      before do
+        cli.stub(:argv).and_return(['-option1', '-option2', 'value2-1', '-option3', 'value3-1', 'value3-2', 'value3-3'])
+      end
+
+      it 'builds the options hash' do
+        expect(cli.options[:option1]).to eq(nil)
+        expect(cli.options[:option2]).to eq('value2-1')
+        expect(cli.options[:option3]).to eq(['value3-1', 'value3-2', 'value3-3'])
+      end
+    end
+
+    context 'argv includes a path to a config file' do
+      context 'but no additional command line options' do
+        before do
+          cli.stub(:argv).and_return(['-c', 'a file path', '-e', 'test'])
+          File.stub(:read).with('a file path').and_return({test: {yaml: 'config'}}.to_yaml)
+        end
+
+        it 'adds options from the config file' do
+          expect(cli.options[:yaml]).to eq('config')
+        end
+      end
+
+      context 'and additional command line options' do
+        before do
+          cli.stub(:argv).and_return(['-c', 'a file path', '-override', 'overridden'])
+          File.stub(:read).with('a file path').and_return({override: 'not overridden'}.to_yaml)
+        end
+
+        it 'command line arguments override options from the config file' do
+          expect(cli.options[:override]).to eq('overridden')
+        end
+      end
+    end
+
+    context 'argv includes a path to a redis config file' do
+      before do
+        cli.stub(:argv).and_return(['-rc', 'a file path'])
+        File.stub(:read).with('a file path').and_return({redis_opt: 'redis opt'}.to_yaml)
+      end
+
+      it 'adds options from the redis config file under :redis_opts' do
+        expect(cli.options[:redis_opts][:redis_opt]).to eq('redis opt')
+      end
+    end
+  end
+end

data/spec/lib/when-do/do_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+require 'when-do/do'
+require 'when-do'
+
+describe When::Do do
+  let(:test_redis_index) { 11 }
+  let(:redis) { Redis.new(db: test_redis_index) }
+  let(:when_do) { When::Do.new(redis_opts: {db: test_redis_index}) }
+  let(:started_at) { Time.now }
+
+  before do
+    When.logger.level = 5
+    when_do.logger.level = 5
+    When.redis = redis
+    redis.flushall
+  end
+
+  after do
+    redis.flushall
+  end
+
+  describe '#running?' do
+    let(:day_key) { when_do.build_day_key(started_at) }
+    let(:min_key) { when_do.build_min_key(started_at) }
+
+    context 'the corresponding day hash and minute key exist in redis' do
+      before do
+        redis.hset(day_key, min_key, 't')
+      end
+
+      it 'returns true' do
+        expect(when_do.running?(started_at)).to be_true
+      end
+    end
+
+    context 'the corresponding day hash and minute key do not exist in redis' do
+      it 'sets the day hash and minute key' do
+        expect { when_do.running?(started_at) }.to change { redis.hget(day_key, min_key) }.from(nil).to be_true
+      end
+
+      it 'returns false' do
+        expect(when_do.running?(started_at)).to be_false
+      end
+    end
+  end
+
+  describe '#queue_scheduled' do
+    context 'a scheduled item has a matching cron' do
+      let(:args) { ['arg1', 'arg2', 3, { 'more' => 'args' }] }
+      let(:klass) { String }
+      before do
+        When.schedule('test schedule', '* * * * *', klass, *args)
+      end
+
+      it 'drops a job onto the queue' do
+        expect { when_do.queue_scheduled(started_at) }
+          .to change { redis.lpop(when_do.worker_queue_key) }
+          .from(nil)
+          .to be_true
+      end
+
+      it 'includes the correct arguments' do
+        when_do.queue_scheduled(started_at)
+        job = JSON.parse(redis.lpop(when_do.worker_queue_key))
+        expect(job['args']).to eq args
+      end
+
+      it 'includes the correct class' do
+        when_do.queue_scheduled(started_at)
+        job = JSON.parse(redis.lpop(when_do.worker_queue_key))
+        expect(job['class']).to eq klass.name
+      end
+    end
+
+    context 'a scheduled item does not have a matching cron' do
+      before do
+        When.schedule('test schedule', String, '0 0 0 0 0')
+      end
+
+      it 'does not add an item to the queue' do
+        expect { when_do.queue_scheduled(started_at) }
+          .not_to change { redis.lpop(when_do.worker_queue_key) }
+          .from(nil)
+      end
+    end
+  end
+
+  describe '#queue_delayed' do
+    context 'a delayed item is due to be queue' do
+      let(:args) { ['arg1', 'arg2', 3, { 'more' => 'args' }] }
+      let(:klass) { String }
+      before do
+        When.enqueue_at(started_at - 1, String, *args)
+      end
+
+      it 'drops a job onto the queue' do
+        expect { when_do.queue_delayed(started_at) }
+          .to change { redis.lpop(when_do.worker_queue_key) }
+          .from(nil)
+          .to be_true
+      end
+
+      it 'includes the correct arguments' do
+        when_do.queue_delayed(started_at)
+        job = JSON.parse(redis.lpop(when_do.worker_queue_key))
+        expect(job['args']).to eq args
+      end
+
+      it 'includes the correct class' do
+        when_do.queue_delayed(started_at)
+        job = JSON.parse(redis.lpop(when_do.worker_queue_key))
+        expect(job['class']).to eq klass.name
+      end
+    end
+
+    context 'a delayed item is not yet due to be queued' do
+      before do
+        When.enqueue_at(started_at + 1, String)
+      end
+
+      it 'does not add an item to the queue' do
+        expect { when_do.queue_delayed(started_at) }
+          .not_to change { redis.lpop(when_do.worker_queue_key) }
+          .from(nil)
+      end
+    end
+  end
+
+  describe '#enqueue' do
+    it 'places jobs onto the work queue' do
+      expect { when_do.enqueue(['junk', 'jobs']) }
+        .to change { redis.llen(when_do.worker_queue_key) }
+        .from(0)
+        .to(2)
+    end
+  end
+end

data/spec/lib/when-do_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+require 'when-do'
+
+describe When do
+  let(:redis) { When.redis }
+
+  before do
+    When.logger.level = 5
+    When.redis = Redis.new(db: 11)
+    redis.flushall
+  end
+
+  after do
+    redis.flushall
+  end
+
+  describe '#schedule' do
+    it 'adds data to the schedules hash in redis' do
+      When.schedule('test_schedule', '* * * * *',  Object, 'arg1', 'arg2')
+      expect(redis.hget(When.schedule_key, 'test_schedule')).to eq "{\"class\":\"Object\",\"cron\":\"* * * * *\",\"args\":[\"arg1\",\"arg2\"]}"
+    end
+  end
+
+  describe '#unschedule' do
+    it 'removes data from the schedules hash in redis' do
+      When.schedule('test_schedule', '* * * * *', Object)
+      expect(redis.hget(When.schedule_key, 'test_schedule')).to eq "{\"class\":\"Object\",\"cron\":\"* * * * *\",\"args\":[]}"
+      When.unschedule('test_schedule')
+      expect(redis.hget(When.schedule_key, 'test_schedule')).to be_nil
+    end
+  end
+
+  describe '#enqueue_at' do
+    let(:now) { Time.now }
+    let(:args) { ['arg1', 'arg2', 3, {'more' => 'args'} ] }
+    let(:klass) { String }
+
+    it 'adds an item to the delayed list' do
+      expect { When.enqueue_at(now, String) }
+        .to change { redis.zrange(When.delayed_queue_key, 0, -1).count }
+        .from(0).to(1)
+    end
+
+    it 'adds the correct score' do
+      When.enqueue_at(now, String)
+      score = redis.zrange(When.delayed_queue_key, 0, -1, with_scores: true).first.last
+      expect(score).to eq now.to_i.to_f
+    end
+
+    it 'adds the correct args' do
+      When.enqueue_at(now, String, *args)
+      new_args = JSON.parse(redis.zrange(When.delayed_queue_key, 0, -1).first)['args']
+      expect(new_args).to eq args
+    end
+
+    it 'adds the correct class' do
+      When.enqueue_at(now, klass, *args)
+      new_args = JSON.parse(redis.zrange(When.delayed_queue_key, 0, -1).first)['class']
+      expect(new_args).to eq klass.name
+    end
+  end
+
+  describe '#enqueue' do
+    let(:args) { ['arg1', 'arg2', 3, {'more' => 'args'} ] }
+    let(:klass) { String }
+
+    it 'adds an item to the worker queue' do
+      expect { When.enqueue(klass) }
+        .to change { redis.llen(When.worker_queue_key) }
+        .from(0).to(1)
+    end
+
+    it 'adds the correct args' do
+      When.enqueue(klass, *args)
+      enqueued_args = JSON.parse(redis.rpop(When.worker_queue_key))['args']
+      expect(enqueued_args).to eq args
+    end
+
+    it 'adds the correct class' do
+      When.enqueue(klass)
+      enqueued_class = JSON.parse(redis.rpop(When.worker_queue_key))['class']
+      expect(enqueued_class).to eq klass.name
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+RSpec.configure do |config|
+  config.order = 'random'
+end

data/when-do.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "when-do"
+  spec.version       = '1.0.0'
+  spec.authors       = ["TH"]
+  spec.email         = ["tylerhartland7@gmail.com"]
+  spec.description   = %q{Queues jobs when you want.}
+  spec.summary       = %q{Queues jobs when you want.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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.add_runtime_dependency 'when-cron'
+  spec.add_runtime_dependency 'redis'
+  spec.add_runtime_dependency 'json'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "pry"
+end

metadata

@@ -0,0 +1,193 @@
+--- !ruby/object:Gem::Specification
+name: when-do
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- TH
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: when-cron
+  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: redis
+  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: json
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: guard
+  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: rspec
+  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: guard-rspec
+  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: pry
+  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: Queues jobs when you want.
+email:
+- tylerhartland7@gmail.com
+executables:
+- when-do
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/when-do
+- config/when.yml.example
+- lib/when-do.rb
+- lib/when-do/cli.rb
+- lib/when-do/do.rb
+- spec/lib/when-do/cli_spec.rb
+- spec/lib/when-do/do_spec.rb
+- spec/lib/when-do_spec.rb
+- spec/spec_helper.rb
+- when-do.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Queues jobs when you want.
+test_files:
+- spec/lib/when-do/cli_spec.rb
+- spec/lib/when-do/do_spec.rb
+- spec/lib/when-do_spec.rb
+- spec/spec_helper.rb
+has_rdoc: