moment 0.1.0

data/README

@@ -0,0 +1,5 @@
+This is a scheduling system in pure ruby.  It runs jobs at specified intervals.
+It has a server component that you can interface with via DRb, which makes
+admining it from a Rails environment easy.
+
+See Moment for more documentation.

data/bin/moment_server

@@ -0,0 +1,81 @@
+#!/usr/bin/ruby
+
+#
+# == Synopsis
+#
+# moment_server: scheduling server, accessible via DRb
+#
+#  $ moment_server -p 9901 saved_jobs
+#  Loading previous jobs from saved_jobs..
+#  Loaded 0 jobs:
+#  []
+#  Starting service on druby://localhost:9901 ...
+#  Ready.<Ctrl-C>
+#  Saving 0 jobs to saved_jobs..
+#  Exiting..
+#
+# == Usage
+#
+# moment_server [@options] [job_file]
+#
+# -h, --help:
+#     show help
+#
+# -p, --port: (default 9000)
+#     port to run druby instance on
+#
+# -q, --[no-]quiet: (default false)
+#     run verbosely
+#
+# job_file
+#     if specified, will save still running jobs in the given file on
+#     exit to be read in again on next start.
+#
+
+require 'rubygems'
+require 'moment'
+require 'drb'
+require 'ostruct'
+require 'optparse'
+require 'rdoc/usage'
+
+@options = OpenStruct.new :port => 9000, :quiet => false, :file => nil
+OptionParser.new do |o|
+  o.on '-p', '--port [port]', Integer do |port| @options.port = port end
+  o.on '-q', '--[no-]quiet' do |quiet| @options.quiet = quiet end
+  o.on '-h', '--help' do
+    RDoc::usage
+    exit
+  end
+end.order! do |file|
+  @options.file ||= file
+end
+
+def putsv(*args)
+  puts args  unless @options.quiet
+end
+
+url = "druby://localhost:#{@options.port}"
+server = Moment::Server.new
+
+unless @options.file.nil? or !File.exists?(@options.file)
+  putsv "Loading previous jobs from #{@options.file}.."
+  server.load(File.open(@options.file))
+  putsv "Loaded #{server.jobs.size} jobs:", server.jobs.inspect
+end
+
+server.run
+
+putsv "Starting service on #{url} ..."
+DRb.start_service(url, server)
+begin
+  putsv "Ready."
+  DRb.thread.join
+rescue Interrupt => e
+  if @options.file
+    putsv "Saving #{server.jobs.size} jobs to #{@options.file}.."
+    server.dump(File.open(@options.file, 'w'))
+  end
+
+  putsv "Exiting.."
+end

data/lib/client.rb

@@ -0,0 +1,24 @@
+require 'drb'
+require 'shell_job'
+require 'simple_trigger'
+
+class Printer
+
+  include DRbUndumped
+  attr_accessor :name, :counter
+
+  def initialize(name = nil)
+    self.name = name
+    self.counter = 0
+  end
+
+  def execute
+    puts self.inspect, Time.now
+    @counter += 1
+  end
+
+end
+
+DRb.start_service
+scheduler = DRbObject.new(nil, 'druby://localhost:9000')
+scheduler.schedule(Moment::ShellJob.new('ls'), Moment::SimpleTrigger.new(Time.now, Time.now + 10, 2))

data/lib/cron_trigger.rb

