clockwork 0.3.2 → 0.3.3

data/Rakefile

@@ -1,23 +1,23 @@
 require 'jeweler'
 
 Jeweler::Tasks.new do |s|
-	s.name = "clockwork"
-	s.summary = "A scheduler process to replace cron."
-	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.author = "Adam Wiggins"
-	s.email = "adam@heroku.com"
-	s.homepage = "http://github.com/adamwiggins/clockwork"
-	s.executables = [ "clockwork" ]
-	s.rubyforge_project = "clockwork"
+  s.name = "clockwork"
+  s.summary = "A scheduler process to replace cron."
+  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.author = "Adam Wiggins"
+  s.email = "adam@heroku.com"
+  s.homepage = "http://github.com/adamwiggins/clockwork"
+  s.executables = [ "clockwork" ]
+  s.rubyforge_project = "clockwork"
 
-	s.files = FileList["[A-Z]*", "{bin,lib}/**/*"]
-	s.test_files = FileList["{test}/**/*"]
+  s.files = FileList["[A-Z]*", "{bin,lib}/**/*"]
+  s.test_files = FileList["{test}/**/*"]
 end
 
 Jeweler::GemcutterTasks.new
 
 task 'test' do
-	sh "ruby test/clockwork_test.rb"
+  sh "ruby test/clockwork_test.rb"
 end
 
 task :build => :test

data/VERSION

@@ -1 +1 @@
-0.3.2
+0.3.3

data/bin/clockwork

@@ -12,8 +12,8 @@ file = "./#{file}" unless file.match(/^[\/.]/)
 require file
 
 trap('INT') do
-	puts "\rExiting"
-	exit
+  puts "\rExiting"
+  exit
 end
 
 Clockwork::run

data/lib/clockwork.rb

@@ -1,145 +1,177 @@
 module Clockwork
-	class FailedToParse < StandardError; end;
-
-	@@events = []
-
-	class Event
-		attr_accessor :job, :last
-
-		def initialize(period, job, block, options={})
-			@period = period
-			@job = job
-			@at = parse_at(options[:at])
-			@last = nil
-			@block = block
-		end
-
-		def to_s
-			@job
-		end
-
-		def time?(t)
-			ellapsed_ready = (@last.nil? or (t - @last).to_i >= @period)
-			time_ready = (@at.nil? or ((@at[0].nil? or t.hour == @at[0]) and t.min == @at[1]))
-			ellapsed_ready and time_ready
-		end
-
-		def run(t)
-			@last = t
-			@block.call(@job)
-		rescue => e
-			log_error(e)
-		end
-
-		def log_error(e)
-			STDERR.puts exception_message(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
-
-		def parse_at(at)
-			return unless at
-			case at
-			when /^(\d{1,2}):(\d\d)$/
-				hour = $1.to_i
-				min  = $2.to_i
-				raise FailedToParse, at if hour >= 24 || min >= 60
-				[hour, min]
-			when /^\*{1,2}:(\d\d)$/
-				min = $1.to_i
-				raise FailedToParse, at if min >= 60
-				[nil, min]
-			else
-				raise FailedToParse, at
-			end
-		end
-	end
-
-	extend self
-
-	def handler(&block)
-		@@handler = block
-	end
-
-	class NoHandlerDefined < RuntimeError; 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 1
-		end
-	end
-
-	def log(msg)
-		puts 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
-	end
-
-	def clear!
-		@@events = []
-		@@handler = nil
-	end
-
-	private
-	def register(period, job, block, options)
-		event = Event.new(period, job, block || get_handler, options)
-		@@events << event
-		event
-	end
-	
+
+  @@events = []
+
+  class At
+    class FailedToParse < StandardError; end;
+    NOT_SPECIFIED = class << nil
+                      include Comparable
+                      def <=>(other); 0; end # equals to anything
+                    end
+    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 < 0 || hour > 23 ||
+          wday < 0 || wday > 6
+        raise ArgumentError
+      end
+      @min = min
+      @hour = hour
+      @wday = wday
+    end
+
+    def ready?(t)
+      t.min == @min and t.hour == @hour and 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
+    end
+
+    def to_s
+      @job
+    end
+
+    def time?(t)
+      ellapsed_ready = (@last.nil? or (t - @last).to_i >= @period)
+      ellapsed_ready and (@at.nil? or @at.ready?(t))
+    end
+
+    def run(t)
+      @last = t
+      @block.call(@job)
+    rescue => e
+      log_error(e)
+    end
+
+    def log_error(e)
+      STDERR.puts exception_message(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
+
+  extend self
+
+  def handler(&block)
+    @@handler = block
+  end
+
+  class NoHandlerDefined < RuntimeError; 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 1
+    end
+  end
+
+  def log(msg)
+    puts 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
+  end
+
+  def clear!
+    @@events = []
+    @@handler = nil
+  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) 
+unless 1.respond_to?(:seconds)
   class Numeric
-  	def seconds; self; end
-  	alias :second :seconds
+    def seconds; self; end
+    alias :second :seconds
+
+    def minutes; self * 60; end
+    alias :minute :minutes
 
-  	def minutes; self * 60; end
-  	alias :minute :minutes
+    def hours; self * 3600; end
+    alias :hour :hours
 
-  	def hours; self * 3600; end
-  	alias :hour :hours
+    def days; self * 86400; end
+    alias :day :days
 
-  	def days; self * 86400; end
-  	alias :day :days
+    def weeks; self * 604800; end
+    alias :week :weeks
   end
 end

data/test/clockwork_test.rb

@@ -5,142 +5,168 @@ require 'mocha'
 require 'time'
 
 module Clockwork
-	def log(msg)
-	end
+  def log(msg)
+  end
 end
 
 class ClockworkTest < Test::Unit::TestCase
-	setup do
-		Clockwork.clear!
-		Clockwork.handler { }
-	end
-
-	def assert_will_run(t)
-		if t.is_a? String
-			t = Time.parse(t)
-		end
-		assert_equal 1, Clockwork.tick(t).size
-	end
-
-	def assert_wont_run(t)
-		if t.is_a? String
-			t = Time.parse(t)
-		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 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 "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::FailedToParse) do
-			Clockwork.every(1.day, "myjob", :at => "a:bc")
-		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)
-		assert_nothing_raised { Clockwork.tick(Time.now) }
-	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
+  setup do
+    Clockwork.clear!
+    Clockwork.handler { }
+  end
+
+  def assert_will_run(t)
+    if t.is_a? String
+      t = Time.parse(t)
+    end
+    assert_equal 1, Clockwork.tick(t).size
+  end
+
+  def assert_wont_run(t)
+    if t.is_a? String
+      t = Time.parse(t)
+    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")
+    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)
+    assert_nothing_raised { Clockwork.tick(Time.now) }
+  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
 end

metadata

@@ -2,7 +2,7 @@
 name: clockwork
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors: 
 - Adam Wiggins
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-11 00:00:00 +09:00
+date: 2011-12-13 00:00:00 +09:00
 default_executable: clockwork
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -77,6 +77,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: -31480467
+      segments: 
+      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false