andrewtimberlake-whenever 0.1.5.1

data/CHANGELOG.rdoc

@@ -0,0 +1,26 @@
+== 0.1.5 / February 19th, 2009
+
+* Fixed load path so Whenever's files don't conflict with anything in Rails. Thanks Ryan Koopmans. [Javan Makhmali]
+
+
+== 0.1.4 / February 17th, 2009
+
+* Added --load-file and --user opts to whenever binary. [Javan Makhmali]
+
+
+== 0.1.3 / February 16th, 2009
+
+* Added 'rake' helper for defining scheduled rake tasks. [Javan Makhmali]
+
+* Renamed :cron_environment and :cron_path to :enviroment and :path for better (word) compatibility with rake tasks. [Javan Makhmali]
+
+* Improved test load paths so tests can be run individually. [Javan Makhmali]
+
+* Got rid of already initialized constant warning. [Javan Makhmali]
+
+* Requiring specific gem versions: Chronic >=0.2.3 and activesupport >= 1.3.0 [Javan Makhmali]
+
+
+== 0.1.0 / February 15th, 2009
+
+* Initial release [Javan Makhmali]

data/README.rdoc

@@ -0,0 +1,125 @@
+== Introduction
+
+Whenever is a Ruby gem that provides a clear syntax for defining cron jobs. It outputs valid cron syntax and can even write your crontab file for you. It is designed to work well with Rails applications and can be deployed with Capistrano. Whenever works fine independently as well.
+
+== Installation
+
+Regular (non-Rails) install:
+  
+  $ gem sources -a http://gems.github.com  #you only need to run this once
+  $ sudo gem install javan-whenever
+
+In a Rails (2.1 or greater) application:
+  
+in your "config/environment.rb" file:
+
+  Rails::Initializer.run do |config|
+    config.gem 'javan-whenever', :lib => false, :version => '>= 0.1.5' :source => 'http://gems.github.com'
+  end
+  
+To install this gem (and all other missing gem dependencies), run rake gems:install (use sudo if necessary).
+
+In older versions of Rails:
+
+  $ gem sources -a http://gems.github.com  #you only need to run this once
+  $ gem install javan-whenever
+
+in your "config/environment.rb" file:
+
+  Rails::Initializer.run do |config|
+    ...
+  end
+
+  require 'whenever'
+  
+NOTE: Requiring the whenever gem inside your Rails application is technically optional. However, if you plan to use something like Capistrano to automatically deploy and write your crontab file, you'll need to have the gem installed on your servers, and requiring it in your app is one way to ensure this.
+
+== Getting started
+
+  $ cd /my/rails/app
+  $ wheneverize .
+
+This will create an initial "config/schedule.rb" file you.
+
+== Example schedule.rb file
+  
+  every 3.hours do
+    runner "MyModel.some_process"       
+    rake "my:rake:task"                 
+    command "/usr/bin/my_great_command"
+  end
+
+  every 1.day, :at => '4:30 am' do 
+    runner "MyModel.task_to_run_at_four_thirty_in_the_morning"
+  end
+
+  every :hour do # Many shortcuts available: :hour, :day, :month, :year, :reboot
+    runner "SomeModel.ladeeda"
+  end
+
+  every :sunday do # Use any day of the week or :weekend, :weekday 
+    runner "Task.do_something_great"
+  end
+
+More examples on the wiki: http://wiki.github.com/javan/whenever/instructions-and-examples
+  
+== Cron output
+
+  $ cd /my/rails/app
+  $ whenever
+
+And you'll see your schedule.rb converted to cron sytax
+
+== Capistrano integration
+
+in your "config/deploy.rb" file do something like:
+
+  after "deploy:symlink", "deploy:write_crontab"
+
+  namespace :deploy do
+    desc "write the crontab file"
+    task :write_crontab, :roles => :app do
+      run "cd #{release_path} && whenever --write-crontab"
+    end
+  end
+  
+By mixing and matching the "--load-file" and "--user" options with your various :roles in Capistrano it is entirely possible to deploy different crontab schedules under different users to all your various servers. Get creative!
+  
+USING THE "--write-crontab" OPTION WILL COMPLETELY OVERWRITE ANY EXISTING CRONTAB ENTRIES!
+
+== Credit
+
+Whenever was created for use at Inkling (http://inklingmarkets.com) where I work. Their take on it: http://blog.inklingmarkets.com/2009/02/whenever-easy-way-to-do-cron-jobs-from.html
+
+While building Whenever, I learned a lot by digging through the source code of Capistrano - http://github.com/jamis/capistrano
+
+== Feedback
+
+Lighthouse: http://javan.lighthouseapp.com/projects/25781-whenever/overview
+
+Email me: javan [at] javan (dot) us
+
+== License
+
+Copyright (c) 2009 Javan Makhmali
+
+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/Rakefile

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+require File.expand_path(File.dirname(__FILE__) + "/lib/version")
+
+Echoe.new('whenever', Whenever::VERSION::STRING) do |p|
+  p.description    = "Provides clean ruby syntax for defining messy cron jobs and running them Whenever."
+  p.url            = "http://github.com/javan/whenever"
+  p.author         = "Javan Makhmali"
+  p.email          = "javan@javan.us"
+  p.dependencies   = ["chronic >=0.2.3", "activesupport >=1.3.0"]
+end

data/bin/whenever

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << "/home/andrew/dev/whenever/lib"
+
+require 'rubygems'
+require 'optparse'
+require 'fileutils'
+require 'tempfile'
+require 'whenever'
+
+require File.expand_path(File.dirname(__FILE__) + "/../lib/version")
+
+options = Hash.new
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: whenever [options]"
+  opts.on('-v', '--version') { puts "Whenever v#{Whenever::VERSION::STRING}"; exit }
+  opts.on('-w', '--write-crontab') { options[:write] = true }
+  opts.on('-f', '--load-file [schedule file]', 'default: config/schedule.rb') do |file|
+    options[:file] = file if file
+  end
+  opts.on('-u', '--user [user]', 'default: current user') do |user| 
+    options[:user] = user if user
+  end
+end.parse!
+
+options[:file] ||= 'config/schedule.rb'
+
+unless File.exists?(options[:file])
+  warn("[fail] can't find file: #{options[:file]}")
+  exit(1)
+end
+
+if options[:write]
+  cron_output   = Whenever.cron(:file => options[:file])
+  file_path = File.expand_path(options[:file])
+  
+  #Get existing crontab
+  command = ['crontab']
+  command << "-u #{options[:user]}" if options[:user]
+  command << "-l"
+  
+  existing_crontab = `#{command.join(' ')}`
+  if $?.exitstatus == 0
+    lines = existing_crontab.split(/\n/)
+    kept_lines = []
+    keep = true
+    lines.each do |line|
+      keep = false if line =~ /#BEGIN.*#{Regexp.escape(file_path)}/
+
+      kept_lines << line if keep
+
+      keep = true if line =~ /#END.*#{Regexp.escape(file_path)}/
+    end
+  else
+    warn "[fail] couldn't read existing crontab"
+    exit(1)
+  end
+  
+  tmp_cron_file = Tempfile.new('whenever_tmp_cron').path
+  File.open(tmp_cron_file, File::WRONLY | File::APPEND) do |file|
+    kept_lines.each do |line|
+      file.puts line
+    end
+    file << "#BEGIN: Crontab entry generated from: #{file_path}\n"
+    file << cron_output
+    file << "#END: Crontab entry generated from: #{file_path}\n"
+  end
+
+  command = ['crontab']
+  command << "-u #{options[:user]}" if options[:user]
+  command << tmp_cron_file
+  
+  if system(command.join(' '))
+    puts "[write] crontab file updated"
+    exit
+  else
+    warn "[fail] couldn't write crontab"
+    exit(1)
+  end
+  
+else
+  puts Whenever.cron(:file => options[:file])
+  exit
+end

data/bin/wheneverize

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+
+# This file is based heavily on Capistrano's `capify` command
+
+require 'optparse'
+require 'fileutils'
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename($0)} [path]"
+
+  begin
+    opts.parse!(ARGV)
+  rescue OptionParser::ParseError => e
+    warn e.message
+    puts opts
+    exit 1
+  end
+end
+
+if ARGV.empty?
+  abort "Please specify the directory to wheneverize, e.g. `#{File.basename($0)} .'"
+elsif !File.exists?(ARGV.first)
+  abort "`#{ARGV.first}' does not exist."
+elsif !File.directory?(ARGV.first)
+  abort "`#{ARGV.first}' is not a directory."
+elsif ARGV.length > 1
+  abort "Too many arguments; please specify only the directory to wheneverize."
+end
+
+
+content = <<-FILE
+# Use this file to easily define all of your cron jobs.
+#
+# It's helpful, but not entirely necessary to understand cron before proceeding.
+# http://en.wikipedia.org/wiki/Cron
+
+# Example:
+#
+# set :cron_log, "/path/to/my/cron_log.log"
+#
+# every 2.hours do
+#   command "/usr/bin/some_great_command"
+#   runner "MyModel.some_method"
+#   rake "some:great:rake:task"
+# end
+#
+# every 4.days do
+#   runner "AnotherModel.prune_old_records"
+# end
+
+# Learn more: http://github.com/javan/whenever
+FILE
+
+file = 'config/schedule.rb'
+base = ARGV.shift
+
+file = File.join(base, file)
+if File.exists?(file)
+  warn "[skip] `#{file}' already exists"
+elsif File.exists?(file.downcase)
+  warn "[skip] `#{file.downcase}' exists, which could conflict with `#{file}'"
+elsif !File.exists?(File.dirname(file))
+  warn "[skip] directory `#{File.dirname(file)}' does not exist"
+else
+  puts "[add] writing `#{file}'"
+  File.open(file, "w") { |f| f.write(content) }
+end
+
+puts "[done] wheneverized!"

