sidetiq 0.1.2

data/.gitignore

@@ -0,0 +1,9 @@
+lib/*.bundle
+coverage
+rdoc
+doc
+.yardoc
+.bundle
+Gemfile.lock
+pkg
+tmp

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+before_script:
+  - bundle exec rake compile
+matrix:
+  allow_failures:
+    - rvm: 2.0.0

data/Gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+
+group :development do
+  gem 'rake'
+  gem 'rake-compiler'
+  gem 'sinatra', require: false
+  gem 'slim', require: false
+end
+
+group :test do
+  gem 'simplecov'
+  gem 'mocha'
+  gem 'rack-test'
+end
+
+gemspec
+

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (C) 2012 by Tobias Svensson <tobias@musicglue.com>
+
+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,146 @@
+Sidetiq
+=======
+
+[![Build Status](https://travis-ci.org/tobiassvn/sidetiq.png)](https://travis-ci.org/tobiassvn/sidetiq)
+
+Recurring jobs for [Sidekiq](http://mperham.github.com/sidekiq/).
+
+## DESCRIPTION
+
+Sidetiq provides a simple API for defining recurring workers for Sidekiq.
+
+- Flexible DSL based on [ice_cube](http://seejohnrun.github.com/ice_cube/)
+
+- High-resolution timer using `clock_gettime(3)` (or `mach_absolute_time()` on
+  Apple Mac OS X), allowing for accurate sub-second clock ticks.
+
+- Sidetiq uses a locking mechanism (based on `setnx` and `pexpire`) internally
+  so Sidetiq clocks can run in each Sidekiq process without interfering with
+  each other (tested with sub-second polling of scheduled jobs by Sidekiq and
+  Sidetiq clock rates above 100hz).
+
+## DEPENDENCIES
+
+- [Sidekiq](http://mperham.github.com/sidekiq/)
+- [ice_cube](http://seejohnrun.github.com/ice_cube/)
+
+## INSTALLATION
+
+The best way to install Sidetiq is with RubyGems:
+
+    $ [sudo] gem install sidetiq
+
+If you're installing from source, you can use [Bundler](http://gembundler.com/)
+to pick up all the gems ([more info](http://gembundler.com/bundle_install.html)):
+
+    $ bundle install
+
+## GETTING STARTED
+
+Defining recurring jobs is simple:
+
+```ruby
+class MyWorker
+  include Sidekiq::Worker
+  include Sidetiq::Schedulable
+
+  # Daily at midnight
+  tiq { daily }
+end
+```
+
+It also is possible to define multiple scheduling rules for a worker:
+
+```ruby
+class MyWorker
+  include Sidekiq::Worker
+  include Sidetiq::Schedulable
+
+  tiq do
+    # Every third year in March
+    yearly(3).month_of_year(:march)
+
+    # Every second year in February
+    yearly(2).month_of_year(:february)
+  end
+end
+```
+
+Or complex schedules:
+
+```ruby
+class MyWorker
+  include Sidekiq::Worker
+  include Sidetiq::Schedulable
+
+  # Every other month on the first monday and last tuesday at 12 o'clock.
+  tiq { monthly(2).day_of_week(1 => [1], 2 => [-1]).hour_of_day(12) }
+end
+```
+
+To start Sidetiq, simply call `Sidetiq::Clock.start!` in a server specific
+configuration block:
+
+```ruby
+Sidekiq.configure_server do |config|
+  Sidetiq::Clock.start!
+end
+```
+
+Additionally, Sidetiq includes a middleware that will check if the clock
+thread is still alive and restart it if necessary.
+
+## CONFIGURATION
+
+```ruby
+Sidetiq.configure do |config|
+  # Thread priority of the clock thread (default: Thread.main.priority as
+  # defined when Sidetiq is loaded).
+  config.priority = 2
+
+  # Clock tick resolution in seconds (default: 1).
+  config.resolution = 0.5
+
+  # Clock locking key expiration in ms (default: 1000).
+  config.lock_expire = 100
+
+  # When `true` uses UTC instead of local times (default: false)
+  config.utc = false
+end
+```
+
+## WEB EXTENSION
+
+Sidetiq includes an extension for Sidekiq's web interface. It will not be
+loaded by default, so it will have to be required manually:
+
+```ruby
+require 'sidetiq/web'
+```
+
+### SCREENSHOT
+
+![Screenshot](http://f.cl.ly/items/1P2u1v091F3V1n381g2I/Screen%20Shot%202013-02-01%20at%2012.16.17.png)
+
+## CONTRIBUTE
+
+If you'd like to contribute to Sidetiq, start by forking my repo on GitHub:
+
+[http://github.com/tobiassvn/sidetiq](http://github.com/tobiassvn/sidetiq)
+
+To get all of the dependencies, install the gem first. The best way to get
+your changes merged back into core is as follows:
+
+1. Clone down your fork
+1. Create a thoughtfully named topic branch to contain your change
+1. Write some code
+1. Add tests and make sure everything still passes by running `rake`
+1. If you are adding new functionality, document it in the README
+1. Do not change the version number, I will do that on my end
+1. If necessary, rebase your commits into logical chunks, without errors
+1. Push the branch up to GitHub
+1. Send a pull request to the tobiassvn/sidetiq project.
+
+## LICENSE
+
+Sidetiq is released under the MIT License. See LICENSE for further details.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'rake/extensiontask'
+
+Rake::ExtensionTask.new('sidetiq_ext')
+
+Rake::TestTask.new do |t|
+  t.pattern = 'test/**/test_*.rb'
+end
+
+task default: :test

