whenever-benlangfeld 0.9.5

data/lib/whenever/cron.rb

@@ -0,0 +1,153 @@
+require 'chronic'
+
+module Whenever
+  module Output
+    class Cron
+      KEYWORDS = [:reboot, :yearly, :annually, :monthly, :weekly, :daily, :midnight, :hourly]
+      REGEX = /^(@(#{KEYWORDS.join '|'})|((\*?[\d\/,\-]*)\s*){5})$/
+
+      attr_accessor :time, :task
+
+      def initialize(time = nil, task = nil, at = nil)
+        @at_given = at
+        @time = time
+        @task = task
+        @at   = at.is_a?(String) ? (Chronic.parse(at) || 0) : (at || 0)
+      end
+
+      def self.enumerate(item, detect_cron = true)
+        if item and item.is_a?(String)
+          items =
+            if detect_cron && item =~ REGEX
+              [item]
+            else
+              item.split(',')
+            end
+        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, false).each do |at|
+            yield new(time, job.output, at).output
+          end
+        end
+      end
+
+      def output
+        [time_in_cron_syntax, task].compact.join(' ').strip
+      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 syntax given
+          when Symbol then parse_symbol
+          when String then parse_as_string
+          else parse_time
+        end
+      end
+
+    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) }
+      end
+
+      def parse_symbol
+        shortcut = case @time
+          when *KEYWORDS then "@#{@time}" # :reboot => '@reboot'
+          when :year     then Whenever.seconds(12, :months)
+          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)
+        end
+
+        if shortcut.is_a?(Numeric)
+          @time = shortcut
+          parse_time
+        elsif shortcut
+          if @at.is_a?(Time) || (@at.is_a?(Numeric) && @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 Whenever.seconds(0, :seconds)...Whenever.seconds(1, :minute)
+            raise ArgumentError, "Time must be in minutes or higher"
+          when Whenever.seconds(1, :minute)...Whenever.seconds(1, :hour)
+            minute_frequency = @time / 60
+            timing[0] = comma_separated_timing(minute_frequency, 59, @at || 0)
+          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 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 Whenever.seconds(1, :month)..Whenever.seconds(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] = if @at.is_a?(Time)
+              day_given? ? @at.day : 1
+            else
+              @at.zero? ? 1 : @at
+            end
+            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.nil? || frequency == "" || 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/job.rb

@@ -0,0 +1,54 @@
+require 'shellwords'
+
+module Whenever
+  class Job
+    attr_reader :at, :roles
+
+    def initialize(options = {})
+      @options = options
+      @at                               = options.delete(:at)
+      @template                         = options.delete(:template)
+      @job_template                     = options.delete(:job_template) || ":job"
+      @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
+      @options[:path]                   = Shellwords.shellescape(@options[:path] || Whenever.path)
+    end
+
+    def output
+      job = process_template(@template, @options)
+      out = process_template(@job_template, @options.merge(:job => job))
+      out.gsub(/%/, '\%')
+    end
+
+    def has_role?(role)
+      roles.empty? || roles.include?(role)
+    end
+
+  protected
+
+    def process_template(template, options)
+      template.gsub(/:\w+/) do |key|
+        before_and_after = [$`[-1..-1], $'[0..0]]
+        option = options[key.sub(':', '').to_sym] || key
+
+        if before_and_after.all? { |c| c == "'" }
+          escape_single_quotes(option)
+        elsif before_and_after.all? { |c| c == '"' }
+          escape_double_quotes(option)
+        else
+          option
+        end
+      end.gsub(/\s+/m, " ").strip
+    end
+
+    def escape_single_quotes(str)
+      str.gsub(/'/) { "'\\''" }
+    end
+
+    def escape_double_quotes(str)
+      str.gsub(/"/) { '\"' }
+    end
+  end
+end

data/lib/whenever/job_list.rb

@@ -0,0 +1,155 @@
+module Whenever
+  class JobList
+    attr_reader :roles
+
+    def initialize(options)
+      @jobs, @env, @set_variables, @pre_set_variables = {}, {}, {}, {}
+
+      if options.is_a? String
+        options = { :string => options }
+      end
+
+      pre_set(options[:set])
+
+      @roles = options[:roles] || []
+
+      setup_file = File.expand_path('../setup.rb', __FILE__)
+      setup = File.read(setup_file)
+      schedule = if options[:string]
+        options[:string]
+      elsif options[:file]
+        File.read(options[:file])
+      end
+
+      instance_eval(setup, setup_file)
+      instance_eval(schedule, options[:file] || '<eval>')
+    end
+
+    def set(variable, value)
+      variable = variable.to_sym
+      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 env(variable, value)
+      @env[variable.to_s] = value
+    end
+
+    def every(frequency, options = {})
+      @current_time_scope = frequency
+      @options = options
+      yield
+    end
+
+    def job_type(name, template)
+      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
+
+          # :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))
+        end
+      end
+    end
+
+    def generate_cron_output
+      [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.nil? || variable_string == ""
+
+      pairs = variable_string.split('&')
+      pairs.each do |pair|
+        next unless pair.index('=')
+        variable, value = *pair.split('=')
+        unless variable.nil? || variable == "" || value.nil? || value == ""
+          variable = variable.strip.to_sym
+          set(variable, value.strip)
+          @pre_set_variables[variable] = value
+        end
+      end
+    end
+
+    def environment_variables
+      return if @env.empty?
+
+      output = []
+      @env.each do |key, val|
+        output << "#{key}=#{val.nil? || val == "" ? '""' : 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 = []
+
+      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"
+
+            if cron[0,1] == "@"
+              shortcut_jobs << cron
+            else
+              regular_jobs << cron
+            end
+          end
+        end
+      end
+
+      shortcut_jobs.join + combine(regular_jobs).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/output_redirection.rb

@@ -0,0 +1,57 @@
+module Whenever
+  module Output
+    class Redirection
+      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"
+          when Proc     then @output.call
+          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 == '/dev/null'
+            ">> #{stdout} 2> /dev/null"
+          when stdout && stderr
+            ">> #{stdout} 2>> #{stderr}"
+          when stderr == '/dev/null'
+            "2> /dev/null"
+          when stderr
+            "2>> #{stderr}"
+          when stdout == '/dev/null'
+            "> /dev/null"
+          when stdout
+            ">> #{stdout}"
+          else
+            ''
+        end
+      end
+
+      def redirect_from_string
+        ">> #{@output} 2>&1"
+      end
+    end
+  end
+end