data/lib/base.rb

@@ -0,0 +1,15 @@
+module Whenever
+  
+  def self.cron(options)
+    Whenever::JobList.new(options).generate_cron_output
+  end
+  
+  def self.path
+    if defined?(RAILS_ROOT)
+      RAILS_ROOT 
+    elsif defined?(::RAILS_ROOT)
+      ::RAILS_ROOT
+    end
+  end
+  
+end

data/lib/job_list.rb

@@ -0,0 +1,90 @@
+module Whenever
+  class JobList
+  
+    def initialize(options)
+      @jobs = Hash.new
+      @env  = Hash.new
+      
+      config = case options
+        when String then options
+        when Hash
+          if options[:string]
+            options[:string]
+          elsif options[:file]
+            File.read(options[:file])
+          end
+      end
+
+      eval(config)
+    end
+    
+    def set(variable, value)
+      instance_variable_set("@#{variable}".to_sym, value)
+      self.class.send(:attr_reader, variable.to_sym)
+    end
+    
+    def env(variable, value)
+      @env[variable.to_s] = value
+    end
+  
+    def every(frequency, options = {})
+      @current_time_scope = frequency
+      @options = options
+      yield
+    end
+    
+    def command(task, options = {})
+      options[:cron_log] ||= @cron_log unless options[:cron_log] === false
+      options[:class]    ||= Whenever::Job::Default
+      @jobs[@current_time_scope] ||= []
+      @jobs[@current_time_scope] << options[:class].new(@options.merge(:task => task).merge(options))
+    end
+    
+    def runner(task, options = {})
+      options.reverse_merge!(:environment => @environment, :path => @path)
+      options[:class] = Whenever::Job::Runner
+      command(task, options)
+    end
+    
+    def rake(task, options = {})
+      options.reverse_merge!(:environment => @environment, :path => @path)
+      options[:class] = Whenever::Job::RakeTask
+      command(task, options)
+    end
+  
+    def generate_cron_output
+      [environment_variables, cron_jobs].compact.join
+    end
+    
+  private
+  
+    def environment_variables
+      return if @env.empty?
+      
+      output = []
+      @env.each do |key, val|
+        output << "#{key}=#{val}\n"
+      end
+      output << "\n"
+      
+      output.join
+    end
+    
+    def cron_jobs
+      return if @jobs.empty?
+      
+      output = []
+      @jobs.each do |time, jobs|
+        jobs.each do |job|
+          cron = Whenever::Output::Cron.output(time, job)
+          cron << " >> #{job.cron_log} 2>&1" if job.cron_log 
+          cron << "\n\n"
+          output << cron
+        end
+      end
+      
+      output.join
+    end
+    
+  end
+end