data/examples/simple.rb

@@ -0,0 +1,18 @@
+# Run with `sidekiq -r /path/to/simple.rb`
+
+require 'sidekiq'
+require 'sidetiq'
+
+Sidekiq.options[:poll_interval] = 1
+
+class MyWorker
+  include Sidekiq::Worker
+  include Sidetiq::Schedulable
+
+  tiq { secondly }
+
+  def perform(*args)
+    Sidekiq.logger.info "#perform"
+  end
+end
+

data/ext/sidetiq_ext/extconf.rb

@@ -0,0 +1,4 @@
+require 'rbconfig'
+require 'mkmf'
+create_makefile('sidetiq_ext')
+

data/ext/sidetiq_ext/sidetiq_ext.c

@@ -0,0 +1,97 @@
+#include <ruby.h>
+#include <assert.h>
+#include "sidetiq_ext.h"
+
+#ifdef __APPLE__
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <mach/mach.h>
+#include <mach/clock.h>
+#include <mach/mach_time.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sched.h>
+#else
+#include <time.h>
+#endif
+
+VALUE msidetiq;
+VALUE esidetiq_error;
+VALUE csidetiq_clock;
+
+#ifdef __APPLE__
+static mach_timebase_info_data_t clock_gettime_inf;
+
+typedef enum {
+        CLOCK_REALTIME,
+        CLOCK_MONOTONIC,
+        CLOCK_PROCESS_CPUTIME_ID,
+        CLOCK_THREAD_CPUTIME_ID
+} clockid_t;
+
+int clock_gettime(clockid_t clk_id, struct timespec *tp)
+{
+        kern_return_t ret;
+        clock_serv_t clk;
+        clock_id_t clk_serv_id;
+        mach_timespec_t tm;
+        uint64_t start, end, delta, nano;
+        int retval = -1;
+
+        switch (clk_id) {
+                case CLOCK_REALTIME:
+                case CLOCK_MONOTONIC:
+                        clk_serv_id = clk_id == CLOCK_REALTIME ? CALENDAR_CLOCK : SYSTEM_CLOCK;
+                        if (KERN_SUCCESS == (ret = host_get_clock_service(mach_host_self(), clk_serv_id, &clk))) {
+                                if (KERN_SUCCESS == (ret = clock_get_time(clk, &tm))) {
+                                        tp->tv_sec  = tm.tv_sec;
+                                        tp->tv_nsec = tm.tv_nsec;
+                                        retval = 0;
+                                }
+                        }
+                        if (KERN_SUCCESS != ret) {
+                                errno = EINVAL;
+                                retval = -1;
+                        }
+                break;
+                case CLOCK_PROCESS_CPUTIME_ID:
+                case CLOCK_THREAD_CPUTIME_ID:
+                        start = mach_absolute_time();
+                        if (clk_id == CLOCK_PROCESS_CPUTIME_ID) {
+                                getpid();
+                        } else {
+                                sched_yield();
+                        }
+                        end = mach_absolute_time();
+                        delta = end - start;
+                        if (0 == clock_gettime_inf.denom) {
+                                mach_timebase_info(&clock_gettime_inf);
+                        }
+                        nano = delta * clock_gettime_inf.numer / clock_gettime_inf.denom;
+                        tp->tv_sec = nano * 1e-9;
+                        tp->tv_nsec = nano - (tp->tv_sec * 1e9);
+                        retval = 0;
+                break;
+                default:
+                        errno = EINVAL;
+                        retval = -1;
+        }
+        return retval;
+}
+#endif
+
+static VALUE sidetiq_gettime(VALUE self)
+{
+        struct timespec time;
+        assert(clock_gettime(CLOCK_REALTIME, &time) == 0);
+        return rb_time_nano_new(time.tv_sec, time.tv_nsec);
+}
+
+void Init_sidetiq_ext()
+{
+        msidetiq = rb_define_module("Sidetiq");
+        esidetiq_error = rb_define_class_under(msidetiq, "Error", rb_eStandardError);
+        csidetiq_clock = rb_define_class_under(msidetiq, "Clock", rb_cObject);
+        rb_define_private_method(csidetiq_clock, "clock_gettime", sidetiq_gettime, 0);
+}
+

