super-clean-box 0.0.1

data/whenever-1.1.2/lib/whenever/job_list.rb

@@ -0,0 +1,186 @@
+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)
+      @set_variables[variable] = value
+    end
+
+    def method_missing(name, *args, &block)
+      @set_variables.has_key?(name) ? @set_variables[name] : super
+    end
+
+    def respond_to?(name, include_private = false)
+      @set_variables.has_key?(name) || super
+    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
+
+          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[options.fetch(:mailto)] ||= {}
+          @jobs[options.fetch(:mailto)][@current_time_scope] ||= []
+          @jobs[options.fetch(:mailto)][@current_time_scope] << Whenever::Job.new(@set_variables.merge(@options).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_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"
+          cron = (job.description.strip + "\n").gsub(/^(.*)$/, '# \1') + cron unless job.description.to_s.empty?
+
+          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?
+
+      output = []
+
+      # 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
+
+      @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
+
+      output.join
+    end
+  end
+end

data/whenever-1.1.2/lib/whenever/numeric.rb

@@ -0,0 +1,13 @@
+Numeric.class_eval do
+  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/whenever-1.1.2/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/whenever-1.1.2/lib/whenever/os.rb

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

data/whenever-1.1.2/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

data/whenever-1.1.2/lib/whenever/setup.rb

@@ -0,0 +1,31 @@
+# Environment variable defaults to RAILS_ENV
+set :environment_variable, "RAILS_ENV"
+# Environment defaults to the value of RAILS_ENV in the current environment if
+# it's set or production otherwise
+set :environment, ENV.fetch("RAILS_ENV", "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'"
+
+set :runner_command, case
+  when Whenever.bin_rails?
+    "bin/rails runner"
+  when Whenever.script_rails?
+    "script/rails runner"
+  else
+    "script/runner"
+  end
+
+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 && :bundle_command :runner_command -e :environment ':task' :output"

data/whenever-1.1.2/lib/whenever/version.rb

@@ -0,0 +1,3 @@
+module Whenever
+  VERSION = '1.1.2'
+end

data/whenever-1.1.2/lib/whenever.rb

@@ -0,0 +1,42 @@
+require "whenever/version"
+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
+  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.exist?(File.join(path, 'bin', 'rails'))
+  end
+
+  def self.script_rails?
+    File.exist?(File.join(path, 'script', 'rails'))
+  end
+
+  def self.bundler?
+    File.exist?(File.join(path, 'Gemfile'))
+  end
+
+  def self.update_cron options
+    o = { 'update' => true, 'console' => false}
+    o.merge! options if options
+    Whenever::CommandLine.execute o
+  end
+
+end