scron 1.0.0

data/scron

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require File.expand_path('scron', File.dirname(__FILE__))
+
+ARGV.options do |o|
+  o.set_summary_indent('  ')
+  o.banner =    "Usage: #{File.basename($0)} [OPTION]"
+  o.define_head "Scheduler for laptops/machines which aren't on 24/7"
+  o.on('-e', '--edit', 'edit jobs') { Scron.edit; exit }
+  o.on('-r', '--run', 'run jobs') { Scron.run; exit }
+  o.on('-h', '--help', 'show this help message') { puts o; exit }
+  o.parse!
+  puts o
+end

data/scron.rb

@@ -0,0 +1,123 @@
+require 'date'
+
+class Scron
+  VERSION = '1.0.0'
+  SCHEDULE_FILE = "#{ENV['HOME']}/.scron"
+  HISTORY_FILE = "#{ENV['HOME']}/.scrondb"
+  LOG_FILE = "#{ENV['HOME']}/.scronlog"
+  EDITOR = ENV['EDITOR'] || 'vi'
+  attr_reader :history, :schedules
+  
+  def initialize(text, history_text)
+    @history = History.new(history_text)
+    @schedules = text.split("\n").
+      reject {|l| l =~ /^\s+$/}.
+      map {|l| Schedule.new(l, @history)}
+  end
+
+  def self.run
+    scron = Scron.new(read(SCHEDULE_FILE), read(HISTORY_FILE))
+    overdue = scron.schedules.select {|s| s.overdue?}
+    return if overdue.size == 0
+
+    logger = []
+    overdue.each do |schedule|
+      output = `#{schedule.command}`
+      logger << "=> #{now.strftime(History::FORMAT)} #{schedule.command} (#{$?.to_i})"
+      logger << output unless output == ''
+      scron.history.touch(schedule.command) if $?.to_i == 0
+    end
+    File.open(HISTORY_FILE, "w") {|f| f.puts scron.history.to_s}
+    File.open(LOG_FILE, "a") {|f| f.puts logger.map {|l| l.strip}.join("\n")}
+  end
+
+  def self.now
+    @now ||= DateTime.now
+  end
+
+  def self.edit
+    `#{EDITOR} #{SCHEDULE_FILE} < \`tty\` > \`tty\``
+  end
+
+  private
+  def self.read(filename)
+    File.exist?(filename) ? File.read(filename) : ''
+  end
+end
+
+class Schedule
+  attr_reader :interval, :command
+  WEEKDAYS = {'Mo' => 1, 'Tu' => 2, 'We' => 3, 'Th' => 4, 'Fr' => 5,
+              'Sa' => 6, 'Su' => 7}
+
+  def initialize(line, history)
+    interval, command = line.split(/\s+/, 2)
+    @interval = interval.split(',').map {|i| parse_days(i)}.min
+    @command = command.strip
+    @overdue = history[command].nil? || 
+               (Scron.now - history[command]).to_f > @interval
+  end
+
+  def overdue?
+    !!@overdue
+  end
+
+  private
+  def parse_days(interval)
+    now = Scron.now
+    if WEEKDAYS[interval]
+      (now.cwday - WEEKDAYS[interval]) % 7 + 1
+    elsif interval =~ /^\d+(st|nd|rd|th)$/
+      day = interval.to_i
+      delta = now.day >= day ?
+        now.day - day :
+        now - last_month(day)
+      delta.to_i + 1
+    elsif interval =~ /^(\d+)\/(\d+)$/
+      year, month, day = Scron.now.year, $1.to_i, $2.to_i
+      year -= 1 if Scron.now.month < month ||
+                   (Scron.now.month == month && Scron.now.day < day)
+      (Scron.now - DateTime.new(year, month, day)).to_i + 1
+    elsif interval =~ /^\d+d$/
+      interval.to_i
+    else
+      raise ArgumentError.new("Unable to parse: #{interval}")
+    end
+  end
+
+  def last_month(day)
+    last = Scron.now << 1
+    [day, 30, 29, 28].each do |d|
+      date = DateTime.new(last.year, last.month, d) rescue nil
+      return date if date
+    end
+  end
+end
+
+class History
+  FORMAT = '%Y-%m-%d.%H:%M'
+
+  def initialize(text)
+    @history = {}
+    text.split("\n").reject {|l| l =~ /^\s+$/}.each do |line|
+      timestamp, command = line.split(/\s+/, 2)
+      @history[command.strip] = DateTime.parse(timestamp, FORMAT)
+    end
+  end
+
+  def [](command)
+    @history[command]
+  end
+
+  def touch(command)
+    @history[command] = Scron.now
+  end
+
+  def to_s
+    lines = []
+    @history.each do |command, timestamp|
+      lines << "#{timestamp.strftime(FORMAT)} #{command}"
+    end
+    lines.join("\n")
+  end
+end

data/scron_test.rb