data/ext/sidetiq_ext/sidetiq_ext.h

@@ -0,0 +1,17 @@
+#ifndef __SIDETIQ_EXT_H__
+#define __SIDETIQ_EXT_H__
+#include <ruby.h>
+
+void Init_sidetiq_ext();
+static VALUE sidetiq_gettime(VALUE self);
+
+/* module Sidetiq */
+extern VALUE msidetiq;
+
+/* class Sidetiq::Error < StandardError */
+extern VALUE esidetiq_error;
+
+/* class Sidetiq::Clock */
+extern VALUE csidetiq_clock;
+
+#endif

data/lib/sidetiq/clock.rb

@@ -0,0 +1,105 @@
+module Sidetiq
+  configure do |config|
+    config.priority = Thread.main.priority
+    config.resolution = 1
+    config.lock_expire = 1000
+    config.utc = false
+  end
+
+  class Clock
+    include Singleton
+    include MonitorMixin
+
+    START_TIME = Sidetiq.config.utc ? Time.utc(2010, 1, 1) : Time.local(2010, 1, 1)
+
+    attr_reader :schedules, :thread
+
+    def self.method_missing(meth, *args, &block)
+      instance.__send__(meth, *args, &block)
+    end
+
+    def initialize
+      super
+      @schedules = {}
+    end
+
+    def schedule_for(worker)
+      schedules[worker] ||= Sidetiq::Schedule.new(START_TIME)
+    end
+
+    def tick
+      @tick = gettime
+      synchronize do
+        schedules.each do |worker, schedule|
+          if schedule.schedule_next?(@tick)
+            enqueue(worker, schedule.next_occurrence(@tick))
+          end
+        end
+      end
+    end
+
+    def gettime
+      Sidetiq.config.utc ? clock_gettime.utc : clock_gettime
+    end
+
+    def start!
+      return if ticking?
+
+      Sidekiq.logger.info "Sidetiq::Clock start"
+      @thread = Thread.start { clock { tick } }
+      @thread.abort_on_exception = true
+      @thread.priority = Sidetiq.config.resolution
+    end
+
+    def stop!
+      if ticking?
+        @thread.kill
+        Sidekiq.logger.info "Sidetiq::Clock stop"
+      end
+    end
+
+    def ticking?
+      @thread && @thread.alive?
+    end
+
+    private
+
+    def enqueue(worker, time)
+      key = "sidetiq:#{worker.name}"
+
+      synchronize_clockworks("#{key}:lock") do |redis|
+        status = redis.get(key)
+
+        if status.nil? || status.to_f < time.to_f
+          time_f = time.to_f
+          Sidekiq.logger.info "Sidetiq::Clock enqueue #{worker.name} (at: #{time_f})"
+          redis.set(key, time_f)
+          worker.perform_at(time)
+        end
+      end
+    end
+
+    def synchronize_clockworks(lock)
+      Sidekiq.redis do |redis|
+        if redis.setnx(lock, 1)
+          Sidekiq.logger.debug "Sidetiq::Clock lock #{lock} #{Thread.current.inspect}"
+
+          redis.pexpire(lock, Sidetiq.config.lock_expire)
+          yield redis
+          redis.del(lock)
+
+          Sidekiq.logger.debug "Sidetiq::Clock unlock #{lock} #{Thread.current.inspect}"
+        end
+      end
+    end
+
+    def clock
+      loop do
+        yield
+        Thread.pass
+        sleep Sidetiq.config.resolution
+      end
+    end
+  end
+end
+