data/lib/job_types/default.rb

@@ -0,0 +1,27 @@
+module Whenever
+  module Job
+    class Default
+      
+      attr_accessor :task, :at, :cron_log
+    
+      def initialize(options = {})
+        @task        = options[:task]
+        @at          = options[:at]
+        @cron_log    = options[:cron_log]
+        @environment = options[:environment] || :production
+        @path        = options[:path] || Whenever.path
+      end
+    
+      def output
+        task
+      end
+      
+    protected
+      
+      def path_required
+        raise ArgumentError, "No path available; set :path, '/your/path' in your schedule file" if @path.blank?
+      end
+      
+    end
+  end
+end

data/lib/job_types/rake_task.rb

@@ -0,0 +1,12 @@
+module Whenever
+  module Job
+    class RakeTask < Whenever::Job::Default
+      
+      def output
+        path_required
+        "cd #{@path} && RAILS_ENV=#{@environment} /usr/bin/env rake #{task}"
+      end
+      
+    end
+  end
+end

data/lib/job_types/runner.rb

@@ -0,0 +1,12 @@
+module Whenever
+  module Job
+    class Runner < Whenever::Job::Default
+
+      def output
+        path_required
+        %Q(#{File.join(@path, 'script', 'runner')} -e #{@environment} "#{task}")
+      end
+      
+    end
+  end
+end

data/lib/outputs/cron.rb

@@ -0,0 +1,104 @@
+module Whenever
+  module Output
+    
+    class Cron
+      
+      attr_accessor :time, :task
+      
+      def initialize(time = nil, task = nil, at = nil)
+        @time = time
+        @task = task
+        @at   = at.is_a?(String) ? (Chronic.parse(at) || 0) : (at || 0)
+      end
+      
+      def self.output(time, job)
+        out = new(time, job.output, job.at)
+        "#{out.time_in_cron_syntax} #{out.task}"
+      end
+      
+      def time_in_cron_syntax
+        case @time
+          when Symbol then parse_symbol
+          when String then parse_as_string
+          else parse_time
+        end
+      end
+      
+    protected
+    
+      def parse_symbol
+        case @time
+          when :reboot          then '@reboot'
+          when :year, :yearly   then '@annually'
+          when :day, :daily     then '@daily'
+          when :midnight        then '@midnight'
+          when :month, :monthly then '@monthly'
+          when :week, :weekly   then '@weekly'
+          when :hour, :hourly   then '@hourly'
+          else parse_as_string
+        end
+      end
+      
+      def parse_time
+        timing = Array.new(5, '*')
+        case @time
+          when 0.seconds...1.minute
+            raise ArgumentError, "Time must be in minutes or higher"
+          when 1.minute...1.hour
+            minute_frequency = @time / 60
+            timing[0] = comma_separated_timing(minute_frequency, 59)
+          when 1.hour...1.day
+            hour_frequency = (@time / 60 / 60).round
+            timing[0] = @at.is_a?(Time) ? @at.min : @at  
+            timing[1] = comma_separated_timing(hour_frequency, 23)
+          when 1.day...1.month
+            day_frequency = (@time / 24 / 60 / 60).round
+            timing[0] = @at.is_a?(Time) ? @at.min  : 0
+            timing[1] = @at.is_a?(Time) ? @at.hour : @at
+            timing[2] = comma_separated_timing(day_frequency, 31, 1)
+          when 1.month..12.months
+            month_frequency = (@time / 30  / 24 / 60 / 60).round
+            timing[0] = @at.is_a?(Time) ? @at.min  : 0
+            timing[1] = @at.is_a?(Time) ? @at.hour : 0
+            timing[2] = @at.is_a?(Time) ? @at.day  : (@at.zero? ? 1 : @at)
+            timing[3] = comma_separated_timing(month_frequency, 12, 1)
+          else
+            return parse_as_string
+        end
+        timing.join(' ')
+      end
+      
+      def parse_as_string
+        return unless @time
+        string = @time.to_s
+        
+        return "0 0 * * mon-fri" if string.downcase.index('weekday')
+        return "0 0 * * sat,sun" if string.downcase.index('weekend')
+        
+        %w(sun mon tue wed thu fri sat).each do |day|
+          return "0 0 * * #{day}" if string.downcase.index(day)
+        end
+        
+        raise ArgumentError, "Couldn't parse: #{@time}"
+      end
+      
+      def comma_separated_timing(frequency, max, start = 0)
+        return start     if frequency.blank? || frequency.zero?
+        return '*'       if frequency == 1
+        return frequency if frequency > (max * 0.5).ceil
+        
+        original_start = start
+        
+        start += frequency unless (max + 1).modulo(frequency).zero? || start > 0
+        output = (start..max).step(frequency).to_a
+        
+        max_occurances = (max.to_f  / (frequency.to_f)).round
+        max_occurances += 1 if original_start.zero?
+        
+        output[0, max_occurances].join(',')
+      end
+
+    end
+    
+  end
+end

data/lib/version.rb

@@ -0,0 +1,9 @@
+module Whenever
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 5
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end unless defined?(Whenever::VERSION)

data/lib/whenever.rb

@@ -0,0 +1,19 @@
+unless defined?(Whenever)
+  $:.unshift(File.dirname(__FILE__))
+   
+  # Hoping to load Rails' Rakefile
+  begin
+    load 'Rakefile'
+  rescue LoadError => e
+    nil
+  end
+end
+
+# Dependencies
+require 'activesupport'
+require 'chronic'
+
+# Whenever files
+%w{ base version job_list job_types/default job_types/rake_task job_types/runner outputs/cron }.each do |file|
+  require	File.expand_path(File.dirname(__FILE__) + "/#{file}")
+end

data/test/cron_test.rb

@@ -0,0 +1,187 @@
+require File.expand_path(File.dirname(__FILE__) + "/test_helper")
+
+class CronTest < Test::Unit::TestCase
+  
+  context "When parsing time in minutes" do
+    should "raise if less than 1 minute" do
+      assert_raises ArgumentError do
+        parse_time(59.seconds)
+      end
+      
+      assert_raises ArgumentError do
+        parse_time(0.minutes)
+      end
+    end
+    
+    # For santity, do some tests on straight String
+    should "parse correctly" do
+      assert_equal '* * * * *', parse_time(1.minute)
+      assert_equal '0,5,10,15,20,25,30,35,40,45,50,55 * * * *', parse_time(5.minutes)
+      assert_equal '7,14,21,28,35,42,49,56 * * * *', parse_time(7.minutes)
+      assert_equal '0,30 * * * *', parse_time(30.minutes)
+      assert_equal '32 * * * *', parse_time(32.minutes)
+      assert_not_equal '60 * * * *', parse_time(60.minutes) # 60 minutes bumps up into the hour range
+    end
+    
+    # Test all minutes
+    (2..59).each do |num|
+      should "parse correctly for #{num} minutes" do
+        start = 0
+        start += num unless 60.modulo(num).zero?
+        minutes = (start..59).step(num).to_a
+        
+        assert_equal "#{minutes.join(',')} * * * *", parse_time(num.minutes)
+      end
+    end
+  end
+  
+  context "When parsing time in hours" do
+    should "parse correctly" do
+      assert_equal '0 * * * *', parse_time(1.hour)
+      assert_equal '0 0,2,4,6,8,10,12,14,16,18,20,22 * * *', parse_time(2.hours)
+      assert_equal '0 0,3,6,9,12,15,18,21 * * *', parse_time(3.hours)
+      assert_equal '0 5,10,15,20 * * *', parse_time(5.hours)
+      assert_equal '0 17 * * *', parse_time(17.hours)
+      assert_not_equal '0 24 * * *', parse_time(24.hours) # 24 hours bumps up into the day range
+    end
+    
+    (2..23).each do |num|
+      should "parse correctly for #{num} hours" do
+        start = 0
+        start += num unless 24.modulo(num).zero?
+        hours = (start..23).step(num).to_a
+        
+        assert_equal "0 #{hours.join(',')} * * *", parse_time(num.hours)
+      end
+    end
+    
+    should "parse correctly when given an 'at' with minutes as an Integer" do
+      assert_minutes_equals "1",  1
+      assert_minutes_equals "14", 14
+      assert_minutes_equals "27", 27
+      assert_minutes_equals "55", 55
+    end
+    
+    should "parse correctly when given an 'at' with minutes as a Time" do
+      # Basically just testing that Chronic parses some times and we get the minutes out of it
+      assert_minutes_equals "1",  '3:01am'
+      assert_minutes_equals "1",  'January 21 2:01 PM'
+      assert_minutes_equals "0",  'midnight'
+      assert_minutes_equals "59", '13:59'
+    end
+  end
+  
+  context "When parsing time in days (of month)" do
+    should "parse correctly" do
+      assert_equal '0 0 * * *', parse_time(1.days)
+      assert_equal '0 0 1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31 * *', parse_time(2.days)
+      assert_equal '0 0 1,5,9,13,17,21,25,29 * *', parse_time(4.days)
+      assert_equal '0 0 1,8,15,22 * *', parse_time(7.days)
+      assert_equal '0 0 1,17 * *', parse_time(16.days)
+      assert_equal '0 0 17 * *', parse_time(17.days)
+      assert_equal '0 0 29 * *', parse_time(29.days)
+      assert_not_equal '0 0 30 * *', parse_time(30.days) # 30 days bumps into the month range
+    end
+    
+    should "parse correctly when given an 'at' with hours, minutes as a Time" do
+      # first param is an array with [hours, minutes]
+      assert_hours_and_minutes_equals %w(3 45),  '3:45am'
+      assert_hours_and_minutes_equals %w(20 1),  '8:01pm'
+      assert_hours_and_minutes_equals %w(0 0),   'midnight'
+      assert_hours_and_minutes_equals %w(1 23),  '1:23 AM'
+      assert_hours_and_minutes_equals %w(23 59), 'March 21 11:59 pM'
+    end
+    
+    should "parse correctly when given an 'at' with hours as an Integer" do
+      # first param is an array with [hours, minutes]
+      assert_hours_and_minutes_equals %w(1 0),  1
+      assert_hours_and_minutes_equals %w(3 0),  3
+      assert_hours_and_minutes_equals %w(15 0), 15
+      assert_hours_and_minutes_equals %w(19 0), 19
+      assert_hours_and_minutes_equals %w(23 0), 23
+    end
+  end
+  
+  context "When parsing time in months" do
+    should "parse correctly" do
+      assert_equal '0 0 1 * *', parse_time(1.month)
+      assert_equal '0 0 1 1,3,5,7,9,11 *', parse_time(2.months)
+      assert_equal '0 0 1 1,4,7,10 *', parse_time(3.months)
+      assert_equal '0 0 1 1,5,9 *', parse_time(4.months)
+      assert_equal '0 0 1 1,6 *', parse_time(5.months)
+      assert_equal '0 0 1 7 *', parse_time(7.months)
+      assert_equal '0 0 1 8 *', parse_time(8.months)
+      assert_equal '0 0 1 9 *', parse_time(9.months)
+      assert_equal '0 0 1 10 *', parse_time(10.months)
+      assert_equal '0 0 1 11 *', parse_time(11.months)
+      assert_equal '0 0 1 12 *', parse_time(12.months)
+    end
+    
+    should "parse correctly when given an 'at' with days, hours, minutes as a Time" do
+      # first param is an array with [days, hours, minutes]
+      assert_days_and_hours_and_minutes_equals %w(1 3 45),  'January 1st 3:45am'
+      assert_days_and_hours_and_minutes_equals %w(11 23 0), 'Feb 11 11PM'
+      assert_days_and_hours_and_minutes_equals %w(22 1 1), 'march 22nd at 1:01 am'
+      assert_days_and_hours_and_minutes_equals %w(23 0 0), 'march 22nd at midnight' # looks like midnight means the next day
+    end
+    
+    should "parse correctly when given an 'at' with days as an Integer" do
+      # first param is an array with [days, hours, minutes]
+      assert_days_and_hours_and_minutes_equals %w(1 0 0),  1
+      assert_days_and_hours_and_minutes_equals %w(15 0 0), 15
+      assert_days_and_hours_and_minutes_equals %w(29 0 0), 29
+    end
+  end
+  
+  context "When parsing time in days (of week)" do
+    should "parse days of the week correctly" do
+      {
+        'sun' => %w(sun Sunday SUNDAY SUN),
+        'mon' => %w(mon Monday MONDAY MON),
+        'tue' => %w(tue tues Tuesday TUESDAY TUE),
+        'wed' => %w(wed Wednesday WEDNESDAY WED),
+        'thu' => %w(thu thurs thur Thursday THURSDAY THU),
+        'fri' => %w(fri Friday FRIDAY FRI),
+        'sat' => %w(sat Saturday SATURDAY SAT) 
+      }.each do |day, day_tests|
+        day_tests.each do |day_test|
+          assert_equal "0 0 * * #{day}", parse_time(day_test)
+        end
+      end
+    end
+    
+    should "parse weekday correctly" do
+      assert_equal '0 0 * * mon-fri', parse_time('weekday')
+      assert_equal '0 0 * * mon-fri', parse_time('Weekdays')
+    end
+    
+    should "parse weekend correctly" do
+      assert_equal '0 0 * * sat,sun', parse_time('weekend')
+      assert_equal '0 0 * * sat,sun', parse_time('Weekends')
+    end
+  end
+  
+private
+
+  def assert_days_and_hours_and_minutes_equals(expected, time)
+    cron = parse_time(2.months, 'some task', time)
+    minutes, hours, days, *garbage = cron.split(' ')
+    assert_equal expected, [days, hours, minutes]
+  end
+
+  def assert_hours_and_minutes_equals(expected, time)
+    cron = parse_time(2.days, 'some task', time)
+    minutes, hours, *garbage = cron.split(' ')
+    assert_equal expected, [hours, minutes]
+  end
+
+  def assert_minutes_equals(expected, time)
+    cron = parse_time(2.hours, 'some task', time)
+    assert_equal expected, cron.split(' ')[0]
+  end
+
+  def parse_time(time = nil, task = nil, at = nil)
+    Whenever::Output::Cron.new(time, task, at).time_in_cron_syntax
+  end
+  
+end

data/test/output_command_test.rb

@@ -0,0 +1,70 @@
+require File.expand_path(File.dirname(__FILE__) + "/test_helper")
+
+class OutputCommandTest < Test::Unit::TestCase
+  
+  context "A plain command" do
+    setup do
+      @output = Whenever.cron \
+      <<-file
+        every 2.hours do
+          command "blahblah"
+        end
+      file
+    end
+    
+    should "output the command" do
+      assert_match /^.+ .+ .+ .+ blahblah$/, @output
+    end
+  end
+  
+  context "A command when the cron_log is set" do
+    setup do
+      @output = Whenever.cron \
+      <<-file
+        set :cron_log, 'logfile.log'
+        every 2.hours do
+          command "blahblah"
+        end
+      file
+    end
+    
+    should "output the command with the log syntax appended" do
+      assert_match /^.+ .+ .+ .+ blahblah >> logfile.log 2>&1$/, @output
+    end
+  end
+  
+  context "A command when the cron_log is set and the comand overrides it" do
+    setup do
+      @output = Whenever.cron \
+      <<-file
+        set :cron_log, 'logfile.log'
+        every 2.hours do
+          command "blahblah", :cron_log => 'otherlog.log'
+        end
+      file
+    end
+    
+    should "output the command with the log syntax appended" do
+      assert_no_match /.+ .+ .+ .+ blahblah >> logfile.log 2>&1/, @output
+      assert_match /^.+ .+ .+ .+ blahblah >> otherlog.log 2>&1$/, @output
+    end
+  end
+  
+  context "A command when the cron_log is set and the comand rejects it" do
+    setup do
+      @output = Whenever.cron \
+      <<-file
+        set :cron_log, 'logfile.log'
+        every 2.hours do
+          command "blahblah", :cron_log => false
+        end
+      file
+    end
+
+    should "output the command without the log syntax appended" do
+      assert_no_match /.+ .+ .+ .+ blahblah >> logfile.log 2>&1/, @output
+      assert_match /^.+ .+ .+ .+ blahblah$/, @output
+    end
+  end
+  
+end

data/test/output_env_test.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + "/test_helper")
+
+class OutputEnvTest < Test::Unit::TestCase
+
+  context "The output from Whenever with environment variables set" do
+    setup do
+      @output = Whenever.cron \
+      <<-file
+        env :MYVAR, 'blah'
+        env 'MAILTO', "someone@example.com"
+      file
+    end
+
+    should "output MYVAR environment variable" do
+      assert_match "MYVAR=blah", @output
+    end
+  
+    should "output MAILTO environment variable" do
+      assert_match "MAILTO=someone@example.com", @output
+    end
+  end
+
+end

