clockwork 0.5.4 → 0.5.5

data/README.md

@@ -16,51 +16,63 @@ Quickstart
 
 Create clock.rb:
 
-    require 'clockwork'
-    include Clockwork
+```ruby
+require 'clockwork'
+include Clockwork
 
-    handler do |job|
-      puts "Running #{job}"
-    end
+handler do |job|
+  puts "Running #{job}"
+end
 
-    every(10.seconds, 'frequent.job')
-    every(3.minutes, 'less.frequent.job')
-    every(1.hour, 'hourly.job')
+every(10.seconds, 'frequent.job')
+every(3.minutes, 'less.frequent.job')
+every(1.hour, 'hourly.job')
 
-    every(1.day, 'midnight.job', :at => '00:00')
+every(1.day, 'midnight.job', :at => '00:00')
+```
 
 Run it with the clockwork binary:
 
-    $ clockwork clock.rb
-    Starting clock for 4 events: [ frequent.job less.frequent.job hourly.job midnight.job ]
-    Triggering frequent.job
+```
+$ clockwork clock.rb
+Starting clock for 4 events: [ frequent.job less.frequent.job hourly.job midnight.job ]
+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/)).
 
-    require '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.
 
-    module Clockwork
+```ruby
+require 'clockwork'
 
-      configure do |config|
-        config[:tz] = "America/Chicago"
-      end
+module Clockwork
 
-      handler do |job|
-        puts "Running #{job}"
-      end
+  configure do |config|
+    config[:tz] = "America/Chicago"
+  end
 
-      every(10.seconds, 'frequent.job')
-      every(3.minutes, 'less.frequent.job')
-      every(1.hour, 'hourly.job')
+  handler do |job|
+    puts "Running #{job}"
+  end
 
-      every(1.day, 'midnight.job', :at => '00:00')
-    end
+  every(10.seconds, 'frequent.job')
+  every(3.minutes, 'less.frequent.job')
+  every(1.hour, 'hourly.job')
+
+  every(1.day, 'midnight.job', :at => '00:00')
+end
+```
 
 If you need to load your entire environment for your jobs, simply add:
 
-    require './config/boot'
-		require './config/environment'
+```ruby
+require './config/boot'
+require './config/environment'
+```
 
 under the `require 'clockwork'` declaration.
 
@@ -89,12 +101,14 @@ scalability.
 
 For example, if you're using Beanstalk/Staker:
 
-    require 'stalker'
+```ruby
+require 'stalker'
 
-    handler { |job| Stalker.enqueue(job) }
+handler { |job| Stalker.enqueue(job) }
 
-    every(1.hour, 'feeds.refresh')
-    every(1.day, 'reminders.send', :at => '01:30')
+every(1.hour, 'feeds.refresh')
+every(1.day, 'reminders.send', :at => '01:30')
+```
 
 Using a queueing system which doesn't require that your full application be
 loaded is preferable, because the clock process can keep a tiny memory
@@ -102,11 +116,13 @@ footprint.  If you're using DJ or Resque, however, you can go ahead and load
 your full application enviroment, and use per-event blocks to call DJ or Resque
 enqueue methods.  For example, with DJ/Rails:
 
-    require 'config/boot'
-    require 'config/environment'
+```ruby
+require 'config/boot'
+require 'config/environment'
 