data/lib/sidetiq/config.rb

@@ -0,0 +1,14 @@
+module Sidetiq
+  class << self
+    attr_writer :config
+
+    def configure
+      yield config
+    end
+
+    def config
+      @config ||= OpenStruct.new
+    end
+  end
+end
+

data/lib/sidetiq/middleware.rb

@@ -0,0 +1,20 @@
+module Sidetiq
+  class Middleware
+    def initialize
+      @clock = Sidetiq::Clock.instance
+    end
+
+    def call(*args)
+      # Restart the clock if the thread died.
+      @clock.start! if !@clock.ticking?
+      yield
+    end
+  end
+end
+
+Sidekiq.configure_server do |config|
+  config.server_middleware do |chain|
+    chain.add Sidetiq::Middleware
+  end
+end
+

data/lib/sidetiq/schedulable.rb

@@ -0,0 +1,17 @@
+module Sidetiq
+  module Schedulable
+    module ClassMethods
+      def tiq(&block)
+        clock = Sidetiq::Clock.instance
+        clock.synchronize do
+          clock.schedule_for(self).instance_eval(&block)
+        end
+      end
+    end
+
+    def self.included(klass)
+      klass.extend(Sidetiq::Schedulable::ClassMethods)
+    end
+  end
+end
+

data/lib/sidetiq/schedule.rb

@@ -0,0 +1,22 @@
+module Sidetiq
+  class Schedule < IceCube::Schedule
+    def method_missing(meth, *args, &block)
+      if IceCube::Rule.respond_to?(meth)
+        rule = IceCube::Rule.send(meth, *args, &block)
+        add_recurrence_rule(rule)
+        rule
+      else
+        super
+      end
+    end
+
+    def schedule_next?(time)
+      if @last_scheduled != (no = next_occurrence(time))
+        @last_scheduled = no
+        return true
+      end
+      false
+    end
+  end
+end
+

data/lib/sidetiq/version.rb

@@ -0,0 +1,10 @@
+module Sidetiq
+  module VERSION
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 2
+
+    STRING = [MAJOR, MINOR, PATCH].compact.join('.')
+  end
+end
+

data/lib/sidetiq/views/sidetiq.slim

@@ -0,0 +1,23 @@
+header.row
+  .span5
+    h3 Recurring Jobs
+
+- if @schedules.length > 0
+  table class="table table-striped table-bordered table-white" style="width: 100%; margin: 0; table-layout:fixed;"
+    thead
+      th style="width: 50%" Worker
+      th style="width: 20%" Queue
+      th style="width: 20%" Next Run
+      th style="width: 10%" Actions
+    - @schedules.each do |worker, schedule|
+      tr
+        td
+          = worker.name
+        td= worker.get_sidekiq_options['queue']
+        td
+          == relative_time(schedule.next_occurrence(@time))
+        td
+          a href="#{root_path}sidetiq/#{worker.name}" Details
+- else
+  .alert.alert-success No recurring jobs found.
+

data/lib/sidetiq/views/sidetiq_details.slim

