sundbp-whenever 0.4.1

data/lib/whenever/job_list.rb

@@ -0,0 +1,161 @@
+module Whenever
+  class JobList
+  
+    def initialize(options)
+      @jobs = Hash.new
+      @env  = Hash.new
+      
+      case options
+        when String
+          config = options
+        when Hash
+          config = if options[:string]
+            options[:string]
+          elsif options[:file]
+            File.read(options[:file])
+          end
+          pre_set(options[:set])
+      end
+
+      eval(config)
+    end
+    
+    def set(variable, value)
+      return if instance_variable_defined?("@#{variable}".to_sym)
+      
+      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 = {})
+      # :cron_log was an old option for output redirection, it remains for backwards compatibility
+      options[:output] = (options[:cron_log] || @cron_log) if defined?(@cron_log) || options.has_key?(:cron_log)
+      # :output is the newer, more flexible option.
+      options[:output] = @output if defined?(@output) && !options.has_key?(:output)
+      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
+      set_path_environment_variable
+      
+      [environment_variables, cron_jobs].compact.join
+    end
+    
+  private
+    
+    #
+    # Takes a string like: "variable1=something&variable2=somethingelse"
+    # and breaks it into variable/value pairs. Used for setting variables at runtime from the command line.
+    # Only works for setting values as strings.
+    #
+    def pre_set(variable_string = nil)
+      return if variable_string.blank?
+      
+      pairs = variable_string.split('&')
+      pairs.each do |pair|
+        next unless pair.index('=')
+        variable, value = *pair.split('=')
+        set(variable.strip, value.strip) unless variable.blank? || value.blank?
+      end
+    end
+    
+    def set_path_environment_variable
+      return if path_should_not_be_set_automatically?
+      @env[:PATH] = read_path unless read_path.blank?
+    end
+    
+    def read_path
+      ENV['PATH'] if ENV
+    end
+    
+    def path_should_not_be_set_automatically?
+      @set_path_automatically === false || @env[:PATH] || @env["PATH"]
+    end
+  
+    def environment_variables
+      return if @env.empty?
+      
+      output = []
+      @env.each do |key, val|
+        output << "#{key}=#{val}\n"
+      end
+      output << "\n"
+      
+      output.join
+    end
+    
+    #
+    # Takes the standard cron output that Whenever generates and finds
+    # similar entries that can be combined. For example: If a job should run
+    # at 3:02am and 4:02am, instead of creating two jobs this method combines
+    # them into one that runs on the 2nd minute at the 3rd and 4th hour.
+    #
+    def combine(entries)
+      entries.map! { |entry| entry.split(/ +/, 6) }
+      0.upto(4) do |f|
+        (entries.length-1).downto(1) do |i|
+          next if entries[i][f] == '*'
+          comparison = entries[i][0...f] + entries[i][f+1..-1]
+          (i-1).downto(0) do |j|
+            next if entries[j][f] == '*'
+            if comparison == entries[j][0...f] + entries[j][f+1..-1]
+              entries[j][f] += ',' + entries[i][f]
+              entries.delete_at(i)
+              break
+            end
+          end
+        end
+      end
+
+      entries.map { |entry| entry.join(' ') }
+    end
+
+    def cron_jobs
+      return if @jobs.empty?
+      
+      shortcut_jobs = []
+      regular_jobs = []
+      
+      @jobs.each do |time, jobs|
+        jobs.each do |job|
+          Whenever::Output::Cron.output(time, job) do |cron|
+            cron << "\n\n"
+            
+            if cron.starts_with?("@")
+              shortcut_jobs << cron
+            else
+              regular_jobs << cron
+            end
+          end
+        end
+      end
+
+      shortcut_jobs.join + combine(regular_jobs).join
+    end
+    
+  end
+end

data/lib/whenever/job_types/default.rb