-    every(1.hour, 'feeds.refresh') { Feed.send_later(:refresh) }
-    every(1.day, 'reminders.send', :at => '01:30') { Reminder.send_later(:send_reminders) }
+every(1.hour, 'feeds.refresh') { Feed.send_later(:refresh) }
+every(1.day, 'reminders.send', :at => '01:30') { Reminder.send_later(:send_reminders) }
+```
 
 Parameters
 ----------
@@ -117,26 +133,36 @@ Parameters
 
 The simplest example:
 
-    every(1.day, 'reminders.send', :at => '01:30')
+```ruby
+every(1.day, 'reminders.send', :at => '01:30')
+```
 
 You can omit 0 of the hour:
 
-    every(1.day, 'reminders.send', :at => '1:30')
+```ruby
+every(1.day, 'reminders.send', :at => '1:30')
+```
 
 The wildcard for hour is supported:
 
-    every(1.hour, 'reminders.send', :at => '**:30')
+```ruby
+every(1.hour, 'reminders.send', :at => '**:30')
+```
 
 You can set more than one timing:
 
-    every(1.hour, 'reminders.send', :at => ['12:00', '18:00'])
-    # send reminders at noon and evening
+```ruby
+every(1.hour, 'reminders.send', :at => ['12:00', '18:00'])
+# send reminders at noon and evening
+```
 
 You can also specify a timezone (default is the local timezone):
 
-    every(1.day, 'reminders.send', :at => '00:00', :tz => 'UTC')
-    # Runs the job each day at midnight, UTC.
-    # The value for :tz can be anything supported by [TZInfo](http://tzinfo.rubyforge.org/)
+```ruby
+every(1.day, 'reminders.send', :at => '00:00', :tz => 'UTC')
+# Runs the job each day at midnight, UTC.
+# The value for :tz can be anything supported by [TZInfo](http://tzinfo.rubyforge.org/)
+```
 
 ### :if
 
@@ -145,14 +171,17 @@ return value is true.
 
 Run on every first day of month.
 
-    Clockwork.every(1.day, 'myjob', :if => lambda { |t| t.day == 1 })
+```ruby
+Clockwork.every(1.day, 'myjob', :if => lambda { |t| t.day == 1 })
+```
 
 The argument is an instance of `ActiveSupport::TimeWithZone` if the `:tz` option is set. Otherwise, it's an instance of `Time`.
 
 This argument cannot be omitted.  Please use _ as placeholder if not needed.
 
-    Clockwork.every(1.second, 'myjob', :if => lambda { |_| true })
-
+```ruby
+Clockwork.every(1.second, 'myjob', :if => lambda { |_| true })
+```
 
 ### :thread
 
@@ -188,12 +217,14 @@ jobs.
 
 ### Configuration example
 
-    Clockwork.configure do |config|
-      config[:sleep_timeout] = 5
-      config[:logger] = Logger.new(log_file_path)
-      config[:tz] = 'EST'
-      config[:max_threads] = 15
-    end
+```ruby
+Clockwork.configure do |config|
+  config[:sleep_timeout] = 5
+  config[:logger] = Logger.new(log_file_path)
+  config[:tz] = 'EST'
+  config[:max_threads] = 15
+end
+```
 
 Anatomy of a clock file
 -----------------------
@@ -205,7 +236,9 @@ and then the events themselves.
 
 The handler typically looks like this:
 
-    handler { |job| enqueue_your_job(job) }
+```ruby
+handler { |job| enqueue_your_job(job) }
+```
 
 This block will be invoked every time an event is triggered, with the job name
 passed in.  In most cases, you should be able to pass the job name directly
@@ -213,8 +246,10 @@ through to your queueing system.
 
 The second part of the file are the events, which roughly resembles a crontab:
 
-    every(5.minutes, 'thing.do')
-    every(1.hour, 'otherthing.do')
+```ruby
+every(5.minutes, 'thing.do')
+every(1.hour, 'otherthing.do')
+```
 
 In the first line of this example, an event will be triggered once every five
 minutes, passing the job name 'thing.do' into the handler.  The handler shown
@@ -225,16 +260,20 @@ rely on classes rather than job names (i.e. DJ and Resque).  In this case, you
 need not define a general event handler, and instead provide one with each
 event:
 
-    every(5.minutes, 'thing.do') { Thing.send_later(:do) }
+```ruby
+every(5.minutes, 'thing.do') { Thing.send_later(:do) }
+```
 
 If you provide a custom handler for the block, the job name is used only for
 logging.
 
 You can also use blocks to do more complex checks:
 
-    every(1.day, 'check.leap.year') do
-      Stalker.enqueue('leap.year.party') if Time.now.year % 4 == 0
-    end
+```ruby
+every(1.day, 'check.leap.year') do
+  Stalker.enqueue('leap.year.party') if Time.now.year % 4 == 0
+end
+```
 
 In production
 -------------
@@ -259,7 +298,9 @@ You need `daemons` gem to use `clockworkd`.  It is not automatically installed,
 
 Then,
 
-    clockworkd -c YOUR_CLOCK.rb start
+```
+clockworkd -c YOUR_CLOCK.rb start
+```
 
 For more details, see help shown by `clockworkd`.
 

data/Rakefile

@@ -1,7 +1,7 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
 
 task 'test' do
-  sh "ruby test/clockwork_test.rb"
+  sh 'ruby test/clockwork_test.rb'
 end
 
 task :default => :test

data/bin/clockwork

@@ -4,7 +4,7 @@ STDERR.sync = STDOUT.sync = true
 
 require 'clockwork'
 
-usage = "clockwork <clock.rb>"
+usage = 'clockwork <clock.rb>'
 file = ARGV.shift or abort usage
 
 file = "./#{file}" unless file.match(/^[\/.]/)

data/clockwork.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "clockwork"
-  s.version = "0.5.4"
+  s.version = "0.5.5"
 
   s.authors = ["Adam Wiggins", "tomykaira"]
   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."

data/example.rb

@@ -12,5 +12,5 @@ every(1.hour, 'run.me.every.hour')
 every(1.day, 'run.me.at.midnight', :at => '00:00')
 
 every(1.day, 'custom.event.handler', :at => '00:30') do
-  puts "This event has its own handler"
+  puts 'This event has its own handler'
 end

data/lib/clockwork.rb

@@ -17,7 +17,7 @@ module Clockwork
       case at
       when /^([[:alpha:]]+)\s(.*)$/
         ret = parse($2)
-        wday = WDAYS.find_index {|x| x.include?($1) }
+        wday = WDAYS.find_index { |x| x.include?($1) }
         raise FailedToParse, at if wday.nil?
         ret.wday = wday
         ret
@@ -69,9 +69,7 @@ module Clockwork
         end
       end
 
-      if options[:thread]
-        @thread = options[:thread]
-      end
+      @thread = !!(options.has_key?(:thread) ? options[:thread] : Clockwork.config[:thread])
 
       @timezone = options[:tz] || Clockwork.config[:tz]
     end
@@ -94,16 +92,12 @@ module Clockwork
       @thread
     end
 
-    def thread_available?
-      Thread.list.count < Clockwork.config[:max_threads]
-    end
-
     def run(t)
       t = convert_timezone(t)
       @last = t
 
       if thread?
-        if thread_available?
+        if Clockwork.thread_available?
           Thread.new { execute }
         else
           log_error "Threads exhausted; skipping #{self}"
@@ -135,6 +129,10 @@ module Clockwork
     end
   end
 
+  def thread_available?
+    Thread.list.count < config[:max_threads]
+  end
+
   def configure
     yield(config)
   end
@@ -146,7 +144,7 @@ module Clockwork
   extend self
 
   def default_configuration
-    { :sleep_timeout => 1, :logger => Logger.new(STDOUT), :max_threads => 10 }
+    { :sleep_timeout => 1, :logger => Logger.new(STDOUT), :thread => false, :max_threads => 10 }
   end
 
   @@configuration = default_configuration

data/test/clockwork_test.rb

@@ -180,17 +180,20 @@ class ClockworkTest < Test::Unit::TestCase
       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
@@ -246,7 +249,7 @@ class ClockworkTest < Test::Unit::TestCase
   end
 
   test ":if it is compared to a time with zone" do
-    tz = "America/Chicago"
+    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
@@ -271,4 +274,34 @@ class ClockworkTest < Test::Unit::TestCase
     Clockwork.tick(Time.now)
   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
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clockwork
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.5.5
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-24 00:00:00.000000000 Z
+date: 2013-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tzinfo
@@ -163,7 +163,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 437114255
+      hash: -871026735
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -172,7 +172,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 437114255
+      hash: -871026735
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23