@@ -0,0 +1,40 @@
+header.row
+  .span5
+    h3
+      ' Recurring Job:
+      = @worker.name
+
+- if (recurrences = @schedule.recurrence_rules).length > 0
+  table class="table table-striped table-bordered table-white" style="width: 100%; margin: 0; table-layout:fixed;"
+    thead
+      th Recurrences
+    - recurrences.each do |rule|
+      tr
+        td
+          = rule.to_s
+
+br
+
+- if (exceptions = @schedule.exception_rules).length > 0
+  table class="table table-striped table-bordered table-white" style="width: 100%; margin: 0; table-layout:fixed;"
+    thead
+      th Exceptions
+    - exceptions.each do |rule|
+      tr
+        td
+          = rule.to_s
+
+br
+
+table class="table table-striped table-bordered table-white" style="width: 100%; margin: 0; table-layout:fixed;"
+  thead
+    th style="width: 25%" Next 10 runs
+    th style="width: 75%"
+  - @schedule.next_occurrences(10, @time).each do |time|
+    tr
+      td
+        time= time.getutc
+      td
+        == relative_time(time)
+
+br

data/lib/sidetiq/web.rb

@@ -0,0 +1,47 @@
+require 'sidekiq/web'
+
+module Sidetiq
+  module Web
+
+    def self.registered(app)
+      app.helpers do
+        def find_template(view, *args, &block)
+          path = File.expand_path(File.join('..', 'views'), __FILE__)
+          super(path, *args, &block)
+          super
+        end
+      end
+
+      app.get "/sidetiq" do
+        clock = Sidetiq::Clock.instance
+        @schedules = clock.schedules
+        @time = clock.gettime
+        slim :sidetiq
+      end
+
+      app.get "/sidetiq/:name" do
+        halt 404 unless (name = params[:name])
+
+        clock = Sidetiq::Clock.instance
+        schedules = clock.schedules
+
+        @time = clock.gettime
+
+        @worker, @schedule = schedules.select do |worker, schedule|
+          worker.name == name
+        end.flatten
+
+        slim :sidetiq_details
+      end
+    end
+  end
+end
+
+Sidekiq::Web.register(Sidetiq::Web)
+
+if Sidekiq::Web.tabs.is_a?(Array)
+  Sidekiq::Web.tabs << "sidetiq"
+else
+  Sidekiq::Web.tabs["Sidetiq"] = "sidetiq"
+end
+

data/lib/sidetiq.rb

@@ -0,0 +1,20 @@
+# stdlib
+require 'monitor'
+require 'ostruct'
+require 'singleton'
+
+# gems
+require 'ice_cube'
+require 'sidekiq'
+
+# c extensions
+require 'sidetiq_ext'
+
+# internal
+require 'sidetiq/config'
+require 'sidetiq/clock'
+require 'sidetiq/middleware'
+require 'sidetiq/schedule'
+require 'sidetiq/schedulable'
+require 'sidetiq/version'
+