@@ -0,0 +1,27 @@
+module Whenever
+  module Job
+    class Default
+      
+      attr_accessor :task, :at, :output, :output_redirection
+    
+      def initialize(options = {})
+        @task               = options[:task]
+        @at                 = options[:at]
+        @output_redirection = options.has_key?(:output) ? options[:output] : :not_set
+        @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/whenever/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/whenever/job_types/runner.rb

@@ -0,0 +1,16 @@
+module Whenever
+  module Job
+    class Runner < Whenever::Job::Default
+
+      def output
+        path_required
+        if File.exist? File.join(@path, 'script', 'rails')
+          %Q(#{File.join(@path, 'script', 'rails')} runner -e #{@environment} #{task.inspect})
+        else
+          %Q(#{File.join(@path, 'script', 'runner')} -e #{@environment} #{task.inspect})
+        end
+      end
+      
+    end
+  end
+end

data/lib/whenever/outputs/cron.rb

@@ -0,0 +1,139 @@
+module Whenever
+  module Output
+
+    class Cron
+
+      attr_accessor :time, :task
+
+      def initialize(time = nil, task = nil, at = nil, output_redirection = nil)
+        @time = time
+        @task = task
+        @at   = at.is_a?(String) ? (Chronic.parse(at) || 0) : (at || 0)
+        @output_redirection = output_redirection
+      end
+
+      def self.enumerate(item)
+        if item and item.is_a?(String)
+          items = item.split(',')
+        else
+          items = item
+          items = [items] unless items and items.respond_to?(:each)
+        end
+        items
+      end
+
+      def self.output(times, job)
+        enumerate(times).each do |time|
+          enumerate(job.at).each do |at|
+            yield new(time, job.output, at, job.output_redirection).output
+          end
+        end
+      end
+      
+      def output
+        [time_in_cron_syntax, task, output_redirection].compact.join(' ').strip
+      end
+
+      def time_in_cron_syntax
+        case @time
+          when Symbol then parse_symbol
+          when String then parse_as_string
+          else parse_time
+        end
+      end
+      
+      def output_redirection
+        OutputRedirection.new(@output_redirection).to_s unless @output_redirection == :not_set
+      end
+
+    protected
+
+      def parse_symbol
+        shortcut = 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'
+        end
+        
+        if shortcut
+          if @at > 0
+            raise ArgumentError, "You cannot specify an ':at' when using the shortcuts for times."
+          else
+            return shortcut
+          end
+        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
+
+        timing = Array.new(4, '*')
+        timing[0] = @at.is_a?(Time) ? @at.min  : 0
+        timing[1] = @at.is_a?(Time) ? @at.hour : 0
+
+        return (timing << '1-5') * " " if string.downcase.index('weekday')
+        return (timing << '6,0') * " " if string.downcase.index('weekend')
+
+        %w(sun mon tue wed thu fri sat).each_with_index do |day, i|
+          return (timing << i) * " " 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/whenever/outputs/cron/output_redirection.rb

@@ -0,0 +1,54 @@
+module Whenever
+  module Output
+    class Cron
+      class OutputRedirection
+        
+        def initialize(output)
+          @output = output
+        end
+        
+        def to_s
+          return '' unless defined?(@output)
+          case @output
+            when String   then redirect_from_string
+            when Hash     then redirect_from_hash
+            when NilClass then ">> /dev/null 2>&1"
+            else ''
+          end 
+        end
+        
+      protected
+        
+        def stdout
+          return unless @output.has_key?(:standard)
+          @output[:standard].nil? ? '/dev/null' : @output[:standard]
+        end
+
+        def stderr
+          return unless @output.has_key?(:error)
+          @output[:error].nil? ? '/dev/null' : @output[:error]
+        end
+
+        def redirect_from_hash
+          case
+            when stdout == '/dev/null' && stderr == '/dev/null'
+              ">> /dev/null 2>&1"
+            when stdout && stderr
+              ">> #{stdout} 2> #{stderr}"
+            when stderr
+              "2> #{stderr}"
+            when stdout
+              ">> #{stdout}"
+            else
+              ''
+          end
+        end
+
+        def redirect_from_string
+          ">> #{@output} 2>&1"
+        end
+        
+      end
+    end
+  end
+end

data/lib/whenever/version.rb

@@ -0,0 +1,3 @@
+module Whenever
+  VERSION = '0.4.1' 
+end unless defined?(Whenever::VERSION)

data/test/command_line_test.rb

@@ -0,0 +1,101 @@
+require File.expand_path(File.dirname(__FILE__) + "/test_helper")
+
+class CommandLineTest < Test::Unit::TestCase
+  
+  context "A command line write" do
+    setup do
+      File.expects(:exists?).with('config/schedule.rb').returns(true)
+      @command = Whenever::CommandLine.new(:write => true, :identifier => 'My identifier')
+      @task = "#{two_hours} /my/command"
+      Whenever.expects(:cron).returns(@task)
+    end
+
+    should "output the cron job with identifier blocks" do
+      output = <<-EXPECTED
+# Begin Whenever generated tasks for: My identifier
+#{@task}
+# End Whenever generated tasks for: My identifier
+EXPECTED
+      
+      assert_equal output, @command.send(:whenever_cron)
+    end
+    
+    should "write the crontab when run" do
+      @command.expects(:write_crontab).returns(true)
+      assert @command.run
+    end
+  end
+  
+  context "A command line update" do
+    setup do
+      File.expects(:exists?).with('config/schedule.rb').returns(true)
+      @command = Whenever::CommandLine.new(:update => true, :identifier => 'My identifier')
+      @task = "#{two_hours} /my/command"
+      Whenever.expects(:cron).returns(@task)
+    end
+
+    should "add the cron to the end of the file if there is no existing identifier block" do
+      existing = '# Existing crontab'
+      @command.expects(:read_crontab).at_least_once.returns(existing)
+      
+      new_cron = <<-EXPECTED
+#{existing}
+
+# Begin Whenever generated tasks for: My identifier
+#{@task}
+# End Whenever generated tasks for: My identifier
+EXPECTED
+      
+      assert_equal new_cron, @command.send(:updated_crontab)
+      
+      @command.expects(:write_crontab).with(new_cron).returns(true)
+      assert @command.run
+    end
+    
+    should "replace an existing block if the identifier matches" do
+      existing = <<-EXISTING_CRON
+# Something
+
+# Begin Whenever generated tasks for: My identifier
+My whenever job that was already here
+# End Whenever generated tasks for: My identifier
+
+# Begin Whenever generated tasks for: Other identifier
+This shouldn't get replaced
+# End Whenever generated tasks for: Other identifier
+EXISTING_CRON
+
+      @command.expects(:read_crontab).at_least_once.returns(existing)
+      
+      new_cron = <<-NEW_CRON
+# Something
+
+# Begin Whenever generated tasks for: My identifier
+#{@task}
+# End Whenever generated tasks for: My identifier
+
+# Begin Whenever generated tasks for: Other identifier
+This shouldn't get replaced
+# End Whenever generated tasks for: Other identifier
+NEW_CRON
+      
+      assert_equal new_cron, @command.send(:updated_crontab)
+      
+      @command.expects(:write_crontab).with(new_cron).returns(true)
+      assert @command.run
+    end
+  end
+  
+  context "A command line update with no identifier" do
+    setup do
+      File.expects(:exists?).with('config/schedule.rb').returns(true)
+      Whenever::CommandLine.any_instance.expects(:default_identifier).returns('DEFAULT')
+      @command = Whenever::CommandLine.new(:update => true, :file => @file)
+    end
+
+    should "use the default identifier" do
+      assert_equal "Whenever generated tasks for: DEFAULT", @command.send(:comment_base)
+    end
+  end
+  
+end