data/test/output_rake_test.rb

@@ -0,0 +1,74 @@
+require File.expand_path(File.dirname(__FILE__) + "/test_helper")
+
+class OutputRakeTest < Test::Unit::TestCase
+  
+  # Rake are generated in an almost identical way to runners so we
+  # only need some basic tests to ensure they are output correctly
+  
+  context "A rake command with path set" do
+    setup do
+      @output = Whenever.cron \
+      <<-file
+        set :path, '/my/path'
+        every 2.hours do
+          rake "blahblah"
+        end
+      file
+    end
+    
+    should "output the rake command using that path" do
+      assert_match two_hours + ' cd /my/path && RAILS_ENV=production /usr/bin/env rake blahblah', @output
+    end
+  end
+  
+  context "A rake command that overrides the path set" do
+    setup do
+      @output = Whenever.cron \
+      <<-file
+        set :path, '/my/path'
+        every 2.hours do
+          rake "blahblah", :path => '/some/other/path'
+        end
+      file
+    end
+    
+    should "output the rake command using that path" do
+      assert_match two_hours + ' cd /some/other/path && RAILS_ENV=production /usr/bin/env rake blahblah', @output
+    end
+  end
+  
+  context "A rake command with environment set" do
+    setup do
+      @output = Whenever.cron \
+      <<-file
+        set :environment, :silly
+        set :path, '/my/path'
+        every 2.hours do
+          rake "blahblah"
+        end
+      file
+    end
+    
+    should "output the rake command using that environment" do
+      assert_match two_hours + ' cd /my/path && RAILS_ENV=silly /usr/bin/env rake blahblah', @output
+    end
+  end
+  
+  context "A rake command that overrides the environment set" do
+    setup do
+      @output = Whenever.cron \
+      <<-file
+        set :environment, :silly
+        set :path, '/my/path'
+        every 2.hours do
+          rake "blahblah", :environment => :serious
+        end
+      file
+    end
+    
+    should "output the rake command using that environment" do
+      assert_match two_hours + ' cd /my/path && RAILS_ENV=serious /usr/bin/env rake blahblah', @output
+    end
+  end
+  
+end