@@ -0,0 +1,161 @@
+require File.dirname(__FILE__) + '/moment'
+require File.dirname(__FILE__) + '/trigger'
+
+class Moment::CronTrigger < Moment::Trigger
+
+  attr_reader :sec, :min, :hour, :day, :month, :wday, :year, :cron_expr
+
+  def initialize(expr)
+    super()
+    self.cron_expr = expr
+  end
+
+  def cron_expr=(expr)
+    @cron_expr = expr
+    self.sec, self.min, self.hour, self.day, self.month, self.wday, self.year = @cron_expr.split(' ')
+    #puts inspect
+  end
+
+  def fire_time_after(time)
+    sec, min, hour, day, month, year, wday, yday, isdst, zone = time.to_a
+
+    loop do
+      # year
+      unless @year.nil? or @year.include?(year)
+        return nil  if year > @year.max
+        year = @year.detect do |y| y > year end  # next allowable year
+      end
+
+      # month
+      unless @month.include?(month)
+        # next allowable month
+        next_month = @month.detect(lambda { @month.min }) do |m| m > month end
+        # reset everything lower
+        day, hour, min, sec = @day.min, @hour.min, @min.min, @sec.min
+        # carry case
+        if next_month < month
+          month = next_month
+          year += 1
+          retry
+        end
+        month = next_month
+      end
+
+      # day
+      month_days = (1 .. month_days(year, month))
+      days = @day.select do |d| month_days === d end
+      unless days.include?(day)
+        next_day = days.detect(lambda { days.min }) do |d| d > day end
+        hour, min, sec = @hour.min, @min.min, @sec.min
+        if next_day.nil? or next_day < day
+          day = next_day.nil? ? @day.min : next_day
+          month += 1
+          retry
+        end
+        day = next_day
+      end
+
+      # hour
+      unless @hour.include?(hour)
+        next_hour = @hour.detect(lambda { @hour.min }) do |h| h > hour end
+        min, sec = @min.min, @sec.min
+        if next_hour < hour
+          hour = next_hour
+          day += 1
+          retry
+        end
+        hour = next_hour
+      end
+
+      # min
+      unless @min.include?(min)
+        next_min = @min.detect(lambda { @min.min }) do |m| m > min end
+        sec = @sec.min
+        if next_min < min
+          min = next_min
+          hour += 1
+          retry
+        end
+        min = next_min
+      end
+
+      # sec
+      unless @sec.include?(sec)
+        next_sec = @sec.detect(lambda { @sec.min }) do |s| s > sec end
+        if next_sec < sec
+          sec = next_sec
+          min += 1
+          retry
+        end
+        sec = next_sec
+      end
+
+      break
+    end
+
+    Time.local sec, min, hour, day, month, year, wday, yday, isdst, zone
+  end
+
+  # TODO: mimic attr_reader to define all of these
+  def sec=(sec)
+    @sec = parse_part(sec, 0 .. 59)
+  end
+
+  def min=(min)
+    @min = parse_part(min, 0 .. 59)
+  end
+
+  def hour=(hour)
+    @hour = parse_part(hour, 0 .. 23)
+  end
+
+  def day=(day)
+    @day = parse_part(day, 1 .. 31)
+  end
+
+  def month=(month)
+    @month = parse_part(month, 1 .. 12)
+  end
+
+  def year=(year)
+    @year = parse_part(year)
+  end
+
+  def wday=(wday)
+    @wday = parse_part(wday, 0 .. 6)
+  end
+
+  LeapYearMonthDays = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+  CommonYearMonthDays = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+  private
+  def month_days(y, m)
+    if ((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0)
+      LeapYearMonthDays[m-1]
+    else
+      CommonYearMonthDays[m-1]
+    end
+  end
+
+  # 0-5,8,10; 0-5; *; */5
+  def parse_part(part, range=nil)
+    return range  if part.nil? or part == '*' or part =~ /[*0]\/1/
+
+    r = Array.new
+    part.split(',').each do |p|
+      if p =~ /-/  # 0-5
+        r << Range.new(*p.scan(/\d+/)).to_a.map do |x| x.to_i end
+      elsif p =~ /(\*|\d+)\/(\d+)/ and not range.nil?  # */5, 2/10
+        min = $1 == '*' ? 0 : $1.to_i
+        inc = $2.to_i
+        (min .. range.end).each_with_index do |x, i|
+          r << x  if i % inc == 0
+        end
+      else
+        r << p.to_i
+      end
+    end
+
+    r.flatten
+  end
+
+end

data/lib/job.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/moment'
+
+class Moment::Job
+
+  def execute
+    puts "Implement me"
+  end
+
+end

data/lib/moment.rb

@@ -0,0 +1,70 @@
+#
+# == Moment. a scheduler.
+#
+# Author:: visnup <visnux@swivel.com>
+# Started:: 8 March 2006
+# Copyright:: Copyright (c) 2006  Swivel, LLC
+# License:: Ruby License
+#
+# i just ate some doritos and need to drink more water.
+#
+# === Introduction
+#
+# Moment is a scheduling service that handles running given jobs at specified
+# intervals.
+#
+# === Features
+#
+# Built-in triggers include a cron implementation (CronTrigger) and simple
+# reptition (SimpleTrigger).  Users-written triggers are of course supported by
+# extending Trigger.  A Server is also provided that handles multithreading.
+# There is also a seperate executable +moment_server+ that can be run and
+# scheduled to via DRb.  Built-in job types include a shell execution job
+# (ShellJob), or you can extend Job.
+#
+# === Example
+#
+#  require 'rubygems'
+#  require 'moment'
+#  require 'drb'
+#
+#  class Printer
+#
+#    include DRbUndumped
+#    attr_accessor :name, :counter
+#
+#    def initialize(name = nil)
+#      self.name = name
+#      self.counter = 0
+#    end
+#
+#    def execute
+#      puts self.inspect, Time.now
+#      @counter += 1
+#    end
+#
+#  end
+#
+#  DRb.start_service
+#  scheduler = DRbObject.new(nil, 'druby://localhost:9901')
+#  scheduler.schedule(Moment::ShellJob.new('ls'),
+#    Moment::SimpleTrigger.new(Time.now, Time.now + 10, 2))  # from now till 10 seconds from now, every 2 seconds
+#  scheduler.schedule(Moment::ShellJob.new('date'),
+#    Moment::CronTrigger.new('0 0/5 * * 3,5')  # every 5 minutes during March and May
+#
+# === Server
+#
+# The above example assumes the included server +moment_server+ is running on
+# port 9901.  See the documentation on running +moment_server+.
+#
+
+module Moment
+end
+
+require File.dirname(__FILE__) + '/cron_trigger.rb'
+require File.dirname(__FILE__) + '/job.rb'
+require File.dirname(__FILE__) + '/scheduler.rb'
+require File.dirname(__FILE__) + '/server.rb'
+require File.dirname(__FILE__) + '/shell_job.rb'
+require File.dirname(__FILE__) + '/simple_trigger.rb'
+require File.dirname(__FILE__) + '/trigger.rb'

data/lib/scheduler.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + '/moment'
+
+class Moment::Scheduler
+
+  Event = Struct.new(:job, :trigger)
+
+  attr_accessor :exit_on_idle
+  attr_reader :jobs
+
+  def initialize(exit_on_idle = true)
+    self.exit_on_idle = exit_on_idle
+    @jobs = Array.new
+    @now = Time.now
+  end
+
+  def schedule(job, trigger = nil)
+    job_id = @jobs.size
+    @jobs[job_id] = Event.new(job, trigger)
+
+    job_id
+  end
+
+  def unschedule(job_id)
+    @jobs.delete_at(job_id)
+  end
+
+  def clean_up
+    @jobs.delete_if do |entry| entry.trigger.fire_time_after(@now).nil? end
+  end
+
+  def run
+    loop do
+      # find the next firing triggers
+      todo = next_jobs
+      if todo.empty?  # nothing to do, so we wait
+        break  if @exit_on_idle
+        sleep
+        retry  # check again if we're woken up
+      end
+
+      # sleep until the next event; if we get woken up, retry from the start
+      pause_time = todo.first.trigger.fire_time_after(@now) - Time.now
+      retry  if (pause_time > 0 and sleep(pause_time) < pause_time)
+
+      todo.each do |entry|
+        next  unless @jobs.index(entry)  # make sure since we were sleeping
+        entry.job.execute rescue puts $!
+      end
+
+      # make sure next call to next_jobs won't return the exact same result
+      sleep 0.5  # TODO this is dangerous; could skip over some jobs
+    end
+  end
+
+  # find the next wakeup triggers in our job/trigger list
+  def next_jobs
+    @now = Time.now
+    earliest = nil
+    jobs = Array.new
+
+    @jobs.each do |entry|
+      job, trigger = entry.job, entry.trigger
+      time = trigger.fire_time_after(@now)
+      case
+      when time.nil?
+        # do nothing
+      when earliest.nil?, time < earliest
+        earliest = time
+        jobs = [ entry ]
+      when time == earliest
+        jobs << entry
+      end
+    end
+
+    jobs
+  end
+
+end  # class Moment::Scheduler

data/lib/server.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/moment'
+require File.dirname(__FILE__) + '/scheduler'
+require File.dirname(__FILE__) + '/trigger'
+require File.dirname(__FILE__) + '/job'
+require File.dirname(__FILE__) + '/shell_job'
+require File.dirname(__FILE__) + '/simple_trigger'
+require File.dirname(__FILE__) + '/cron_trigger'
+
+class Moment::Server < Moment::Scheduler
+
+  def initialize
+    super(false)  # don't exit on idle
+    @threads = Array.new
+  end
+
+  def run
+    @threads << Thread.new do
+      super
+    end
+  end
+
+  def schedule(job, trigger)
+    puts 'scheduling:', job.inspect, trigger.inspect
+    retval = super
+    @threads.each do |t| t.wakeup end
+    retval
+  end
+
+  def dump(file)
+    file << Marshal.dump(@jobs)
+  end
+
+  def load(file)
+    @jobs = Marshal.load(file.read)
+  rescue ArgumentError
+    # ignore if the file is empty
+  end
+
+end

data/lib/shell_job.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/job'
+
+class Moment::ShellJob < Moment::Job
+
+  attr_accessor :command
+  attr_reader :last_result
+
+  def initialize(command)
+    self.command = command
+    @last_result = nil
+  end
+
+  def execute
+    @last_result = `#{command}`
+  end
+
+end

data/lib/simple_trigger.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/moment'
+require File.dirname(__FILE__) + '/trigger'
+
+class Moment::SimpleTrigger < Moment::Trigger
+
+  attr_accessor :start_time, :end_time, :repeat_interval
+
+  def initialize(start_time = nil, end_time = nil, repeat_interval = nil)
+    super()
+    self.start_time = start_time
+    self.end_time = end_time
+    self.repeat_interval = repeat_interval
+  end
+
+  def fire_time_after(time)
+    @start_time = time  if not @start_time
+
+    case
+    when end_time && time > end_time
+      nil
+    when time < start_time
+      start_time
+    when repeat_interval != nil && repeat_interval > 0
+      time + repeat_interval - ((time - start_time) % repeat_interval)
+    else
+      nil
+    end
+  end
+
+end

data/lib/trigger.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/moment'
+
+class Moment::Trigger
+
+  def fire_time_after(time)
+    nil
+  end
+
+end

data/test/cron_trigger_test.rb

@@ -0,0 +1,105 @@
+
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/cron_trigger'
+
+class CronTriggerTest < Test::Unit::TestCase
+
+  def test_create
+    expr = '0 0 0 * *'
+    cron = Moment::CronTrigger.new(expr)
+    assert_equal(expr, cron.cron_expr)
+  end
+
+  def test_explicit_no_carry
+    input    = Time.local(0, 0, 0, 1, 1, 2004, nil, nil, false, 'UTC')
+    cron = Moment::CronTrigger.new('10 5 4 3 2')
+    expected = Time.local(10, 5, 4, 3, 2, 2004, nil, nil, false, 'UTC')
+    assert_equal(expected, cron.fire_time_after(input))
+  end
+
+  def test_explicit_no_carry_day
+    input    = Time.local(0, 0, 0, 1, 1, 2004, nil, nil, false, 'UTC')
+    cron = Moment::CronTrigger.new('10 5 4 3 1')
+    expected = Time.local(10, 5, 4, 3, 1, 2004, nil, nil, false, 'UTC')
+    assert_equal(expected, cron.fire_time_after(input))
+  end
+
+  def test_explicit_no_carry_hour
+    input    = Time.local(0, 0, 0, 1, 1, 2004, nil, nil, false, 'UTC')
+    cron = Moment::CronTrigger.new('10 5 4 1 1')
+    expected = Time.local(10, 5, 4, 1, 1, 2004, nil, nil, false, 'UTC')
+    assert_equal(expected, cron.fire_time_after(input))
+  end
+
+  def test_explicit_no_carry_min
+    input    = Time.local(0, 0, 0, 1, 1, 2004, nil, nil, false, 'UTC')
+    cron = Moment::CronTrigger.new('10 5 0 1 1')
+    expected = Time.local(10, 5, 0, 1, 1, 2004, nil, nil, false, 'UTC')
+    assert_equal(expected, cron.fire_time_after(input))
+  end
+
+  def test_explicit_with_carry
+    input    = Time.local(0, 1, 23, 1, 1, 2004, nil, nil, false, 'UTC')
+    cron = Moment::CronTrigger.new('0 0 23 1 1')
+    expected = Time.local(0, 0, 23, 1, 1, 2005, nil, nil, false, 'UTC')
+    assert_equal(expected, cron.fire_time_after(input))
+  end
+
+  def test_implicit_with_carry
+    input    = Time.local(0, 1, 23, 1, 1, 2004, nil, nil, false, 'UTC')
+    cron = Moment::CronTrigger.new('0 0 * * *')
+    expected = Time.local(0, 0, 0, 2, 1, 2004, nil, nil, false, 'UTC')
+    assert_equal(expected, cron.fire_time_after(input))
+  end
+
+  def test_year_before
+    input    = Time.local(0, 1, 23, 1, 1, 2004, nil, nil, false, 'UTC')
+    cron = Moment::CronTrigger.new('0 15 10 * * * 2003')
+    expected = nil
+    assert_equal(expected, cron.fire_time_after(input))
+  end
+
+  def test_year_after
+    input    = Time.local(0, 1, 23, 1, 1, 2004, nil, nil, false, 'UTC')
+    cron = Moment::CronTrigger.new('0 15 10 * * * 2005')
+    expected = Time.local(0, 15, 10, 2, 1, 2005, nil, nil, false, 'UTC')
+    assert_equal(expected, cron.fire_time_after(input))
+  end
+
+  def test_month_over
+    input    = Time.local(0, 1, 23, 2, 12, 2004, nil, nil, false, 'UTC')
+    cron = Moment::CronTrigger.new('0 15 10 1 * * *')
+    expected = Time.local(0, 15, 10, 1, 1, 2005, nil, nil, false, 'UTC')
+    assert_equal(expected, cron.fire_time_after(input))
+  end
+
+  def test_day_over
+    input    = Time.local(0, 1, 23, 30, 11, 2004, nil, nil, false, 'UTC')
+    cron = Moment::CronTrigger.new('* * * 31 * * *')
+    expected = Time.local(0, 0, 0, 31, 12, 2004, nil, nil, false, 'UTC')
+    assert_equal(expected, cron.fire_time_after(input))
+  end
+
+  def test_min_over
+    input    = Time.local(2, 59, 12, 30, 11, 2004, nil, nil, false, 'UTC')
+    cron = Moment::CronTrigger.new('1 * * * * * *')
+    expected = Time.local(1, 0, 13, 30, 11, 2004, nil, nil, false, 'UTC')
+    assert_equal(expected, cron.fire_time_after(input))
+  end
+
+  def test_range
+    input0    = Time.local(2, 59, 12, 30, 11, 2004, nil, nil, false, 'UTC')
+    cron = Moment::CronTrigger.new('28/5,59 1-4,6,20 */1 * 5,0/1 * *')
+    assert_equal([28,33,38,43,48,53,58,59], cron.sec)
+    assert_equal([1,2,3,4,6,20], cron.min)
+    assert_equal((0 .. 23), cron.hour)
+    assert_equal((1 .. 12), cron.month)
+
+    expected0 = Time.local(28, 1, 13, 30, 11, 2004, nil, nil, false, 'UTC')
+    input1    = Time.local(29, 1, 13, 30, 11, 2004, nil, nil, false, 'UTC')
+    expected1 = Time.local(33, 1, 13, 30, 11, 2004, nil, nil, false, 'UTC')
+    assert_equal(expected0, cron.fire_time_after(input0))
+    assert_equal(expected1, cron.fire_time_after(input1))
+  end
+
+end

data/test/job_test.rb

@@ -0,0 +1,13 @@
+
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/job'
+
+class JobTest < Test::Unit::TestCase
+
+  def test_execute
+    job = Moment::Job.new
+    assert_respond_to(job, :execute)
+    job.execute
+  end
+
+end

data/test/moment_test.rb

@@ -0,0 +1,9 @@
+require 'test/unit'
+
+require File.dirname(__FILE__) + '/cron_trigger_test'
+require File.dirname(__FILE__) + '/job_test'
+require File.dirname(__FILE__) + '/scheduler_test'
+require File.dirname(__FILE__) + '/server_test'
+require File.dirname(__FILE__) + '/shell_job_test'
+require File.dirname(__FILE__) + '/simple_trigger_test'
+require File.dirname(__FILE__) + '/trigger_test'

data/test/scheduler_test.rb

@@ -0,0 +1,64 @@
+
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/scheduler'
+require File.dirname(__FILE__) + '/../lib/simple_trigger'
+require File.dirname(__FILE__) + '/../lib/job'
+
+class SchedulerTest < Test::Unit::TestCase
+
+  def test_initialize
+    scheduler = Moment::Scheduler.new
+    assert_equal([], scheduler.jobs)
+  end
+
+  class CountExecuted < Moment::Job
+    attr_reader :executed
+    def initialize
+      @executed = 0
+    end
+    def execute
+      @executed += 1
+    end
+  end
+
+  def test_schedule
+    scheduler = Moment::Scheduler.new
+    simple = Moment::SimpleTrigger.new(Time.now+1, Time.now+2, nil)
+    job = CountExecuted.new
+
+    scheduler.schedule(job, simple)
+    scheduler.schedule(job, simple)
+    scheduler.run
+
+    assert_not_equal(0, job.executed)
+  end
+
+  def test_unschedule
+    scheduler = Moment::Scheduler.new
+    simple = Moment::SimpleTrigger.new(nil, nil, 1)
+    job = CountExecuted.new
+
+    job_id = scheduler.schedule(job, simple)
+
+    assert_equal(1, scheduler.jobs.size)
+    assert_equal(Moment::Scheduler::Event.new(job, simple),
+      scheduler.unschedule(job_id))
+    assert_equal(0, scheduler.jobs.size)
+  end
+
+  def test_cleanup
+    scheduler = Moment::Scheduler.new
+    dead = Moment::SimpleTrigger.new(nil, Time.now-2, 1)
+    alive = Moment::SimpleTrigger.new(nil, nil, 1)
+
+    scheduler.schedule(Moment::Job.new, dead)
+    scheduler.schedule(Moment::Job.new, alive)
+
+    scheduler.clean_up
+
+    assert_equal(1, scheduler.jobs.size)
+    assert_equal(alive, scheduler.jobs.first[:trigger])
+
+  end
+
+end

data/test/server_test.rb

@@ -0,0 +1,53 @@
+
+require 'test/unit'
+require 'stringio'
+require File.dirname(__FILE__) + '/../lib/server'
+require File.dirname(__FILE__) + '/../lib/simple_trigger'
+require File.dirname(__FILE__) + '/../lib/job'
+
+class ServerTest < Test::Unit::TestCase
+
+  def test_initialize
+    server = Moment::Server.new
+    assert_equal([], server.jobs)
+  end
+
+  class CountExecuted < Moment::Job
+    attr_reader :executed
+    def initialize
+      @executed = 0
+    end
+    def execute
+      @executed += 1
+    end
+  end
+
+  def test_threading
+    scheduler = Moment::Server.new
+    simple = Moment::SimpleTrigger.new(Time.now, nil, 1)
+    job = CountExecuted.new
+
+    scheduler.run  # start running first
+    scheduler.schedule(job, simple)
+    sleep 3  # make sure to wait for the job to run at least once
+
+    assert_not_equal(0, job.executed)
+  end
+
+  def test_serialization
+    scheduler = Moment::Server.new
+    scheduler.schedule(CountExecuted.new, Moment::SimpleTrigger.new(nil, nil, 1))
+    file = StringIO.new
+    scheduler.dump(file)
+    assert_not_equal(0, file.size)
+    old_jobs = scheduler.jobs
+    assert_not_equal(0, scheduler.jobs.size)
+
+    file.rewind
+    scheduler = Moment::Server.new
+    assert_equal(0, scheduler.jobs.size)
+    scheduler.load(file)
+    assert_equal(old_jobs.size, scheduler.jobs.size)
+  end
+
+end

data/test/shell_job_test.rb

@@ -0,0 +1,19 @@
+
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/shell_job'
+
+class ShellJobTest < Test::Unit::TestCase
+
+  def test_initialize
+    job = Moment::ShellJob.new('cmd')
+    assert_not_nil(job)
+    assert_equal('cmd', job.command)
+  end
+
+  def test_execute
+    job = Moment::ShellJob.new('ls')
+    job.execute
+    assert_equal(`ls`, job.last_result)
+  end
+
+end

data/test/simple_trigger_test.rb

@@ -0,0 +1,16 @@
+
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/simple_trigger'
+
+class SimpleTriggerTest < Test::Unit::TestCase
+
+  def test_create
+    trig = Moment::SimpleTrigger.new
+    assert_not_nil(trig)
+  end
+
+  def test_start_time
+    trig = Moment::SimpleTrigger.new(nil, Time.now, nil)
+  end
+
+end

data/test/trigger_test.rb

@@ -0,0 +1,11 @@
+
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/trigger'
+
+class CronTriggerTest < Test::Unit::TestCase
+
+  def test_fire_time_after
+    assert_nil(Moment::Trigger.new.fire_time_after(Time.now))
+  end
+
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: moment
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-04-25 00:00:00 -07:00
+summary: A scheduler (like cron) that will run specified ruby code at given intervals or times
+require_paths: 
+- lib
+email: visnux@swivel.com
+homepage: http://visnup.com
+rubyforge_project: 
+description: 
+autorequire: moment
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Visnu Pitiyanuvath
+files: 
+- bin/moment_server
+- lib/server.rb
+- lib/client.rb
+- lib/trigger.rb
+- lib/shell_job.rb
+- lib/moment.rb
+- lib/cron_trigger.rb
+- lib/simple_trigger.rb
+- lib/scheduler.rb
+- lib/job.rb
+- test/server_test.rb
+- test/simple_trigger_test.rb
+- test/scheduler_test.rb
+- test/job_test.rb
+- test/cron_trigger_test.rb
+- test/trigger_test.rb
+- test/shell_job_test.rb
+- test/moment_test.rb
+- README
+test_files: 
+- test/moment_test.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- bin/moment_server
+executables: 
+- moment_server
+extensions: []
+
+requirements: []
+
+dependencies: []
+