data/sidetiq.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path(File.join('..', 'lib'), __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sidetiq/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "sidetiq"
+  gem.version       = Sidetiq::VERSION::STRING
+  gem.authors       = ["Tobias Svensson"]
+  gem.email         = ["tob@tobiassvensson.co.uk"]
+  gem.description   = "High-resolution job scheduler for Sidekiq"
+  gem.summary       = gem.description
+  gem.homepage      = "http://github.com/tobiassvn/sidetiq"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.extensions    = ['ext/sidetiq_ext/extconf.rb']
+
+  gem.add_dependency 'sidekiq'
+  gem.add_dependency 'ice_cube'
+end

data/test/helper.rb

@@ -0,0 +1,26 @@
+require 'simplecov'
+SimpleCov.start { add_filter "/test/" }
+
+require 'minitest/autorun'
+require 'mocha/setup'
+require 'rack/test'
+
+require 'sidekiq'
+require 'sidekiq/testing'
+
+require 'sidetiq'
+require 'sidetiq/web'
+
+# Keep the test output clean
+Sidekiq.logger = Logger.new(nil)
+
+class Sidetiq::TestCase < MiniTest::Unit::TestCase
+  def setup
+    Sidekiq.redis { |r| r.flushall }
+  end
+
+  def clock
+    @clock ||= Sidetiq::Clock.instance
+  end
+end
+

data/test/test_clock.rb

@@ -0,0 +1,65 @@
+require_relative 'helper'
+
+class TestClock < Sidetiq::TestCase
+  class FakeWorker;
+  end
+
+  def test_delegates_to_instance
+    Sidetiq::Clock.instance.expects(:foo).once
+    Sidetiq::Clock.foo
+  end
+
+  def test_start_stop
+    refute clock.ticking?
+    assert_nil clock.thread
+
+    clock.start!
+    Thread.pass
+    sleep 0.01
+
+    assert clock.ticking?
+    assert_kind_of Thread, clock.thread
+
+    clock.stop!
+    Thread.pass
+    sleep 0.01
+
+    refute clock.ticking?
+    refute clock.thread.alive?
+  end
+
+  def test_gettime_seconds
+    assert_equal clock.gettime.tv_sec, Time.now.tv_sec
+  end
+
+  def test_gettime_nsec
+    refute_nil clock.gettime.tv_nsec
+  end
+
+  def test_gettime_utc
+    refute clock.gettime.utc?
+    Sidetiq.config.utc = true
+    assert clock.gettime.utc?
+    Sidetiq.config.utc = false
+  end
+
+  def test_enqueues_jobs_by_schedule
+    schedule = Sidetiq::Schedule.new(Sidetiq::Clock::START_TIME)
+    schedule.daily
+
+    clock.stubs(:schedules).returns(FakeWorker => schedule)
+
+    FakeWorker.expects(:perform_at).times(10)
+
+    10.times do |i|
+      clock.stubs(:gettime).returns(Time.local(2011, 1, i + 1, 1))
+      clock.tick
+    end
+
+    clock.stubs(:gettime).returns(Time.local(2011, 1, 10, 2))
+    clock.tick
+    clock.tick
+    clock.tick
+  end
+end
+

data/test/test_config.rb

@@ -0,0 +1,21 @@
+require_relative 'helper'
+
+class TestConfig < Sidetiq::TestCase
+  def setup
+    @saved = Sidetiq.config
+    Sidetiq.config = OpenStruct.new
+  end
+
+  def teardown
+    Sidetiq.config = @saved
+  end
+
+  def test_configure
+    Sidetiq.configure do |config|
+      config.test = 42
+    end
+
+    assert_equal 42, Sidetiq.config.test
+  end
+end
+

data/test/test_errors.rb

@@ -0,0 +1,7 @@
+require_relative 'helper'
+
+class TestErrors < Sidetiq::TestCase
+  def test_error_superclass
+    assert_equal StandardError, Sidetiq::Error.superclass
+  end
+end

data/test/test_middleware.rb

@@ -0,0 +1,18 @@
+require_relative 'helper'
+
+class TestMiddleware < Sidetiq::TestCase
+  def middleware
+    Sidetiq::Middleware.new
+  end
+
+  def test_restarts_clock
+    clock.stubs(:ticking?).returns(false)
+    clock.expects(:start!).once
+    middleware.call {}
+
+    clock.stubs(:ticking?).returns(true)
+    clock.expects(:start!).never
+    middleware.call {}
+  end
+end
+

data/test/test_schedule.rb

@@ -0,0 +1,25 @@
+require_relative 'helper'
+
+class TestSchedule < Sidetiq::TestCase
+  def test_super
+    assert_equal IceCube::Schedule, Sidetiq::Schedule.superclass
+  end
+
+  def test_method_missing
+    sched = Sidetiq::Schedule.new
+    sched.daily
+    assert_equal "Daily", sched.to_s
+  end
+
+  def test_schedule_next?
+    sched = Sidetiq::Schedule.new
+
+    sched.daily
+
+    assert sched.schedule_next?(Time.now + (24 * 60 * 60))
+    refute sched.schedule_next?(Time.now + (24 * 60 * 60))
+    assert sched.schedule_next?(Time.now + (2 * 24 * 60 * 60))
+    refute sched.schedule_next?(Time.now + (2 * 24 * 60 * 60))
+  end
+end
+

data/test/test_version.rb

@@ -0,0 +1,21 @@
+require_relative 'helper'
+
+class TestVersion < Sidetiq::TestCase
+  def test_major
+    assert_instance_of Fixnum, Sidetiq::VERSION::MAJOR
+  end
+
+  def test_minor
+    assert_instance_of Fixnum, Sidetiq::VERSION::MINOR
+  end
+
+  def test_patch
+    assert_instance_of Fixnum, Sidetiq::VERSION::PATCH
+  end
+
+  def test_string
+    assert_equal Sidetiq::VERSION::STRING, [Sidetiq::VERSION::MAJOR,
+      Sidetiq::VERSION::MINOR, Sidetiq::VERSION::PATCH].compact.join('.')
+  end
+end
+

data/test/test_web.rb

@@ -0,0 +1,58 @@
+require_relative 'helper'
+
+class TestWeb < Sidetiq::TestCase
+  include Rack::Test::Methods
+
+  class Worker
+    include Sidekiq::Worker
+    include Sidetiq::Schedulable
+
+    tiq do
+      daily(1)
+      yearly(2)
+      monthly(3)
+
+      add_exception_rule yearly.month_of_year(:february)
+    end
+  end
+
+  def app
+    Sidekiq::Web
+  end
+
+  def test_home_tab
+    get '/'
+    assert_equal 200, last_response.status
+    assert_match last_response.body, /Sidekiq/
+    assert_match last_response.body, /Sidetiq/
+  end
+
+  def test_sidetiq_page
+    get '/sidetiq'
+    assert_equal 200, last_response.status
+
+    clock.schedules.each do |worker, schedule|
+      assert_match last_response.body, /#{worker.name}/
+      assert_match last_response.body, /#{worker.get_sidekiq_options['queue']}/
+    end
+  end
+
+  def test_details_page
+    get "/sidetiq/#{Worker.name}"
+    assert_equal 200, last_response.status
+    schedule = clock.schedules[Worker]
+
+    schedule.recurrence_rules.each do |rule|
+      assert_match last_response.body, /#{rule.to_s}/
+    end
+
+    schedule.exception_rules.each do |rule|
+      assert_match last_response.body, /#{rule.to_s}/
+    end
+
+    schedule.next_occurrences(10).each do |time|
+      assert_match last_response.body, /#{time.getutc.to_s}/
+    end
+  end
+end
+

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: sidetiq
+version: !ruby/object:Gem::Version
+  prerelease: 
+  version: 0.1.2
+platform: ruby
+authors:
+- Tobias Svensson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  name: sidekiq
+  type: :runtime
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  name: ice_cube
+  type: :runtime
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+description: High-resolution job scheduler for Sidekiq
+email:
+- tob@tobiassvensson.co.uk
+executables: []
+extensions:
+- ext/sidetiq_ext/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- examples/simple.rb
+- ext/sidetiq_ext/extconf.rb
+- ext/sidetiq_ext/sidetiq_ext.c
+- ext/sidetiq_ext/sidetiq_ext.h
+- lib/sidetiq.rb
+- lib/sidetiq/clock.rb
+- lib/sidetiq/config.rb
+- lib/sidetiq/middleware.rb
+- lib/sidetiq/schedulable.rb
+- lib/sidetiq/schedule.rb
+- lib/sidetiq/version.rb
+- lib/sidetiq/views/sidetiq.slim
+- lib/sidetiq/views/sidetiq_details.slim
+- lib/sidetiq/web.rb
+- sidetiq.gemspec
+- test/helper.rb
+- test/test_clock.rb
+- test/test_config.rb
+- test/test_errors.rb
+- test/test_middleware.rb
+- test/test_schedule.rb
+- test/test_version.rb
+- test/test_web.rb
+homepage: http://github.com/tobiassvn/sidetiq
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: High-resolution job scheduler for Sidekiq
+test_files:
+- test/helper.rb
+- test/test_clock.rb
+- test/test_config.rb
+- test/test_errors.rb
+- test/test_middleware.rb
+- test/test_schedule.rb
+- test/test_version.rb
+- test/test_web.rb
+has_rdoc: