clockwork 0.5.5 → 0.6.0

data/README.md

@@ -42,10 +42,6 @@ Triggering frequent.job
 If you would not like to taint the namespace with `include Clockwork`, you can use
 it as the module (thanks to [hoverlover](https://github.com/hoverlover/clockwork/)).
 
-As reported in [issue #41](https://github.com/tomykaira/clockwork/issues/41#issuecomment-22073609),
-this technique is necessary when you use Clockwork with Sinatra,
-because both Sinatra and Clockwork add `register()` method into global namespace.
-
 ```ruby
 require 'clockwork'
 

data/Rakefile

@@ -1,7 +1,9 @@
 require 'bundler/gem_tasks'
+require 'rake/testtask'
 
-task 'test' do
-  sh 'ruby test/clockwork_test.rb'
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = false
 end
 
 task :default => :test

data/clockwork.gemspec

@@ -1,8 +1,9 @@
 Gem::Specification.new do |s|
   s.name = "clockwork"
-  s.version = "0.5.5"
+  s.version = "0.6.0"
 
   s.authors = ["Adam Wiggins", "tomykaira"]
+  s.license = 'MIT'
   s.description = "A scheduler process to replace cron, using a more flexible Ruby syntax running as a single long-running process.  Inspired by rufus-scheduler and resque-scheduler."
   s.email = ["adam@heroku.com", "tomykaira@gmail.com"]
   s.extra_rdoc_files = [

data/lib/clockwork.rb

@@ -1,215 +1,34 @@
 require 'logger'
 require 'active_support/time'
 
-module Clockwork
-
-  @@events = []
-
-  class At
-    class FailedToParse < StandardError; end;
-    NOT_SPECIFIED = nil
-    WDAYS = %w[sunday monday tuesday wednesday thursday friday saturday].map do |w|
-      [w, w.capitalize, w[0...3], w[0...3].capitalize]
-    end
-
-    def self.parse(at)
-      return unless at
-      case at
-      when /^([[:alpha:]]+)\s(.*)$/
-        ret = parse($2)
-        wday = WDAYS.find_index { |x| x.include?($1) }
-        raise FailedToParse, at if wday.nil?
-        ret.wday = wday
-        ret
-      when /^(\d{1,2}):(\d\d)$/
-        new($2.to_i, $1.to_i)
-      when /^\*{1,2}:(\d\d)$/
-        new($1.to_i)
-      else
-        raise FailedToParse, at
-      end
-    rescue ArgumentError
-      raise FailedToParse, at
-    end
-
-    attr_writer :min, :hour, :wday
-
-    def initialize(min, hour=NOT_SPECIFIED, wday=NOT_SPECIFIED)
-      if min.nil? || min < 0 || min > 59 ||
-          (hour != NOT_SPECIFIED && (hour < 0 || hour > 23)) ||
-          (wday != NOT_SPECIFIED && (wday < 0 || wday > 6))
-        raise ArgumentError
-      end
-      @min = min
-      @hour = hour
-      @wday = wday
-    end
-
-    def ready?(t)
-      t.min == @min and
-        (@hour == NOT_SPECIFIED or t.hour == @hour) and
-        (@wday == NOT_SPECIFIED or t.wday == @wday)
-    end
-  end
-
-  class Event
-    attr_accessor :job, :last
-
-    def initialize(period, job, block, options={})
-      @period = period
-      @job = job
-      @at = At.parse(options[:at])
-      @last = nil
-      @block = block
-      if options[:if]
-        if options[:if].respond_to?(:call)
-          @if = options[:if]
-        else
-          raise ArgumentError.new(':if expects a callable object, but #{options[:if]} does not respond to call')
-        end
-      end
-
-      @thread = !!(options.has_key?(:thread) ? options[:thread] : Clockwork.config[:thread])
-
-      @timezone = options[:tz] || Clockwork.config[:tz]
-    end
-
-    def to_s
-      @job
-    end
-
-    def convert_timezone(t)
-      @timezone ? t.in_time_zone(@timezone) : t
-    end
-
-    def time?(t)
-      t = convert_timezone(t)
-      elapsed_ready = (@last.nil? or (t - @last).to_i >= @period)
-      elapsed_ready and (@at.nil? or @at.ready?(t)) and (@if.nil? or @if.call(t))
-    end
-
-    def thread?
-      @thread
-    end
-
-    def run(t)
-      t = convert_timezone(t)
-      @last = t
-
-      if thread?
-        if Clockwork.thread_available?
-          Thread.new { execute }
-        else
-          log_error "Threads exhausted; skipping #{self}"
-        end
-      else
-        execute
-      end
-    end
-
-    def execute
-      @block.call(@job)
-    rescue => e
-      log_error e
-    end
-
-    def log_error(e)
-      Clockwork.config[:logger].error(e)
-    end
-
-    def exception_message(e)
-      msg = [ "Exception #{e.class} -> #{e.message}" ]
-
-      base = File.expand_path(Dir.pwd) + '/'
-      e.backtrace.each do |t|
-        msg << "   #{File.expand_path(t).gsub(/#{base}/, '')}"
-      end
-
-      msg.join("\n")
-    end
-  end
-
-  def thread_available?
-    Thread.list.count < config[:max_threads]
-  end
-
-  def configure
-    yield(config)
-  end
-
-  def config
-    @@configuration
-  end
+require 'clockwork/at'
+require 'clockwork/event'
+require 'clockwork/manager'
 
+module Clockwork
   extend self
 
-  def default_configuration
-    { :sleep_timeout => 1, :logger => Logger.new(STDOUT), :thread => false, :max_threads => 10 }
-  end
+  @@manager = Manager.new
 
-  @@configuration = default_configuration
-
-  def handler(&block)
-    @@handler = block
+  def configure(&block)
+    @@manager.configure(&block)
   end
 
-  class NoHandlerDefined < RuntimeError; end
-
-  def get_handler
-    raise NoHandlerDefined unless (defined?(@@handler) and @@handler)
-    @@handler
+  def handler(&block)
+    @@manager.handler(&block)
   end
 
   def every(period, job, options={}, &block)
-    if options[:at].respond_to?(:each)
-      each_options = options.clone
-      options[:at].each do |at|
-        each_options[:at] = at
-        register(period, job, block, each_options)
-      end
-    else
-      register(period, job, block, options)
-    end
+    @@manager.every(period, job, options, &block)
   end
 
   def run
-    log "Starting clock for #{@@events.size} events: [ " + @@events.map { |e| e.to_s }.join(' ') + " ]"
-    loop do
-      tick
-      sleep(config[:sleep_timeout])
-    end
-  end
-
-  def log(msg)
-    config[:logger].info(msg)
-  end
-
-  def tick(t=Time.now)
-    to_run = @@events.select do |event|
-      event.time?(t)
-    end
-
-    to_run.each do |event|
-      log "Triggering '#{event}'"
-      event.run(t)
-    end
-
-    to_run
+    @@manager.run
   end
 
   def clear!
-    @@events = []
-    @@handler = nil
-    @@configuration = Clockwork.default_configuration
+    @@manager = Manager.new
   end
-
-  private
-  def register(period, job, block, options)
-    event = Event.new(period, job, block || get_handler, options)
-    @@events << event
-    event
-  end
-
 end
 
 unless 1.respond_to?(:seconds)

data/lib/clockwork/at.rb

@@ -0,0 +1,49 @@
+module Clockwork
+  class At
+    class FailedToParse < StandardError; end
+
+    NOT_SPECIFIED = nil
+    WDAYS = %w[sunday monday tuesday wednesday thursday friday saturday].map do |w|
+      [w, w.capitalize, w[0...3], w[0...3].capitalize]
+    end
+
+    def self.parse(at)
+      return unless at
+      case at
+      when /^([[:alpha:]]+)\s(.*)$/
+        ret = parse($2)
+        wday = WDAYS.find_index { |x| x.include?($1) }
+        raise FailedToParse, at if wday.nil?
+        ret.wday = wday
+        ret
+      when /^(\d{1,2}):(\d\d)$/
+        new($2.to_i, $1.to_i)
+      when /^\*{1,2}:(\d\d)$/
+        new($1.to_i)
+      else
+        raise FailedToParse, at
+      end
+    rescue ArgumentError
+      raise FailedToParse, at
+    end
+
+    attr_writer :min, :hour, :wday
+
+    def initialize(min, hour=NOT_SPECIFIED, wday=NOT_SPECIFIED)
+      if min.nil? || min < 0 || min > 59 ||
+          (hour != NOT_SPECIFIED && (hour < 0 || hour > 23)) ||
+          (wday != NOT_SPECIFIED && (wday < 0 || wday > 6))
+        raise ArgumentError
+      end
+      @min = min
+      @hour = hour
+      @wday = wday
+    end
+
+    def ready?(t)
+      t.min == @min and
+        (@hour == NOT_SPECIFIED or t.hour == @hour) and
+        (@wday == NOT_SPECIFIED or t.wday == @wday)
+    end
+  end
+end

data/lib/clockwork/event.rb

@@ -0,0 +1,71 @@
+module Clockwork
+  class Event
+    attr_accessor :job, :last
+
+    def initialize(manager, period, job, block, options={})
+      @manager = manager
+      @period = period
+      @job = job
+      @at = At.parse(options[:at])
+      @last = nil
+      @block = block
+      @if = options[:if]
+      @thread = options[:thread]
+      @timezone = options[:tz]
+    end
+
+    def to_s
+      @job
+    end
+
+    def convert_timezone(t)
+      @timezone ? t.in_time_zone(@timezone) : t
+    end
+
+    def time?(t)
+      t = convert_timezone(t)
+      elapsed_ready = (@last.nil? or (t - @last).to_i >= @period)
+      elapsed_ready and (@at.nil? or @at.ready?(t)) and (@if.nil? or @if.call(t))
+    end
+
+    def thread?
+      @thread
+    end
+
+    def run(t)
+      t = convert_timezone(t)
+      @last = t
+
+      if thread?
+        if @manager.thread_available?
+          Thread.new { execute }
+        else
+          log_error "Threads exhausted; skipping #{self}"
+        end
+      else
+        execute
+      end
+    end
+
+    def execute
+      @block.call(@job)
+    rescue => e
+      log_error e
+    end
+
+    def log_error(e)
+      @manager.config[:logger].error(e)
+    end
+
+    def exception_message(e)
+      msg = [ "Exception #{e.class} -> #{e.message}" ]
+
+      base = File.expand_path(Dir.pwd) + '/'
+      e.backtrace.each do |t|
+        msg << "   #{File.expand_path(t).gsub(/#{base}/, '')}"
+      end
+
+      msg.join("\n")
+    end
+  end
+end

data/lib/clockwork/manager.rb

@@ -0,0 +1,91 @@
+module Clockwork
+  class Manager
+    class NoHandlerDefined < RuntimeError; end
+
+    attr_reader :config
+
+    def initialize
+      @events = []
+      @config = default_configuration
+      @handler = nil
+    end
+
+    def thread_available?
+      Thread.list.count < config[:max_threads]
+    end
+
+    def configure
+      yield(config)
+    end
+
+    def default_configuration
+      { :sleep_timeout => 1, :logger => Logger.new(STDOUT), :thread => false, :max_threads => 10 }
+    end
+
+    def handler(&block)
+      @handler = block
+    end
+
+    def get_handler
+      raise NoHandlerDefined unless (defined?(@handler) and @handler)
+      @handler
+    end
+
+    def every(period, job, options={}, &block)
+      if options[:at].respond_to?(:each)
+        each_options = options.clone
+        options[:at].each do |at|
+          each_options[:at] = at
+          register(period, job, block, each_options)
+        end
+      else
+        register(period, job, block, options)
+      end
+    end
+
+    def run
+      log "Starting clock for #{@events.size} events: [ " + @events.map { |e| e.to_s }.join(' ') + " ]"
+      loop do
+        tick
+        sleep(config[:sleep_timeout])
+      end
+    end
+
+    def tick(t=Time.now)
+      to_run = @events.select do |event|
+        event.time?(t)
+      end
+
+      to_run.each do |event|
+        log "Triggering '#{event}'"
+        event.run(t)
+      end
+
+      to_run
+    end
+
+    private
+    def log(msg)
+      config[:logger].info(msg)
+    end
+
+    def register(period, job, block, options)
+      event = Event.new(self, period, job, block || get_handler, parse_event_option(options))
+      @events << event
+      event
+    end
+
+    def parse_event_option(options)
+      if options[:if]
+        if !options[:if].respond_to?(:call)
+          raise ArgumentError.new(':if expects a callable object, but #{options[:if]} does not respond to call')
+        end
+      end
+
+      options[:thread] = !!(options.has_key?(:thread) ? options[:thread] : config[:thread])
+      options[:tz] ||= config[:tz]
+
+      options
+    end
+  end
+end

data/test/at_test.rb

@@ -0,0 +1,67 @@
+require File.expand_path('../../lib/clockwork', __FILE__)
+require 'rubygems'
+require 'contest'
+require 'mocha/setup'
+require 'time'
+require 'active_support/time'
+
+class AtTest < Test::Unit::TestCase
+  def time_in_day(hour, minute)
+    Time.new(2013, 1, 1, hour, minute, 0)
+  end
+
+  test '16:20' do
+    at = Clockwork::At.parse('16:20')
+    assert !at.ready?(time_in_day(16, 19))
+    assert  at.ready?(time_in_day(16, 20))
+    assert !at.ready?(time_in_day(16, 21))
+  end
+
+  test '8:20' do
+    at = Clockwork::At.parse('8:20')
+    assert !at.ready?(time_in_day(8, 19))
+    assert  at.ready?(time_in_day(8, 20))
+    assert !at.ready?(time_in_day(8, 21))
+  end
+
+  test '**:20' do
+    at = Clockwork::At.parse('**:20')
+
+    assert !at.ready?(time_in_day(15, 19))
+    assert  at.ready?(time_in_day(15, 20))
+    assert !at.ready?(time_in_day(15, 21))
+
+    assert !at.ready?(time_in_day(16, 19))
+    assert  at.ready?(time_in_day(16, 20))
+    assert !at.ready?(time_in_day(16, 21))
+  end
+
+  test '**:20' do
+    at = Clockwork::At.parse('*:20')
+
+    assert !at.ready?(time_in_day(15, 19))
+    assert  at.ready?(time_in_day(15, 20))
+    assert !at.ready?(time_in_day(15, 21))
+
+    assert !at.ready?(time_in_day(16, 19))
+    assert  at.ready?(time_in_day(16, 20))
+    assert !at.ready?(time_in_day(16, 21))
+  end
+
+  test 'Saturday 12:00' do
+    at = Clockwork::At.parse('Saturday 12:00')
+
+    assert !at.ready?(Time.new(2010, 1, 1, 12, 00))
+    assert  at.ready?(Time.new(2010, 1, 2, 12, 00)) # Saturday
+    assert !at.ready?(Time.new(2010, 1, 3, 12, 00))
+    assert  at.ready?(Time.new(2010, 1, 9, 12, 00))
+  end
+
+  test 'Saturday 12:00' do
+    at = Clockwork::At.parse('sat 12:00')
+
+    assert !at.ready?(Time.new(2010, 1, 1, 12, 00))
+    assert  at.ready?(Time.new(2010, 1, 2, 12, 00))
+    assert !at.ready?(Time.new(2010, 1, 3, 12, 00))
+  end
+end

data/test/clockwork_test.rb

@@ -1,307 +1,62 @@
 require File.expand_path('../../lib/clockwork', __FILE__)
-require 'rubygems'
 require 'contest'
-require 'mocha/setup'
-require 'time'
-require 'active_support/time'
-
-module Clockwork
-  def log(msg)
-  end
-end
+require 'timeout'
 
 class ClockworkTest < Test::Unit::TestCase
-  setup do
+  teardown do
     Clockwork.clear!
-    Clockwork.handler { }
   end
 
-  def assert_will_run(t)
-    if t.is_a? String
-      t = Time.parse(t)
+  def set_string_io_logger
+    string_io = StringIO.new
+    Clockwork.configure do |config|
+      config[:logger] = Logger.new(string_io)
     end
-    assert_equal 1, Clockwork.tick(t).size
+    string_io
   end
 
-  def assert_wont_run(t)
-    if t.is_a? String
-      t = Time.parse(t)
+  def run_in_thread
+    Thread.new do
+      Clockwork.run
     end
-    assert_equal 0, Clockwork.tick(t).size
   end
 
-  test "once a minute" do
-    Clockwork.every(1.minute, 'myjob')
-
-    assert_will_run(t=Time.now)
-    assert_wont_run(t+30)
-    assert_will_run(t+60)
-  end
-
-  test "every three minutes" do
-    Clockwork.every(3.minutes, 'myjob')
-
-    assert_will_run(t=Time.now)
-    assert_wont_run(t+2*60)
-    assert_will_run(t+3*60)
-  end
-
-  test "once an hour" do
-    Clockwork.every(1.hour, 'myjob')
-
-    assert_will_run(t=Time.now)
-    assert_wont_run(t+30*60)
-    assert_will_run(t+60*60)
-  end
-
-  test "once a week" do
-    Clockwork.every(1.week, 'myjob')
-
-    assert_will_run(t=Time.now)
-    assert_wont_run(t+60*60*24*6)
-    assert_will_run(t+60*60*24*7)
-  end
-
-  test "once a day at 16:20" do
-    Clockwork.every(1.day, 'myjob', :at => '16:20')
-
-    assert_wont_run 'jan 1 2010 16:19:59'
-    assert_will_run 'jan 1 2010 16:20:00'
-    assert_wont_run 'jan 1 2010 16:20:01'
-    assert_wont_run 'jan 2 2010 16:19:59'
-    assert_will_run 'jan 2 2010 16:20:00'
-  end
-
-  test ":at also accepts 8:20" do
-    Clockwork.every(1.hour, 'myjob', :at => '8:20')
-
-    assert_wont_run 'jan 1 2010 08:19:59'
-    assert_will_run 'jan 1 2010 08:20:00'
-    assert_wont_run 'jan 1 2010 08:20:01'
-  end
-
-  test "twice a day at 16:20 and 18:10" do
-    Clockwork.every(1.day, 'myjob', :at => ['16:20', '18:10'])
-
-    assert_wont_run 'jan 1 2010 16:19:59'
-    assert_will_run 'jan 1 2010 16:20:00'
-    assert_wont_run 'jan 1 2010 16:20:01'
-
-    assert_wont_run 'jan 1 2010 18:09:59'
-    assert_will_run 'jan 1 2010 18:10:00'
-    assert_wont_run 'jan 1 2010 18:10:01'
-  end
-
-  test "once an hour at **:20" do
-    Clockwork.every(1.hour, 'myjob', :at => '**:20')
-
-    assert_wont_run 'jan 1 2010 15:19:59'
-    assert_will_run 'jan 1 2010 15:20:00'
-    assert_wont_run 'jan 1 2010 15:20:01'
-    assert_wont_run 'jan 2 2010 16:19:59'
-    assert_will_run 'jan 2 2010 16:20:00'
-  end
-
-  test ":at also accepts *:20" do
-    Clockwork.every(1.hour, 'myjob', :at => '*:20')
-
-    assert_wont_run 'jan 1 2010 15:19:59'
-    assert_will_run 'jan 1 2010 15:20:00'
-    assert_wont_run 'jan 1 2010 15:20:01'
-  end
-
-  test "on every Saturday" do
-    Clockwork.every(1.week, 'myjob', :at => 'Saturday 12:00')
-
-    assert_wont_run 'jan 1 2010 12:00:00'
-    assert_will_run 'jan 2 2010 12:00:00' # Saturday
-    assert_wont_run 'jan 3 2010 12:00:00'
-    assert_wont_run 'jan 8 2010 12:00:00'
-    assert_will_run 'jan 9 2010 12:00:00'
-  end
-
-  test ":at accepts abbreviated weekday" do
-    Clockwork.every(1.week, 'myjob', :at => 'sat 12:00')
-
-    assert_wont_run 'jan 1 2010 12:00:00'
-    assert_will_run 'jan 2 2010 12:00:00' # Saturday
-    assert_wont_run 'jan 3 2010 12:00:00'
-  end
-
-  test "aborts when no handler defined" do
-    Clockwork.clear!
-    assert_raise(Clockwork::NoHandlerDefined) do
-      Clockwork.every(1.minute, 'myjob')
-    end
-  end
-
-  test "aborts when fails to parse" do
-    assert_raise(Clockwork::At::FailedToParse) do
-      Clockwork.every(1.day, "myjob", :at => "a:bc")
+  test 'should run events with configured logger' do
+    run = false
+    string_io = set_string_io_logger
+    Clockwork.handler do |job|
+      run = job == 'myjob'
     end
-  end
-
-  test "general handler" do
-    $set_me = 0
-    Clockwork.handler { $set_me = 1 }
     Clockwork.every(1.minute, 'myjob')
-    Clockwork.tick(Time.now)
-    assert_equal 1, $set_me
-  end
-
-  test "event-specific handler" do
-    $set_me = 0
-    Clockwork.every(1.minute, 'myjob') { $set_me = 2 }
-    Clockwork.tick(Time.now)
-
-    assert_equal 2, $set_me
-  end
 
-  test "exceptions are trapped and logged" do
-    Clockwork.handler { raise 'boom' }
-    event = Clockwork.every(1.minute, 'myjob')
-    event.expects(:log_error)
+    runner = run_in_thread
 
-    assert_nothing_raised do
-      Clockwork.tick(Time.now)
+    timeout(5) do
+      sleep 1 until run
     end
+    runner.kill
+    assert run
+    assert string_io.string.include?('Triggering')
   end
 
-  test "exceptions still set the last timestamp to avoid spastic error loops" do
-    Clockwork.handler { raise 'boom' }
-    event = Clockwork.every(1.minute, 'myjob')
-    event.stubs(:log_error)
-    Clockwork.tick(t = Time.now)
-    assert_equal t, event.last
-  end
-
-  test "should be configurable" do
-    Clockwork.configure do |config|
-      config[:sleep_timeout] = 200
-      config[:logger] = "A Logger"
-      config[:max_threads] = 10
-      config[:thread] = true
-    end
-
-    assert_equal 200, Clockwork.config[:sleep_timeout]
-    assert_equal "A Logger", Clockwork.config[:logger]
-    assert_equal 10, Clockwork.config[:max_threads]
-    assert_equal true, Clockwork.config[:thread]
-  end
-
-  test "configuration should have reasonable defaults" do
-    assert_equal 1, Clockwork.config[:sleep_timeout]
-    assert Clockwork.config[:logger].is_a?(Logger)
-    assert_equal 10, Clockwork.config[:max_threads]
-    assert_equal false, Clockwork.config[:thread]
-  end
-
-  test "should be able to specify a different timezone than local" do
-    Clockwork.every(1.day, 'myjob', :at => '10:00', :tz => 'UTC')
-
-    assert_wont_run 'jan 1 2010 10:00:00 EST'
-    assert_will_run 'jan 1 2010 10:00:00 UTC'
-  end
-
-  test "should be able to specify a different timezone than local for multiple times" do
-    Clockwork.every(1.day, 'myjob', :at => ['10:00', '8:00'], :tz => 'UTC')
-
-    assert_wont_run 'jan 1 2010 08:00:00 EST'
-    assert_will_run 'jan 1 2010 08:00:00 UTC'
-    assert_wont_run 'jan 1 2010 10:00:00 EST'
-    assert_will_run 'jan 1 2010 10:00:00 UTC'
-  end
-
-  test "should be able to configure a default timezone to use for all events" do
-    Clockwork.configure { |config| config[:tz] = 'UTC' }
-    Clockwork.every(1.day, 'myjob', :at => '10:00')
-
-    assert_wont_run 'jan 1 2010 10:00:00 EST'
-    assert_will_run 'jan 1 2010 10:00:00 UTC'
-  end
-
-  test "should be able to override a default timezone in an event" do
-    Clockwork.configure { |config| config[:tz] = 'UTC' }
-    Clockwork.every(1.day, 'myjob', :at => '10:00', :tz => 'EST')
-
-    assert_will_run 'jan 1 2010 10:00:00 EST'
-    assert_wont_run 'jan 1 2010 10:00:00 UTC'
-  end
-
-  test ":if true then always run" do
-    Clockwork.every(1.second, 'myjob', :if => lambda { |_| true })
-
-    assert_will_run 'jan 1 2010 16:20:00'
-  end
-
-  test ":if false then never run" do
-    Clockwork.every(1.second, 'myjob', :if => lambda { |_| false })
-
-    assert_wont_run 'jan 1 2010 16:20:00'
-  end
-
-  test ":if the first day of month" do
-    Clockwork.every(1.second, 'myjob', :if => lambda { |t| t.day == 1 })
-
-    assert_will_run 'jan 1 2010 16:20:00'
-    assert_wont_run 'jan 2 2010 16:20:00'
-    assert_will_run 'feb 1 2010 16:20:00'
-  end
-
-  test ":if it is compared to a time with zone" do
-    tz = 'America/Chicago'
-    time = Time.utc(2012,5,25,10,00)
-    Clockwork.every(1.second, 'myjob', tz: tz, :if => lambda  { |t|(
-      ((time - 1.hour)..(time + 1.hour)).cover? t
-    )})
-    assert_will_run time
-  end
-
-  test ":if is not callable then raise ArgumentError" do
-    assert_raise(ArgumentError) do
-      Clockwork.every(1.second, 'myjob', :if => true)
-    end
-  end
-
-  test "should warn about missing jobs upon exhausting threads" do
-    Clockwork.configure do |config|
-      config[:max_threads] = 0
-    end
-
-    event = Clockwork.every(1.minute, 'myjob', :thread => true)
-    event.expects(:log_error).with("Threads exhausted; skipping #{event}")
+  test 'should not run anything after reset' do
+    Clockwork.every(1.minute, 'myjob') {  }
+    Clockwork.clear!
 
-    Clockwork.tick(Time.now)
+    string_io = set_string_io_logger
+    runner = run_in_thread
+    sleep 1
+    runner.kill
+    assert string_io.string.include?('0 events')
   end
 
-  describe "thread option" do
-    test "should not use thread by default" do
-      event = Clockwork.every(1.minute, 'myjob')
-      assert !event.thread?
-    end
-
-    test "should use thread if thread option is specified with truly value" do
-      event = Clockwork.every(1.minute, 'myjob', :thread => true)
-      assert event.thread?
-    end
-
-    test "should use thread if global thread option is set" do
-      Clockwork.configure do |config|
-        config[:thread] = true
-      end
-
-      event = Clockwork.every(1.minute, 'myjob')
-      assert event.thread?
-    end
-
-    test "should not use thread if job option overrides global option" do
-      Clockwork.configure do |config|
-        config[:thread] = true
-      end
-
-      event = Clockwork.every(1.minute, 'myjob', :thread => false)
-      assert !event.thread?
-    end
+  test 'should pass all arguments to every' do
+    Clockwork.every(1.second, 'myjob', if: lambda { false }) {  }
+    string_io = set_string_io_logger
+    runner = run_in_thread
+    sleep 1
+    runner.kill
+    assert string_io.string.include?('1 events')
+    assert !string_io.string.include?('Triggering')
   end
-
 end

data/test/manager_test.rb

@@ -0,0 +1,272 @@
+require File.expand_path('../../lib/clockwork', __FILE__)
+require 'rubygems'
+require 'contest'
+require 'mocha/setup'
+require 'time'
+require 'active_support/time'
+
+class ManagerTest < Test::Unit::TestCase
+  setup do
+    @manager = Clockwork::Manager.new
+    class << @manager
+      def log(msg); end
+    end
+    @manager.handler { }
+  end
+
+  def assert_will_run(t)
+    if t.is_a? String
+      t = Time.parse(t)
+    end
+    assert_equal 1, @manager.tick(t).size
+  end
+
+  def assert_wont_run(t)
+    if t.is_a? String
+      t = Time.parse(t)
+    end
+    assert_equal 0, @manager.tick(t).size
+  end
+
+  test "once a minute" do
+    @manager.every(1.minute, 'myjob')
+
+    assert_will_run(t=Time.now)
+    assert_wont_run(t+30)
+    assert_will_run(t+60)
+  end
+
+  test "every three minutes" do
+    @manager.every(3.minutes, 'myjob')
+
+    assert_will_run(t=Time.now)
+    assert_wont_run(t+2*60)
+    assert_will_run(t+3*60)
+  end
+
+  test "once an hour" do
+    @manager.every(1.hour, 'myjob')
+
+    assert_will_run(t=Time.now)
+    assert_wont_run(t+30*60)
+    assert_will_run(t+60*60)
+  end
+
+  test "once a week" do
+    @manager.every(1.week, 'myjob')
+
+    assert_will_run(t=Time.now)
+    assert_wont_run(t+60*60*24*6)
+    assert_will_run(t+60*60*24*7)
+  end
+
+  test "aborts when no handler defined" do
+    manager = Clockwork::Manager.new
+    assert_raise(Clockwork::Manager::NoHandlerDefined) do
+      manager.every(1.minute, 'myjob')
+    end
+  end
+
+  test "aborts when fails to parse" do
+    assert_raise(Clockwork::At::FailedToParse) do
+      @manager.every(1.day, "myjob", :at => "a:bc")
+    end
+  end
+
+  test "general handler" do
+    $set_me = 0
+    @manager.handler { $set_me = 1 }
+    @manager.every(1.minute, 'myjob')
+    @manager.tick(Time.now)
+    assert_equal 1, $set_me
+  end
+
+  test "event-specific handler" do
+    $set_me = 0
+    @manager.every(1.minute, 'myjob') { $set_me = 2 }
+    @manager.tick(Time.now)
+
+    assert_equal 2, $set_me
+  end
+
+  test "exceptions are trapped and logged" do
+    @manager.handler { raise 'boom' }
+    @manager.every(1.minute, 'myjob')
+
+    logger = Logger.new(StringIO.new)
+    @manager.configure { |c| c[:logger] = logger }
+    logger.expects(:error)
+
+    assert_nothing_raised do
+      @manager.tick(Time.now)
+    end
+  end
+
+  test "exceptions still set the last timestamp to avoid spastic error loops" do
+    @manager.handler { raise 'boom' }
+    event = @manager.every(1.minute, 'myjob')
+    event.stubs(:log_error)
+    @manager.tick(t = Time.now)
+    assert_equal t, event.last
+  end
+
+  test "should be configurable" do
+    @manager.configure do |config|
+      config[:sleep_timeout] = 200
+      config[:logger] = "A Logger"
+      config[:max_threads] = 10
+      config[:thread] = true
+    end
+
+    assert_equal 200, @manager.config[:sleep_timeout]
+    assert_equal "A Logger", @manager.config[:logger]
+    assert_equal 10, @manager.config[:max_threads]
+    assert_equal true, @manager.config[:thread]
+  end
+
+  test "configuration should have reasonable defaults" do
+    assert_equal 1, @manager.config[:sleep_timeout]
+    assert @manager.config[:logger].is_a?(Logger)
+    assert_equal 10, @manager.config[:max_threads]
+    assert_equal false, @manager.config[:thread]
+  end
+
+  describe ':at option' do
+    test "once a day at 16:20" do
+      @manager.every(1.day, 'myjob', :at => '16:20')
+
+      assert_wont_run 'jan 1 2010 16:19:59'
+      assert_will_run 'jan 1 2010 16:20:00'
+      assert_wont_run 'jan 1 2010 16:20:01'
+      assert_wont_run 'jan 2 2010 16:19:59'
+      assert_will_run 'jan 2 2010 16:20:00'
+    end
+
+    test "twice a day at 16:20 and 18:10" do
+      @manager.every(1.day, 'myjob', :at => ['16:20', '18:10'])
+
+      assert_wont_run 'jan 1 2010 16:19:59'
+      assert_will_run 'jan 1 2010 16:20:00'
+      assert_wont_run 'jan 1 2010 16:20:01'
+
+      assert_wont_run 'jan 1 2010 18:09:59'
+      assert_will_run 'jan 1 2010 18:10:00'
+      assert_wont_run 'jan 1 2010 18:10:01'
+    end
+  end
+
+  describe ':tz option' do
+    test "should be able to specify a different timezone than local" do
+      @manager.every(1.day, 'myjob', :at => '10:00', :tz => 'UTC')
+
+      assert_wont_run 'jan 1 2010 10:00:00 EST'
+      assert_will_run 'jan 1 2010 10:00:00 UTC'
+    end
+
+    test "should be able to specify a different timezone than local for multiple times" do
+      @manager.every(1.day, 'myjob', :at => ['10:00', '8:00'], :tz => 'UTC')
+
+      assert_wont_run 'jan 1 2010 08:00:00 EST'
+      assert_will_run 'jan 1 2010 08:00:00 UTC'
+      assert_wont_run 'jan 1 2010 10:00:00 EST'
+      assert_will_run 'jan 1 2010 10:00:00 UTC'
+    end
+
+    test "should be able to configure a default timezone to use for all events" do
+      @manager.configure { |config| config[:tz] = 'UTC' }
+      @manager.every(1.day, 'myjob', :at => '10:00')
+
+      assert_wont_run 'jan 1 2010 10:00:00 EST'
+      assert_will_run 'jan 1 2010 10:00:00 UTC'
+    end
+
+    test "should be able to override a default timezone in an event" do
+      @manager.configure { |config| config[:tz] = 'UTC' }
+      @manager.every(1.day, 'myjob', :at => '10:00', :tz => 'EST')
+
+      assert_will_run 'jan 1 2010 10:00:00 EST'
+      assert_wont_run 'jan 1 2010 10:00:00 UTC'
+    end
+  end
+
+  describe ':if option' do
+    test ":if true then always run" do
+      @manager.every(1.second, 'myjob', :if => lambda { |_| true })
+
+      assert_will_run 'jan 1 2010 16:20:00'
+    end
+
+    test ":if false then never run" do
+      @manager.every(1.second, 'myjob', :if => lambda { |_| false })
+
+      assert_wont_run 'jan 1 2010 16:20:00'
+    end
+
+    test ":if the first day of month" do
+      @manager.every(1.second, 'myjob', :if => lambda { |t| t.day == 1 })
+
+      assert_will_run 'jan 1 2010 16:20:00'
+      assert_wont_run 'jan 2 2010 16:20:00'
+      assert_will_run 'feb 1 2010 16:20:00'
+    end
+
+    test ":if it is compared to a time with zone" do
+      tz = 'America/Chicago'
+      time = Time.utc(2012,5,25,10,00)
+      @manager.every(1.second, 'myjob', tz: tz, :if => lambda  { |t|
+            ((time - 1.hour)..(time + 1.hour)).cover? t
+            })
+      assert_will_run time
+    end
+
+    test ":if is not callable then raise ArgumentError" do
+      assert_raise(ArgumentError) do
+        @manager.every(1.second, 'myjob', :if => true)
+      end
+    end
+  end
+
+  test "should warn about missing jobs upon exhausting threads" do
+    logger = Logger.new(StringIO.new)
+    @manager.configure do |config|
+      config[:max_threads] = 0
+      config[:logger] = logger
+    end
+
+    @manager.every(1.minute, 'myjob', :thread => true)
+    logger.expects(:error).with("Threads exhausted; skipping myjob")
+
+    @manager.tick(Time.now)
+  end
+
+  describe "thread option" do
+    test "should not use thread by default" do
+      event = @manager.every(1.minute, 'myjob')
+      assert !event.thread?
+    end
+
+    test "should use thread if thread option is specified with truly value" do
+      event = @manager.every(1.minute, 'myjob', :thread => true)
+      assert event.thread?
+    end
+
+    test "should use thread if global thread option is set" do
+      @manager.configure do |config|
+        config[:thread] = true
+      end
+
+      event = @manager.every(1.minute, 'myjob')
+      assert event.thread?
+    end
+
+    test "should not use thread if job option overrides global option" do
+      @manager.configure do |config|
+        config[:thread] = true
+      end
+
+      event = @manager.every(1.minute, 'myjob', :thread => false)
+      assert !event.thread?
+    end
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clockwork
 version: !ruby/object:Gem::Version
-  version: 0.5.5
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-04 00:00:00.000000000 Z
+date: 2013-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tzinfo
@@ -148,9 +148,15 @@ files:
 - gemfiles/activesupport3.gemfile
 - gemfiles/activesupport4.gemfile
 - lib/clockwork.rb
+- lib/clockwork/at.rb
+- lib/clockwork/event.rb
+- lib/clockwork/manager.rb
+- test/at_test.rb
 - test/clockwork_test.rb
+- test/manager_test.rb
 homepage: http://github.com/tomykaira/clockwork
-licenses: []
+licenses:
+- MIT
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -163,7 +169,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -871026735
+      hash: 1040886093
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -172,7 +178,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -871026735
+      hash: 1040886093
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -180,4 +186,6 @@ signing_key:
 specification_version: 3
 summary: A scheduler process to replace cron.
 test_files:
+- test/at_test.rb
 - test/clockwork_test.rb
+- test/manager_test.rb