data/test/output_runner_test.rb

@@ -0,0 +1,125 @@
+require File.expand_path(File.dirname(__FILE__) + "/test_helper")
+
+class OutputRunnerTest < Test::Unit::TestCase
+  
+  context "A runner with path set" do
+    setup do
+      @output = Whenever.cron \
+      <<-file
+        set :path, '/my/path'
+        every 2.hours do
+          runner "blahblah"
+        end
+      file
+    end
+    
+    should "output the runner using that path" do
+      assert_match two_hours + ' /my/path/script/runner -e production "blahblah"', @output
+    end
+  end
+  
+  context "A runner that overrides the path set" do
+    setup do
+      @output = Whenever.cron \
+      <<-file
+        set :path, '/my/path'
+        every 2.hours do
+          runner "blahblah", :path => '/some/other/path'
+        end
+      file
+    end
+    
+    should "output the runner using that path" do
+      assert_match two_hours + ' /some/other/path/script/runner -e production "blahblah"', @output
+    end
+  end
+  
+  context "A runner with no path set and RAILS_ROOT defined" do
+    setup do
+      Whenever.stubs(:path).returns('/my/path')
+      
+      @output = Whenever.cron \
+      <<-file
+        every 2.hours do
+          runner "blahblah"
+        end
+      file
+    end
+    
+    should "output the runner using that path" do
+      assert_match two_hours + ' /my/path/script/runner -e production "blahblah"', @output
+    end
+  end
+  
+  context "A runner with path set AND RAILS_ROOT defined" do
+    setup do
+      Whenever.stubs(:path).returns('/my/rails/path')
+      
+      @output = Whenever.cron \
+      <<-file
+        set :path, '/my/path'
+        every 2.hours do
+          runner "blahblah"
+        end
+      file
+    end
+    
+    should "use the path" do
+      assert_match two_hours + ' /my/path/script/runner -e production "blahblah"', @output
+      assert_no_match /\/rails\/path/, @output
+    end
+  end
+  
+  context "A runner with no path set and no RAILS_ROOT defined" do
+    setup do
+      Whenever.stubs(:path).returns(nil)
+      
+      @input = <<-file
+        every 2.hours do
+          runner "blahblah"
+        end
+      file
+    end
+    
+    should "raise an exception" do
+      assert_raises ArgumentError do
+        Whenever.cron(@input)
+      end
+    end
+  end
+  
+  context "A runner with an environment set" do
+    setup do
+      @output = Whenever.cron \
+      <<-file
+        set :environment, :silly
+        set :path, '/my/path'
+        every 2.hours do
+          runner "blahblah"
+        end
+      file
+    end
+    
+    should "output the runner using that environment" do
+      assert_match two_hours + ' /my/path/script/runner -e silly "blahblah"', @output
+    end
+  end
+  
+  context "A runner that overrides the environment set" do
+    setup do
+      @output = Whenever.cron \
+      <<-file
+        set :environment, :silly
+        set :path, '/my/path'
+        every 2.hours do
+          runner "blahblah", :environment => :serious
+        end
+      file
+    end
+    
+    should "output the runner using that environment" do
+      assert_match two_hours + ' /my/path/script/runner -e serious "blahblah"', @output
+    end
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'test/unit'
+
+require File.expand_path(File.dirname(__FILE__) + "/../lib/whenever")
+
+begin
+  require 'shoulda'
+rescue LoadError
+  warn 'To test Whenever you need the shoulda gem:'
+  warn '$ sudo gem install thoughtbot-shoulda'
+  exit(1)
+end
+
+begin
+  require 'mocha'
+rescue LoadError
+  warn 'To test Whenever you need the mocha gem:'
+  warn '$ sudo gem install mocha'
+  exit(1)
+end
+
+
+module TestExtensions
+  
+  def two_hours
+    "0 0,2,4,6,8,10,12,14,16,18,20,22 * * *"
+  end
+  
+end
+
+class Test::Unit::TestCase
+  include TestExtensions
+end

