whenever 0.9.2 → 0.10.0

data/lib/whenever/cron.rb

@@ -3,16 +3,20 @@ require 'chronic'
 module Whenever
   module Output
     class Cron
+      DAYS = %w(sun mon tue wed thu fri sat)
+      MONTHS = %w(jan feb mar apr may jun jul aug sep oct nov dec)
       KEYWORDS = [:reboot, :yearly, :annually, :monthly, :weekly, :daily, :midnight, :hourly]
-      REGEX = /^(@(#{KEYWORDS.join '|'})|.+\s+.+\s+.+\s+.+\s+.+.?)$/
+      REGEX = /^(@(#{KEYWORDS.join '|'})|((\*?[\d\/,\-]*)\s){3}(\*?([\d\/,\-]|(#{MONTHS.join '|'}))*\s)(\*?([\d\/,\-]|(#{DAYS.join '|'}))*))$/i
 
       attr_accessor :time, :task
 
-      def initialize(time = nil, task = nil, at = nil)
+      def initialize(time = nil, task = nil, at = nil, options = {})
+        chronic_options = options[:chronic_options] || {}
+
         @at_given = at
         @time = time
         @task = task
-        @at   = at.is_a?(String) ? (Chronic.parse(at) || 0) : (at || 0)
+        @at   = at.is_a?(String) ? (Chronic.parse(at, chronic_options) || 0) : (at || 0)
       end
 
       def self.enumerate(item, detect_cron = true)
@@ -30,10 +34,10 @@ module Whenever
         items
       end
 
-      def self.output(times, job)
+      def self.output(times, job, options = {})
         enumerate(times).each do |time|
           enumerate(job.at, false).each do |at|
-            yield new(time, job.output, at).output
+            yield new(time, job.output, at, options).output
           end
         end
       end
@@ -43,8 +47,9 @@ module Whenever
       end
 
       def time_in_cron_syntax
+        @time = @time.to_i if @time.is_a?(Numeric) # Compatibility with `1.day` format using ruby 2.3 and activesupport
         case @time
-          when REGEX  then @time # raw cron sytax given
+          when REGEX  then @time # raw cron syntax given
           when Symbol then parse_symbol
           when String then parse_as_string
           else parse_time
@@ -53,18 +58,18 @@ module Whenever
 
     protected
       def day_given?
-        months = %w(jan feb mar apr may jun jul aug sep oct nov dec)
-        @at_given.is_a?(String) && months.any? { |m| @at_given.downcase.index(m) }
+        @at_given.is_a?(String) && (MONTHS.any? { |m| @at_given.downcase.index(m) } || @at_given[/\d\/\d/])
       end
 
       def parse_symbol
         shortcut = case @time
           when *KEYWORDS then "@#{@time}" # :reboot => '@reboot'
-          when :year     then 12.months
-          when :day      then 1.day
-          when :month    then 1.month
-          when :week     then 1.week
-          when :hour     then 1.hour
+          when :year     then Whenever.seconds(1, :year)
+          when :day      then Whenever.seconds(1, :day)
+          when :month    then Whenever.seconds(1, :month)
+          when :week     then Whenever.seconds(1, :week)
+          when :hour     then Whenever.seconds(1, :hour)
+          when :minute   then Whenever.seconds(1, :minute)
         end
 
         if shortcut.is_a?(Numeric)
@@ -84,22 +89,24 @@ module Whenever
       def parse_time
         timing = Array.new(5, '*')
         case @time
-          when 0.seconds...1.minute
+          when Whenever.seconds(0, :seconds)...Whenever.seconds(1, :minute)
             raise ArgumentError, "Time must be in minutes or higher"
-          when 1.minute...1.hour
+          when Whenever.seconds(1, :minute)...Whenever.seconds(1, :hour)
             minute_frequency = @time / 60
             timing[0] = comma_separated_timing(minute_frequency, 59, @at || 0)
-          when 1.hour...1.day
+          when Whenever.seconds(1, :hour)...Whenever.seconds(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
+            raise ArgumentError, "Minute must be between 0-59, #{timing[0]} given" unless (0..59).include?(timing[0])
+          when Whenever.seconds(1, :day)...Whenever.seconds(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
+            raise ArgumentError, "Hour must be between 0-23, #{timing[1]} given" unless (0..23).include?(timing[1])
+          when Whenever.seconds(1, :month)...Whenever.seconds(1, :year)
+            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] = if @at.is_a?(Time)
@@ -108,6 +115,21 @@ module Whenever
               @at.zero? ? 1 : @at
             end
             timing[3] = comma_separated_timing(month_frequency, 12, 1)
+            raise ArgumentError, "Day must be between 1-31, #{timing[2]} given" unless (1..31).include?(timing[2])
+          when Whenever.seconds(1, :year)
+            timing[0] = @at.is_a?(Time) ? @at.min  : 0
+            timing[1] = @at.is_a?(Time) ? @at.hour : 0
+            timing[2] = if @at.is_a?(Time)
+              day_given? ? @at.day : 1
+            else
+              1
+            end
+            timing[3] = if @at.is_a?(Time)
+              day_given? ? @at.month : 1
+            else
+              @at.zero? ? 1 : @at
+            end
+            raise ArgumentError, "Month must be between 1-12, #{timing[3]} given" unless (1..12).include?(timing[3])
           else
             return parse_as_string
         end
@@ -125,7 +147,7 @@ module Whenever
         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|
+        DAYS.each_with_index do |day, i|
           return (timing << i) * " " if string.downcase.index(day)
         end
 
@@ -133,7 +155,7 @@ module Whenever
       end
 
       def comma_separated_timing(frequency, max, start = 0)
-        return start     if frequency.blank? || frequency.zero?
+        return start     if frequency.nil? || frequency == "" || frequency.zero?
         return '*'       if frequency == 1
         return frequency if frequency > (max * 0.5).ceil
 

data/lib/whenever/job.rb

@@ -2,14 +2,15 @@ require 'shellwords'
 
 module Whenever
   class Job
-    attr_reader :at, :roles
+    attr_reader :at, :roles, :mailto
 
     def initialize(options = {})
       @options = options
       @at                               = options.delete(:at)
       @template                         = options.delete(:template)
+      @mailto                           = options.fetch(:mailto, :default_mailto)
       @job_template                     = options.delete(:job_template) || ":job"
-      @roles                            = Array.wrap(options.delete(:roles))
+      @roles                            = Array(options.delete(:roles))
       @options[:output]                 = options.has_key?(:output) ? Whenever::Output::Redirection.new(options[:output]).to_s : ''
       @options[:environment_variable] ||= "RAILS_ENV"
       @options[:environment]          ||= :production
@@ -40,7 +41,7 @@ module Whenever
         else
           option
         end
-      end.squish
+      end.gsub(/\s+/m, " ").strip
     end
 
     def escape_single_quotes(str)

data/lib/whenever/job_list.rb

@@ -30,10 +30,17 @@ module Whenever
       return if @pre_set_variables[variable]
 
       instance_variable_set("@#{variable}".to_sym, value)
-      self.class.send(:attr_reader, variable.to_sym)
       @set_variables[variable] = value
     end
 
+    def method_missing(name, *args, &block)
+      @set_variables.has_key?(name) ? @set_variables[name] : super
+    end
+
+    def self.respond_to?(name, include_private = false)
+      @set_variables.has_key?(name) || super
+    end
+
     def env(variable, value)
       @env[variable.to_s] = value
     end
@@ -45,18 +52,21 @@ module Whenever
     end
 
     def job_type(name, template)
-      class_eval do
+      singleton_class.class_eval do
         define_method(name) do |task, *args|
           options = { :task => task, :template => template }
           options.merge!(args[0]) if args[0].is_a? Hash
 
+          options[:mailto] ||= @options.fetch(:mailto, :default_mailto)
+
           # :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)
 
-          @jobs[@current_time_scope] ||= []
-          @jobs[@current_time_scope] << Whenever::Job.new(@options.merge(@set_variables).merge(options))
+          @jobs[options.fetch(:mailto)] ||= {}
+          @jobs[options.fetch(:mailto)][@current_time_scope] ||= []
+          @jobs[options.fetch(:mailto)][@current_time_scope] << Whenever::Job.new(@options.merge(@set_variables).merge(options))
         end
       end
     end
@@ -73,13 +83,13 @@ module Whenever
     # Only works for setting values as strings.
     #
     def pre_set(variable_string = nil)
-      return if variable_string.blank?
+      return if variable_string.nil? || variable_string == ""
 
       pairs = variable_string.split('&')
       pairs.each do |pair|
         next unless pair.index('=')
         variable, value = *pair.split('=')
-        unless variable.blank? || value.blank?
+        unless variable.nil? || variable == "" || value.nil? || value == ""
           variable = variable.strip.to_sym
           set(variable, value.strip)
           @pre_set_variables[variable] = value
@@ -92,7 +102,7 @@ module Whenever
 
       output = []
       @env.each do |key, val|
-        output << "#{key}=#{val.blank? ? '""' : val}\n"
+        output << "#{key}=#{val.nil? || val == "" ? '""' : val}\n"
       end
       output << "\n"
 
@@ -125,31 +135,51 @@ module Whenever
       entries.map { |entry| entry.join(' ') }
     end
 
+    def cron_jobs_of_time(time, jobs)
+      shortcut_jobs, regular_jobs = [], []
+
+      jobs.each do |job|
+        next unless roles.empty? || roles.any? do |r|
+          job.has_role?(r)
+        end
+        Whenever::Output::Cron.output(time, job, :chronic_options => @chronic_options) do |cron|
+          cron << "\n\n"
+
+          if cron[0,1] == "@"
+            shortcut_jobs << cron
+          else
+            regular_jobs << cron
+          end
+        end
+      end
+
+      shortcut_jobs.join + combine(regular_jobs).join
+    end
+
     def cron_jobs
       return if @jobs.empty?
 
-      shortcut_jobs = []
-      regular_jobs = []
+      output = []
 
-      output_all = roles.empty?
-      @jobs.each do |time, jobs|
-        jobs.each do |job|
-          next unless output_all || roles.any? do |r|
-            job.has_role?(r)
-          end
-          Whenever::Output::Cron.output(time, job) do |cron|
-            cron << "\n\n"
+      # jobs with default mailto's must be output before the ones with non-default mailto's.
+      @jobs.delete(:default_mailto) { Hash.new }.each do |time, jobs|
+        output << cron_jobs_of_time(time, jobs)
+      end
 
-            if cron.starts_with?("@")
-              shortcut_jobs << cron
-            else
-              regular_jobs << cron
-            end
-          end
+      @jobs.each do |mailto, time_and_jobs|
+        output_jobs = []
+
+        time_and_jobs.each do |time, jobs|
+          output_jobs << cron_jobs_of_time(time, jobs)
         end
+
+        output_jobs.reject! { |output_job| output_job.empty? }
+
+        output << "MAILTO=#{mailto}\n\n" unless output_jobs.empty?
+        output << output_jobs
       end
 
-      shortcut_jobs.join + combine(regular_jobs).join
+      output.join
     end
   end
 end

data/lib/whenever/numeric.rb

@@ -0,0 +1,13 @@
+class Numeric
+  def respond_to?(method, include_private = false)
+    super || Whenever::NumericSeconds.public_method_defined?(method)
+  end
+
+  def method_missing(method, *args, &block)
+    if Whenever::NumericSeconds.public_method_defined?(method)
+      Whenever::NumericSeconds.new(self).send(method)
+    else
+      super
+    end
+  end
+end

data/lib/whenever/numeric_seconds.rb

@@ -0,0 +1,48 @@
+module Whenever
+  class NumericSeconds
+    attr_reader :number
+
+    def self.seconds(number, units)
+      new(number).send(units)
+    end
+
+    def initialize(number)
+      @number = number.to_i
+    end
+
+    def seconds
+      number
+    end
+    alias :second :seconds
+
+    def minutes
+      number * 60
+    end
+    alias :minute :minutes
+
+    def hours
+      number * 3_600
+    end
+    alias :hour :hours
+
+    def days
+      number * 86_400
+    end
+    alias :day :days
+
+    def weeks
+      number * 604_800
+    end
+    alias :week :weeks
+
+    def months
+      number * 2_592_000
+    end
+    alias :month :months
+
+    def years
+      number * 31_557_600
+    end
+    alias :year :years
+  end
+end

data/lib/whenever/os.rb

@@ -0,0 +1,7 @@
+module Whenever
+  module OS
+    def self.solaris?
+      (/solaris/ =~ RUBY_PLATFORM)
+    end
+  end
+end

data/lib/whenever/setup.rb

@@ -5,6 +5,10 @@ set :environment, "production"
 # Path defaults to the directory `whenever` was run from
 set :path, Whenever.path
 
+# Custom Chronic configuration for time parsing, empty by default
+# Full list of options at: https://github.com/mojombo/chronic/blob/master/lib/chronic/parser.rb
+set :chronic_options, {}
+
 # All jobs are wrapped in this template.
 # http://blog.scoutapp.com/articles/2010/09/07/rvm-and-cron-in-production
 set :job_template, "/bin/bash -l -c ':job'"
@@ -23,4 +27,4 @@ set :bundle_command, Whenever.bundler? ? "bundle exec" : ""
 job_type :command, ":task :output"
 job_type :rake,    "cd :path && :environment_variable=:environment :bundle_command rake :task --silent :output"
 job_type :script,  "cd :path && :environment_variable=:environment :bundle_command script/:task :output"
-job_type :runner,  "cd :path && :runner_command -e :environment ':task' :output"
+job_type :runner,  "cd :path && :bundle_command :runner_command -e :environment ':task' :output"

data/lib/whenever/version.rb

@@ -1,3 +1,3 @@
 module Whenever
-  VERSION = '0.9.2'
+  VERSION = '0.10.0'
 end

data/lib/whenever.rb

@@ -1,33 +1,34 @@
-require 'thread'
-require 'active_support/all'
+require 'whenever/numeric'
+require 'whenever/numeric_seconds'
+require 'whenever/job_list'
+require 'whenever/job'
+require 'whenever/command_line'
+require 'whenever/cron'
+require 'whenever/output_redirection'
+require 'whenever/os'
 
 module Whenever
-  autoload :JobList,           'whenever/job_list'
-  autoload :Job,               'whenever/job'
-  autoload :CommandLine,       'whenever/command_line'
-
-  module Output
-    autoload :Cron,        'whenever/cron'
-    autoload :Redirection, 'whenever/output_redirection'
-  end
-
   def self.cron(options)
     Whenever::JobList.new(options).generate_cron_output
   end
 
+  def self.seconds(number, units)
+    Whenever::NumericSeconds.seconds(number, units)
+  end
+
   def self.path
     Dir.pwd
   end
 
   def self.bin_rails?
-    File.exists?(File.join(path, 'bin', 'rails'))
+    File.exist?(File.join(path, 'bin', 'rails'))
   end
 
   def self.script_rails?
-    File.exists?(File.join(path, 'script', 'rails'))
+    File.exist?(File.join(path, 'script', 'rails'))
   end
 
   def self.bundler?
-    File.exists?(File.join(path, 'Gemfile'))
+    File.exist?(File.join(path, 'Gemfile'))
   end
 end