rcron 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/CHANGELOG.rdoc

@@ -0,0 +1,3 @@
+=== 0.1.0 / 2011/08/31
+* Initial release
+

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "yard", "~> 0.6.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "rcov", ">= 0"
+  gem "simplecov"
+end

data/Gemfile.lock

@@ -0,0 +1,26 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.2)
+    rcov (0.9.10)
+    rcov (0.9.10-java)
+    simplecov (0.4.2)
+      simplecov-html (~> 0.4.4)
+    simplecov-html (0.4.5)
+    yard (0.6.8)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.4)
+  rcov
+  simplecov
+  yard (~> 0.6.0)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Junegunn Choi
+
+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.rdoc

@@ -0,0 +1,75 @@
+= rcron
+
+A simple cron-like scheduler for Ruby.
+
+== Installation
+  gem install rcron
+
+== Cron format
+As of now, most of the expressions except for ? and W are supported.
+
+http://en.wikipedia.org/wiki/Cron#Format
+
+== Examples
+
+=== Basic
+  require 'rcron'
+  rcron = RCron.new
+
+  # Enqueue a task
+  rcron.q('runs every two minutes', '*/2 * * * *') do |task|
+    # Task logic
+    # ...
+  end
+
+  # You can `q' any number of tasks before starting rcron
+
+  rcron.start
+
+=== One-time only task
+  rcron = RCron.new
+  rcron.q('will run once at 8pm next second friday', '0 8 * * fri#2') do |task|
+    # Removes the task from the queue
+    task.dq
+
+    # Task logic
+    # ...
+  end
+  rcron.start
+
+=== Options
+  rcron = RCron.new
+
+  # :exclusive - Only one instance of this task will run simultaneously.
+  # :timeout   - Task will be terminated if it takes longer than the specified seconds.
+  rcron.q('Every ten-minutes during summer', 
+          '*/10 * * jun-aug *', 
+          :exclusive => true, 
+          :timeout => 1200) do |task|
+    # Task logic
+    # ...
+  end
+
+  # log to $stderr instead of default $stdout
+  rcron.start $stderr
+
+== Notes
+- Minimum interval for each task is one-minute just like cron. So rcron usually sleeps most of the time and wakes up only once a minute. (Except when short timeouts for the tasks are specified. In that case, rcron wakes up more frequently to check whether the task should be terminated)
+- rcron checks to start tasks at the very first second of every minute. e.g. When you first start it at 12:00:45, it will sleep 15 seconds before doing anything.
+- Tested on Ruby 1.8.7, Ruby 1.9.2 and JRuby 1.6.4
+- 99.67% test coverage. (a false sense of security, though)
+
+== Contributing to rcron
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Junegunn Choi. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "rcron"
+  gem.homepage = "http://github.com/junegunn/rcron"
+  gem.license = "MIT"
+  gem.summary = %Q{A simple cron-like scheduler}
+  gem.description = %Q{A simple cron-like scheduler for Ruby}
+  gem.email = "junegunn.c@gmail.com"
+  gem.authors = ["Junegunn Choi"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+  test.rcov_opts << '--exclude "gems/*"'
+end
+
+task :default => :test
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/rcron.rb

@@ -0,0 +1,5 @@
+require 'rcron/task'
+require 'rcron/alarm'
+require 'rcron/parser'
+require 'rcron/timeout'
+require 'rcron/scheduler'

data/lib/rcron/alarm.rb

@@ -0,0 +1,6 @@
+class RCron
+  # Custom exception class for waking up scheduler
+  class Alarm < Exception
+  end#Alarm
+end#RCron
+

data/lib/rcron/parser.rb

@@ -0,0 +1,86 @@
+class RCron
+  module Parser
+    # @param [String] cron Cron-format schedule string
+    # @return [Hash] Parsed schedule
+    def self.parse(cron)
+      elements = cron.strip.split(/\s+/)
+      raise ArgumentError.new("Invalid format: '#{cron}'") unless [5, 6].include? elements.length
+
+      parser = lambda { |type, min, len, element, subs, extra|
+        return nil if element.nil?
+
+        max = min + len
+
+        (subs || {}).each do |k, v|
+          element = element.gsub(/\b#{k}\b/i, v.to_s)
+        end
+
+        ret = element.split(',').map { |e|
+          err = ArgumentError.new("Invalid #{type} specification: '#{cron}'")
+          case e
+          when '*'
+            nil
+          when %r|^[0-9]+$|
+            ei = e.to_i
+            raise err if ei < min || ei > max
+            ei
+          when %r|^\*/([1-9][0-9]*)$|
+            (min...max).select { |m| m % $1.to_i == 0 }
+          when %r|^([0-9]+)-([0-9]+)$|
+            f, t = $1.to_i, $2.to_i
+
+            raise err if f < min || f > max
+            raise err if t < min || t > max
+
+            if f < t
+              (f..t).to_a
+            else
+              (f...max).to_a + (min..t).to_a
+            end
+          else
+            extra && extra.call(e) || raise(err)
+          end
+        }.flatten.compact.uniq.inject({}) { |h, k| 
+          if k.is_a? Hash
+            h[k.first.first] = k.first.last
+          else
+            h[k] = true
+          end
+          h 
+        }
+        ret.empty? ? nil : ret
+      }
+
+      schedule = {
+        :minutes => parser.call('minute', 0, 60, elements[0], nil, nil),
+        :hours => parser.call('hour', 0, 24, elements[1], nil, nil),
+        :days => parser.call('day/month', 1, 31, elements[2], nil,
+                  lambda { |e|
+                    case e.upcase
+                    when 'L'
+                      -1
+                    when /W/
+                      raise NotImplementedError.new("Nearest weekday not implemeneted: '#{cron}'")
+                    end
+                  }),
+        :months => parser.call('month', 1, 12, elements[3], 
+                      { 'jan' => 1, 'feb' => 2, 'mar' => 3,
+                        'apr' => 4,  'may' => 5, 'jun' => 6,
+                        'jul' => 7, 'aug' => 8, 'sep' => 9,
+                        'oct' => 10, 'nov' => 11, 'dec' => 12 }, nil),
+        :weekdays => parser.call('day/week', 0,  7, elements[4], 
+                      { 'sun' => 0, 'mon' => 1, 'tue' => 2,
+                        'wed' => 3, 'thu' => 4, 'fri' => 5, 'sat' => 6 },
+                      lambda { |e|
+                        if e =~ /^([0-6]+)#([1-5])$/
+                          {$1.to_i => $2.to_i}
+                        end
+                      }),
+        :years => parser.call('year', 1970, 130, elements[5], nil, nil)
+      }
+      schedule
+    end
+  end#Parser
+end#RCron
+
+#puts RCron::Parser.parse('*/8 * */2,L * sun,wed#2')

data/lib/rcron/scheduler.rb

@@ -0,0 +1,102 @@
+require 'thread'
+
+class RCron
+  def initialize
+    @tasks = []
+    @mutex = Mutex.new
+    @sleeping = false
+    @log_mutex = Mutex.new
+    @log_ostream = $stdout
+  end
+
+  # Enqueues a task to be run
+  # @param [String] name Name of the task
+  # @param [String] schedule Cron-format schedule string
+  # @param [Hash] options Additional options for the task. :exclusive and :timeout.
+  # @return [RCron::Task]
+  def q name, schedule, options = {}, &block
+    raise ArgumentError.new("Block not given") unless block_given?
+
+    new_task = nil
+    @mutex.synchronize do
+      @tasks << new_task = Task.send(:new,
+                      self, name, schedule,
+                      options[:exclusive], options[:timeout],
+                      &block)
+    end
+    return new_task
+  end
+
+  # Starts the scheduler
+  # @param log_output_stream Stream to output scheduler log. Should implement puts method.
+  def start log_output_stream = $stdout
+    raise ArgumentError.new(
+        "Log output stream should implement puts method") unless
+            log_output_stream.respond_to? :puts
+
+    @log_ostream = log_output_stream
+    @thread = Thread.current
+
+    log "rcron started"
+
+    now = Time.now
+    while @tasks.length > 0
+      # At every minute
+      next_tick = Time.at( (now + 60 - now.sec).to_i )
+      interval = @tasks.select(&:running?).map(&:timeout).compact.min
+      begin
+        @mutex.synchronize { @sleeping = true }
+        #puts [ next_tick - now, interval ].compact.min
+        sleep [ next_tick - now, interval ].compact.min
+        @mutex.synchronize { @sleeping = false }
+      rescue RCron::Alarm => e
+        # puts 'woke up'
+      end
+
+      # Join completed threads
+      @tasks.select(&:running?).each do |t|
+        t.send :join
+      end
+
+      # Removed dequeued tasks
+      @tasks.reject { |e| e.running? || e.queued? }.each do |t|
+        @mutex.synchronize { @tasks.delete t }
+      end
+
+      # Start new task threads if it's time
+      now = Time.now
+      @tasks.select { |e| e.queued? && e.scheduled?(now) }.each do |t|
+        if t.running? && t.exclusive?
+          log "[#{t.name}] already running exclusively"
+          next
+        end
+
+        log "[#{t.name}] started"
+        t.send :start, now
+      end if now >= next_tick
+    end#while
+    log "rcron completed"
+  end#start
+
+  # Crontab-like tasklist
+  # @return [String]
+  def tab
+    @tasks.map { |t| "#{t.schedule_expression} #{t.name}" }.join($/)
+  end
+
+private
+  def wake_up
+    @mutex.synchronize {
+      if @sleeping
+        @sleeping = false
+        @thread.raise(RCron::Alarm.new)
+      end
+    }
+  end
+
+  def log msg
+    @log_mutex.synchronize do
+      @log_ostream.puts "[#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}] #{msg}"
+    end
+  end
+end#RCron

data/lib/rcron/task.rb

@@ -0,0 +1,172 @@
+require 'date'
+require 'time'
+
+class RCron
+  class Task
+    # RCron scheduler for this task
+    attr_reader :rcron
+
+    # Name of the task
+    attr_reader :name
+    
+    # Cron schedule expression
+    attr_reader :schedule_expression
+    
+    # Parsed cron schedule
+    attr_reader :schedule
+    
+    # Timeout for the task
+    attr_reader :timeout
+    
+    # Threads running this task
+    def threads
+      @mutex.synchronize { return @threads.dup }
+    end
+
+    # Executes the task manually
+    def run
+      if @block.arity >= 1
+        @block.call self
+      else
+        @block.call
+      end
+    end
+
+    # Returns if the task is being executed by one or more threads
+    # @return [Boolean]
+    def running?
+      @mutex.synchronize {
+        return @threads.empty? == false
+      }
+    end
+
+    # Returns whether if the same task should not run simultaneously
+    # @return [Boolean]
+    def exclusive?
+      @exclusive
+    end
+
+    # Returns if the task is queued to the scheduler
+    # @return [Boolean]
+    def queued?
+      @queued
+    end
+
+    # Removes the task from the scheduler
+    def dq
+      @queued = false
+      nil
+    end
+
+    # Returns if the task is supposed to be triggered at the given moment.
+    # @param [Time] at
+    # @return [Boolean]
+    def scheduled? at
+      if @previous_start.nil? || (at - at.sec).to_i > (@previous_start - @previous_start.sec).to_i
+        s, m, h, day, mon, year, wd = at.to_a
+
+        td = Date.new(year, mon, day) # at.to_date # Doesn't work with current JRuby
+        wom = ((td - td.day + 1).wday + td.day - 1) / 7 + 1
+        last_day = (td + 1).month > td.month
+
+        (@schedule[:years].nil?    || @schedule[:years].has_key?(year)) &&
+        (@schedule[:months].nil?   || @schedule[:months].has_key?(mon)) &&
+        (@schedule[:weekdays].nil? || [true, wom].include?(@schedule[:weekdays][wd])) &&
+        (@schedule[:days].nil?     || @schedule[:days].has_key?(day) || (last_day && @schedule[:days].has_key?(-1)) ) &&
+        (@schedule[:hours].nil?    || @schedule[:hours].has_key?(h)) &&
+        (@schedule[:minutes].nil?  || @schedule[:minutes].has_key?(m))
+      else
+        false
+      end
+    end
+
+  private
+    def start now
+      @previous_start = now
+      @mutex.synchronize do
+        @threads << TaskThread.new(self, now)
+      end
+    end
+
+    def join
+      @threads.dup.each do |thr|
+        if thr.alive?
+          # Timeout!
+          if @timeout && thr.elapsed > @timeout
+            thr.kill!
+            @mutex.synchronize { @threads.delete thr }
+          end
+        else
+          # Finished already
+          thr.cleanup
+          @mutex.synchronize { @threads.delete thr }
+        end
+      end
+    end
+
+  private
+    private_class_method :new
+
+    def initialize scheduler, name, schedule, exclusive, timeout, &block
+      if timeout && (timeout.is_a?(Numeric) == false || timeout < 1)
+        raise ArgumentError.new("Invalid timeout: #{timeout} (sec)") 
+      end
+      unless [true, false, nil].include? exclusive
+        raise ArgumentError.new("exclusive option must be true or false") 
+      end
+
+      @rcron     = scheduler
+      @name      = name
+      @schedule  = Parser.parse schedule
+      @schedule_expression    = schedule
+      @exclusive = exclusive == true
+      @timeout   = timeout
+      @block     = block
+      @queued    = true
+      @threads   = []
+      @mutex     = Mutex.new
+
+      @previous_start = nil
+    end
+
+    class TaskThread
+      attr_reader :started_at, :ended_at
+      attr_reader :exception
+
+      def initialize task, started_at
+        @started_at = started_at
+        @thread = Thread.new {
+          begin
+            task.run
+            @ended_at = Time.now
+
+            task.rcron.send :log, "[#{task.name}] completed (#{'%.2f' % elapsed}s)"
+          rescue Exception => e
+            @ended_at = Time.now
+
+            task.rcron.send :log, "[#{task.name}] terminated: #{[e, e.backtrace].join($/)}"
+            # Ignore exception?
+          end
+          task.rcron.send :wake_up
+        }
+      end
+
+      def cleanup
+        @thread.join
+      end
+
+      def elapsed
+        (@ended_at || Time.now) - @started_at
+      end
+
+      def alive?
+        @thread.alive?
+      end
+
+      def kill!
+        @thread.raise RCron::Timeout.new("Timeout: task terminated by rcron", @started_at, Time.now)
+        cleanup
+      end
+    end
+  end#Task
+end#RCron

data/lib/rcron/timeout.rb

@@ -0,0 +1,14 @@
+class RCron
+  # Timeout exception
+  class Timeout < Exception
+    attr_reader :started_at
+    attr_reader :terminated_at
+
+    def initialize(msg, started_at, terminated_at)
+      super(msg)
+      @started_at    = started_at
+      @terminated_at = terminated_at
+    end
+  end#Timeout
+end#RCron
+

data/test/helper.rb

@@ -0,0 +1,39 @@
+require 'rubygems'
+require 'bundler'
+require 'simplecov'
+SimpleCov.start
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rcron'
+
+class Test::Unit::TestCase
+end
+
+# Overrides timings constructs to boost up the test speed
+# - This might break some test results
+class Time
+  class << self
+    alias org_now now
+  end
+  def self.now
+    @@first_call ||= Time.org_now
+    return @@first_call + (Time.org_now - @@first_call) * 20
+  end
+end
+
+def sleep n
+  Kernel.sleep n * 0.05
+end
+
+Thread.abort_on_exception = false # FIXME: Without this, test fails.
+

data/test/test_rcron.rb

@@ -0,0 +1,176 @@
+$LOAD_PATH << "."
+require 'helper'
+
+class TestRcron < Test::Unit::TestCase
+  class LogStream
+    def initialize
+      @lines = []
+    end
+
+    def puts str
+      $stdout.puts str
+      @lines << str
+    end
+
+    def count pat
+      @lines.select { |e| e =~ pat }.count
+    end
+  end
+
+  def test_empty_q
+    rcron = RCron.new
+    log = LogStream.new
+    rcron.start(log)
+
+    assert_equal 1, log.count(/completed/)
+  end
+
+  def test_blockless
+    rcron = RCron.new
+    assert_raise(ArgumentError) { rcron.q('test task 1', "* * * * *") }
+  end
+
+  def test_invalid_schedule
+    rcron = RCron.new
+    assert_raise(ArgumentError) { rcron.q('test task 1', "* *") { |task| } }
+  end
+
+  def test_basic_task_dq
+    puts 'basic task eq'
+    counter = 0
+    rcron = RCron.new
+    rcron.q('basic task 1 - auto dq', "* * * * *") do |task|
+      counter += 1
+      sleep 1
+      task.dq
+    end
+
+    @task = rcron.q('basic task 2 - auto dq', "* * * * *") do
+      counter += 2
+      sleep 3
+      @task.dq
+    end
+
+    st = Time.now
+    rcron.start
+    assert_equal 3, counter
+    assert Time.now - st > 3
+  end
+
+  def test_basic_task
+    puts 'basic task'
+    counter = 0
+    rcron = RCron.new
+    rcron.q('basic task', "* * * * *") do |task|
+      task.dq if counter >= 2
+
+      counter += 1
+      sleep 60 + 10
+    end
+
+    st = Time.now
+    rcron.start
+    assert_equal 3, counter
+    assert Time.now - st > 3 * 60
+  end
+
+  def test_dq
+    counter = 0
+    rcron = RCron.new
+    task = rcron.q('never', "* * * * *") do |task|
+      counter += 1
+    end
+
+    task.dq
+    rcron.start
+    assert_equal 0, counter
+  end
+
+  def test_timeout
+    puts 'timeout'
+    counter = 0
+    rcron = RCron.new
+    rcron.q('timeout', '*/5 * * * *', :timeout => 10) do |task|
+      task.dq # no more
+      loop do
+        counter += 1
+        sleep 1
+      end
+    end
+
+    assert_raise(ArgumentError) { rcron.q('inv timeout', '* * * * *', :timeout => -3) { } }
+    assert_raise(ArgumentError) { rcron.q('inv timeout', '* * * * *', :timeout => 'not too long') { } }
+
+    rcron.start
+    assert_equal 10, counter
+  end
+
+  def test_non_exclusive
+    puts 'non exclusive'
+    counter = 0
+    log = LogStream.new
+    rcron = RCron.new
+    truth = true
+    rcron.q('non-exclusive', '* * * * *') do |task|
+      counter += 1
+      truth &&= counter == task.threads.length
+      puts task.threads.length
+      sleep 60 * 2 + 30
+      task.dq
+    end
+    rcron.start(log)
+
+    assert truth
+    assert_equal 3, counter
+  end
+
+  def test_exclusive
+    puts 'exclusive'
+    counter = 0
+    log = LogStream.new
+    rcron = RCron.new
+    rcron.q('exclusive', '* * * * *', :exclusive => true) do |task|
+      counter += 1
+      sleep 60 * 2 + 10
+      task.dq
+    end
+
+    assert_raise(ArgumentError) {
+      rcron.q('inv exclusive', '* * * * *', :exclusive => 'i guess') { }
+    }
+    rcron.start(log)
+
+    assert_equal 1, counter
+    assert log.count(/exclusively/i) > 0
+  end
+
+  def test_invalid_output_stream
+    rcron = RCron.new
+    assert_raise(ArgumentError) { rcron.start("invalid") }
+  end
+
+  def test_tab
+    rcron = RCron.new
+    rcron.q('task number 1', '* * * * *') {}
+    rcron.q('task number 2', '*/2 * * * *') {}
+    rcron.q('task number 3', '*/3 * * * *') {}
+
+    assert_equal ["* * * * * task number 1", 
+                  "*/2 * * * * task number 2", 
+                  "*/3 * * * * task number 3"].join($/), rcron.tab
+  end
+
+  def test_exception
+    log = LogStream.new
+    rcron = RCron.new
+    rcron.q('Exceptional', '* * * * *') do |task|
+      task.dq
+      sleep 80
+      raise Exception.new("this-error")
+    end
+    rcron.start(log)
+
+    assert_equal 1, log.count(/this-error/)
+  end
+end
+

data/test/test_rcron_parser.rb

@@ -0,0 +1,88 @@
+$LOAD_PATH << "."
+require 'helper'
+
+class TestRcronParser < Test::Unit::TestCase
+  def test_invalid_format
+    assert_raise(ArgumentError) { RCron::Parser.parse('* * * *') }
+    assert_raise(ArgumentError) { RCron::Parser.parse('* * * * * * *') }
+    assert_raise(ArgumentError) { RCron::Parser.parse('a b c d e') }
+  end
+
+  def test_asterisk
+    RCron::Parser.parse('* * * * *').each do |k, v|
+      assert_nil v
+    end
+
+    RCron::Parser.parse('* * * * * *').each do |k, v|
+      assert_nil v
+    end
+  end
+
+  def test_single_number
+    RCron::Parser.parse('1 1 1 1 1 2000').each do |k, v|
+      assert_equal(
+        case k
+        when :minutes
+          {1 => true}
+        when :hours
+          {1 => true}
+        when :days
+          {1 => true}
+        when :months
+          {1 => true}
+        when :weekdays
+          {1 => true}
+        when :years
+          {2000 => true}
+        end, v)
+    end
+
+    # Invalid range
+    assert_raise(ArgumentError) { RCron::Parser.parse('61 * * * *') }
+    assert_raise(ArgumentError) { RCron::Parser.parse('* 25 * * *') }
+    assert_raise(ArgumentError) { RCron::Parser.parse('* * 50 * *') }
+    assert_raise(ArgumentError) { RCron::Parser.parse('* * * 14 *') }
+    assert_raise(ArgumentError) { RCron::Parser.parse('* * * * 10000') }
+  end
+
+  def test_range
+    assert_equal({10 => true, 11 => true, 12 => true, 59 => true, 0 => true, 1 => true, 2 => true}, 
+        RCron::Parser.parse('10-12,59-2 * * * *')[:minutes])
+  end
+
+  def test_dividend
+    assert_equal({3 => true, 6 => true, 9 => true, 12 =>true}, 
+                 RCron::Parser.parse('* * * */3 *')[:months])
+    assert_equal({0 => true, 23 => true, 24 => true, 46 => true, 48 => true}, 
+                 RCron::Parser.parse('*/23,*/24 * * * *')[:minutes])
+  end
+
+  def test_months
+    assert_equal({1 => true, 2 => true, 3 => true, 6 => true, 7 => true, 8 => true}, 
+                 RCron::Parser.parse('* * * jan-MAR,Jun-Aug *')[:months])
+    assert_equal((1..12).to_a.sort,
+                 RCron::Parser.parse('* * * jan,feb,mar,apr,may,jun,jul,aug,sep,oct,nov,dec *')[:months].keys.sort)
+  end
+
+  def test_weekdays
+    assert_equal([0,1,2,3,4,5,6],
+                 RCron::Parser.parse('* * * * sun,mon,tue,wed,thu,fri,sat,sun')[:weekdays].keys.sort)
+    assert_equal([0,1,2,3,4,5,6],
+                 RCron::Parser.parse('* * * * SUN,MON,TUE,WED,THU,FRI,SAT,SUN')[:weekdays].keys.sort)
+    assert_equal([0,1,2,3,4,6],
+                 RCron::Parser.parse('* * * * WED-THU,SAT-TUE')[:weekdays].keys.sort)
+  end
+
+  def test_nearest_weekday
+    # TODO FIXME TODO
+    assert_raise(NotImplementedError) { RCron::Parser.parse('* * W * *') }
+  end
+
+  def test_last_day
+    assert_equal([-1, 31], RCron::Parser.parse('* * L,31 * *')[:days].keys.sort)
+  end
+
+  def test_year
+    assert_equal([2010,2011,2012,2020], RCron::Parser.parse('* * L,31 * * 2010-2012,2020')[:years].keys.sort)
+  end
+end

data/test/test_rcron_task.rb

@@ -0,0 +1,175 @@
+$LOAD_PATH << "."
+require 'helper'
+
+class TestRcronTask < Test::Unit::TestCase
+  def test_name
+    rcron = RCron.new
+    name = nil
+
+    task = rcron.q('my name', '* * * * *') { |t|
+      name = t.name
+      t.dq
+    }
+    assert_equal 'my name', task.name
+    rcron.start
+    assert_equal 'my name', name
+  end
+
+  def test_schedule
+    rcron = RCron.new
+    schedule = '* * * * *'
+    task = rcron.q('test_schedule', schedule) { }
+    assert_equal RCron::Parser.parse(schedule), task.schedule
+  end
+  
+  def test_rcron
+    rcron = RCron.new
+    schedule = '* * * * *'
+    task = rcron.q('test_rcron', schedule) { }
+    assert_equal rcron, task.rcron
+  end
+
+  def test_timeout
+    rcron = RCron.new
+    task = rcron.q('test_timeout', '* * * * *', :timeout => 100) { }
+    assert_equal 100, task.timeout
+  end
+
+  def test_exclusive
+    rcron = RCron.new
+    task = rcron.q('test_exclusive', '* * * * *', :exclusive => true) { }
+    assert_equal true, task.exclusive?
+    task = rcron.q('test_exclusive', '* * * * *', :exclusive => false) { }
+    assert_equal false, task.exclusive?
+    task = rcron.q('test_exclusive', '* * * * *') { }
+    assert_equal false, task.exclusive?
+  end
+
+  def test_running
+    rcron = RCron.new
+    running = nil
+    task = rcron.q('test_running', '* * * * *') { |t|
+      running = t.running?
+      t.dq
+    }
+    rcron.start
+    assert_equal false, task.running?
+    assert_equal true, running
+  end
+
+  def test_queued
+    rcron = RCron.new
+    task = rcron.q('test_queued', '* * * * *') { }
+    assert_equal true, task.queued?
+    task.dq
+    assert_equal false, task.queued?
+  end
+
+  def test_threads
+    rcron = RCron.new
+    num_threads = nil
+    task = rcron.q('test_threads', '* * * * *') { |t|
+      p t.threads
+      num_threads = t.threads.length
+      sleep 60 + 10
+      t.dq
+    }
+    assert_equal 0, task.threads.length
+    rcron.start
+    assert_equal 2, num_threads
+    assert_equal 0, task.threads.length
+  end
+
+  def test_now
+    now = Time.parse('2011-08-27 16:16:16')
+    rcron = RCron.new
+    {
+      '* * * * *' => true,
+      '0 * * * *' => false,
+      '16 * * * *' => true,
+      '*/2 * * * *' => true,
+      '10-17 * * * *' => true,
+      '*/3 * * * *' => false,
+      '17-15 * * * *' => false,
+
+      '* 16 * * *' => true,
+      '* */2 * * *' => true,
+      '* */4 * * *' => true,
+      '* 10-17 * * *' => true,
+      '* */3 * * *' => false,
+      '* 17-15 * * *' => false,
+
+      '* * 27 * *' => true,
+      '* * */3 * *' => true,
+      '* * */9 * *' => true,
+      '* * 20-29 * *' => true,
+      '* * 20-22,27,*/4 * *' => true,
+      '* * L * *' => false,
+      '* * 28 * *' => false,
+
+      '* * * 8 *' => true,
+      '* * * */1 *' => true,
+      '* * * */2 *' => true,
+      '* * * */4 *' => true,
+      '* * * */8 *' => true,
+      '* * * Aug *' => true,
+      '* * * AuG *' => true,
+      '* * * 5,7,8 *' => true,
+      '* * * 5-9 *' => true,
+      '* * * 12-9 *' => true,
+      '* * * may-sep *' => true,
+      '* * * nov-sep *' => true,
+      '* * * jan,dec,aug *' => true,
+      '* * * sep *' => false,
+      '* * * 9-10 *' => false,
+      '* * * */7 *' => false,
+
+      '* * * * sat' => true,
+      '* * * * fri-sun' => true,
+      '* * * * mon,tue,sat' => true,
+      '* * * * 6' => true,
+      '* * * * 5-6' => true,
+      '* * * * 5-0' => true,
+      '* * * * 1,6' => true,
+      '* * * * */1' => true,
+      '* * * * */2' => true,
+      '* * * * */3' => true,
+      '* * * * */6' => true,
+      '* * * * tue' => false,
+      '* * * * fri' => false,
+      '* * * * sun-fri' => false,
+      '* * * * 0-5' => false,
+
+      '* * * * sat#1' => false,
+      '* * * * sat#2' => false,
+      '* * * * sat#3' => false,
+      '* * * * sat#4' => true,
+      '* * * * sat#5' => false,
+      '* * * * 6#1' => false,
+      '* * * * 6#2' => false,
+      '* * * * 6#3' => false,
+      '* * * * 6#4' => true,
+      '* * * * 6#5' => false,
+
+      '* * * * * 2011' => true,
+      '* * * * * */2011' => true,
+      '* * * * * 2010-2012' => true,
+      '* * * * * 2010' => false,
+
+      '16 16 27 8 6 2010' => false,
+      '16 16 27 8 6 2011' => true,
+      '16 16 27 8 sat 2011' => true,
+      '16 16 27 aug sat 2010-2012' => true,
+      '16 16 27 aug sun 2010-2012' => false,
+      '*/8 16 27 aug 5-6 2010-2012' => true,
+      '17 16 27 aug sat 2010-2012' => false,
+      '16 17 27 aug * 2010-2012' => false,
+      '16 16 L aug * 2010-2012' => false
+    }.each do |sch, ass|
+      task = rcron.q('test_now', sch) { }
+      puts sch
+      assert_equal ass, task.scheduled?(now)
+    end
+  end
+end
+

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: rcron
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Junegunn Choi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-31 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &2156282420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *2156282420
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &2156281700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *2156281700
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &2156281080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *2156281080
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &2156280220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156280220
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &2156279280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156279280
+description: A simple cron-like scheduler for Ruby
+email: junegunn.c@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- CHANGELOG.rdoc
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/rcron.rb
+- lib/rcron/alarm.rb
+- lib/rcron/parser.rb
+- lib/rcron/scheduler.rb
+- lib/rcron/task.rb
+- lib/rcron/timeout.rb
+- test/helper.rb
+- test/test_rcron.rb
+- test/test_rcron_parser.rb
+- test/test_rcron_task.rb
+homepage: http://github.com/junegunn/rcron
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1983967147733122663
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: A simple cron-like scheduler
+test_files: []