data/whenever.gemspec

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{whenever}
+  s.version = "0.1.5.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Javan Makhmali"]
+  s.date = %q{2009-02-19}
+  s.description = %q{Provides clean ruby syntax for defining messy cron jobs and running them Whenever.}
+  s.email = %q{javan@javan.us}
+  s.executables = ["whenever", "wheneverize"]
+  s.extra_rdoc_files = ["bin/whenever", "bin/wheneverize", "CHANGELOG.rdoc", "lib/base.rb", "lib/job_list.rb", "lib/job_types/default.rb", "lib/job_types/rake_task.rb", "lib/job_types/runner.rb", "lib/outputs/cron.rb", "lib/version.rb", "lib/whenever.rb", "README.rdoc"]
+  s.files = ["bin/whenever", "bin/wheneverize", "CHANGELOG.rdoc", "lib/base.rb", "lib/job_list.rb", "lib/job_types/default.rb", "lib/job_types/rake_task.rb", "lib/job_types/runner.rb", "lib/outputs/cron.rb", "lib/version.rb", "lib/whenever.rb", "Manifest", "Rakefile", "README.rdoc", "test/cron_test.rb", "test/output_command_test.rb", "test/output_env_test.rb", "test/output_rake_test.rb", "test/output_runner_test.rb", "test/test_helper.rb", "whenever.gemspec"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/javan/whenever}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Whenever", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{whenever}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Provides clean ruby syntax for defining messy cron jobs and running them Whenever.}
+  s.test_files = ["test/cron_test.rb", "test/output_command_test.rb", "test/output_env_test.rb", "test/output_rake_test.rb", "test/output_runner_test.rb", "test/test_helper.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<chronic>, [">= 0.2.3"])
+      s.add_runtime_dependency(%q<activesupport>, [">= 1.3.0"])
+    else
+      s.add_dependency(%q<chronic>, [">= 0.2.3"])
+      s.add_dependency(%q<activesupport>, [">= 1.3.0"])
+    end
+  else
+    s.add_dependency(%q<chronic>, [">= 0.2.3"])
+    s.add_dependency(%q<activesupport>, [">= 1.3.0"])
+  end
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: andrewtimberlake-whenever
+version: !ruby/object:Gem::Version 
+  version: 0.1.5.1
+platform: ruby
+authors: 
+- Javan Makhmali
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-19 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: chronic
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.0
+    version: 
+description: Provides clean ruby syntax for defining messy cron jobs and running them Whenever.
+email: javan@javan.us
+executables: 
+- whenever
+- wheneverize
+extensions: []
+
+extra_rdoc_files: 
+- bin/whenever
+- bin/wheneverize
+- CHANGELOG.rdoc
+- lib/base.rb
+- lib/job_list.rb
+- lib/job_types/default.rb
+- lib/job_types/rake_task.rb
+- lib/job_types/runner.rb
+- lib/outputs/cron.rb
+- lib/version.rb
+- lib/whenever.rb
+- README.rdoc
+files: 
+- bin/whenever
+- bin/wheneverize
+- CHANGELOG.rdoc
+- lib/base.rb
+- lib/job_list.rb
+- lib/job_types/default.rb
+- lib/job_types/rake_task.rb
+- lib/job_types/runner.rb
+- lib/outputs/cron.rb
+- lib/version.rb
+- lib/whenever.rb
+- Manifest
+- Rakefile
+- README.rdoc
+- test/cron_test.rb
+- test/output_command_test.rb
+- test/output_env_test.rb
+- test/output_rake_test.rb
+- test/output_runner_test.rb
+- test/test_helper.rb
+- whenever.gemspec
+has_rdoc: true
+homepage: http://github.com/javan/whenever
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Whenever
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: whenever
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Provides clean ruby syntax for defining messy cron jobs and running them Whenever.
+test_files: 
+- test/cron_test.rb
+- test/output_command_test.rb
+- test/output_env_test.rb
+- test/output_rake_test.rb
+- test/output_runner_test.rb
+- test/test_helper.rb