@@ -0,0 +1,124 @@
+require 'rubygems'
+require 'scron'
+require 'minitest/autorun'
+
+class ScronTest < MiniTest::Unit::TestCase
+  def setup
+    Scron.instance_variable_set(:@now, DateTime.new(2010, 3, 15))
+  end
+
+  def test_files
+    assert_equal("#{ENV['HOME']}/.scron", Scron::SCHEDULE_FILE)
+    assert_equal("#{ENV['HOME']}/.scrondb", Scron::HISTORY_FILE)
+    assert_equal("#{ENV['HOME']}/.scronlog", Scron::LOG_FILE)
+  end
+
+  def test_editor
+    assert_includes([ENV['EDITOR'] || 'vi'], Scron::EDITOR)
+  end
+
+  def test_empty
+    assert_equal('', Scron.send(:read, './non-existent-file'))
+    refute_equal('', Scron.send(:read, 'README.md'))
+  end
+
+  def test_no_schedules
+    scron = Scron.new('', '')
+    assert_equal([], scron.schedules)
+  end
+
+  def test_initialize_schedules
+    scron = Scron.new(
+      "30d cmd arg1 arg2\n" +
+      "7d /path/to/script.rb\n" +
+      "1d /path/to/script2.rb",
+      "2100-01-01.01:00 cmd arg1 arg2\n" +
+      "2000-01-01.01:00 /path/to/script.rb")
+    assert_equal(3, scron.schedules.size)
+    refute(scron.schedules[0].overdue?)
+    assert(scron.schedules[1].overdue?)
+    assert(scron.schedules[2].overdue?)
+  end
+end
+
+class ScheduleTest
+  def test_parse_day_interval
+    sched = Schedule.new('1d c', History.new(''))
+    assert_equal(1, sched.send(:parse_days, '1d'))
+    assert_equal(30, sched.send(:parse_days, '30d'))
+  end
+
+  def test_parse_day_of_week
+    sched = Schedule.new('1d c', History.new(''))
+    assert_equal(1, sched.send(:parse_days, 'Mo'))
+    assert_equal(7, sched.send(:parse_days, 'Tu'))
+    assert_equal(6, sched.send(:parse_days, 'We'))
+    assert_equal(5, sched.send(:parse_days, 'Th'))
+    assert_equal(4, sched.send(:parse_days, 'Fr'))
+    assert_equal(3, sched.send(:parse_days, 'Sa'))
+    assert_equal(2, sched.send(:parse_days, 'Su'))
+  end
+
+  def test_parse_day_of_month
+    sched = Schedule.new('1d c', History.new(''))
+    assert_equal(15, sched.send(:parse_days, '1st'))
+    assert_equal(1, sched.send(:parse_days, '15th'))
+    assert_equal(21, sched.send(:parse_days, '23rd'))
+    assert_equal(16, sched.send(:parse_days, '31st'))
+  end
+
+  def test_parse_day_of_year
+    sched = Schedule.new('1d c', History.new(''))
+    assert_equal(74, sched.send(:parse_days, '1/1'))
+    assert_equal(1, sched.send(:parse_days, '3/15'))
+    assert_equal(81, sched.send(:parse_days, '12/25'))
+  end
+
+  def test_initialize_command
+    sched = Schedule.new('30d cmd arg1 arg2', History.new(''))
+    assert_equal('cmd arg1 arg2', sched.command)
+    assert_equal(30, sched.interval)
+    assert(sched.overdue?)
+  end
+
+  def test_bad_date
+    sched = Schedule.new('1d c', History.new(''))
+    assert_raises(ArgumentError) { sched.send(:parse_days, '2/31') }
+    assert_raises(ArgumentError) { sched.send(:parse_days, '1') }
+  end
+
+  def test_multiple_intervals
+    assert_equal(1, Schedule.new('1d,2d,3d cmd', History.new('')).interval)
+    assert_equal(2, Schedule.new('Fr,Sa,Su cmd', History.new('')).interval)
+    assert_equal(15, Schedule.new('1st,23rd cmd', History.new('')).interval)
+  end
+
+  def test_overdue_history
+    sched = Schedule.new('30d cmd', History.new('2000-01-01.01:00 cmd'))
+    assert(sched.overdue?)
+  end
+
+  def test_recent_history
+    sched = Schedule.new('30d cmd', History.new('2100-01-01.01:00 cmd'))
+    refute(sched.overdue?)
+  end
+end
+
+class HistoryTest
+  def test_initialize
+    history = History.new('2100-01-01.01:00 cmd arg1 arg2')
+    assert_equal(DateTime.new(2100, 1, 1, 1, 0), history['cmd arg1 arg2'])
+  end
+
+  def test_update_command
+    history = History.new('')
+    history.touch('cmd')
+    assert_kind_of(DateTime, history['cmd'])
+  end
+
+  def test_output
+    history = History.new('')
+    history.touch('cmd')
+    assert_match(/^20\d{2}-\d{2}-\d{2}.\d{2}:\d{2} cmd$/, history.to_s)
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: scron
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Hugh Bien
+autorequire: 
+bindir: .
+cert_chain: []
+
+date: 2011-10-06 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: Run commands at scheduled intervals.  If an interval is missed, the command will be run as soon as possible.
+email: 
+- hugh@hughbien.com
+executables: 
+- scron
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- scron.rb
+- scron_test.rb
+- scron
+- ./scron
+homepage: https://github.com/hughbien/scron
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Scheduler for laptops/machines which aren't on 24/7
+test_files: []
+