hyper-smart-pkg 0.0.1

data/whenever-1.1.2/lib/whenever/capistrano/v2/support.rb

@@ -0,0 +1,53 @@
+module Whenever
+  module CapistranoSupport
+    def self.load_into(capistrano_configuration)
+      capistrano_configuration.load do
+
+        def whenever_options
+          fetch(:whenever_options)
+        end
+
+        def whenever_roles
+          Array(whenever_options[:roles])
+        end
+
+        def whenever_servers
+          find_servers(whenever_options)
+        end
+
+        def whenever_server_roles
+          whenever_servers.inject({}) do |map, server|
+            map[server] = role_names_for_host(server) & whenever_roles
+            map
+          end
+        end
+
+        def whenever_prepare_for_rollback args
+          if fetch(:previous_release)
+            # rollback to the previous release's crontab
+            args[:path] = fetch(:previous_release)
+          else
+            # clear the crontab if no previous release
+            args[:path]  = fetch(:release_path)
+            args[:flags] = fetch(:whenever_clear_flags)
+          end
+          args
+        end
+
+        def whenever_run_commands(args)
+          unless [:command, :path, :flags].all? { |a| args.include?(a) }
+            raise ArgumentError, ":command, :path, & :flags are required"
+          end
+
+          whenever_server_roles.each do |server, roles|
+            roles_arg = roles.empty? ? "" : " --roles #{roles.join(',')}"
+
+            command = "cd #{args[:path]} && #{args[:command]} #{args[:flags]}#{roles_arg}"
+            run command, whenever_options.merge(:hosts => server)
+          end
+        end
+
+      end
+    end
+  end
+end

data/whenever-1.1.2/lib/whenever/capistrano/v3/tasks/whenever.rake

@@ -0,0 +1,56 @@
+namespace :whenever do
+  def setup_whenever_task(*args, &block)
+    args = Array(fetch(:whenever_command)) + args
+
+    on roles *fetch(:whenever_roles) do |host|
+      args_for_host = block_given? ? args + Array(yield(host)) : args
+      within fetch(:whenever_path) do
+        with fetch(:whenever_command_environment_variables) do
+          execute(*args_for_host)
+        end
+      end
+    end
+  end
+
+  def load_file
+    file = fetch(:whenever_load_file)
+    if file
+      "-f #{file}"
+    else
+      ''
+    end
+  end
+
+  desc "Update application's crontab entries using Whenever"
+  task :update_crontab do
+    setup_whenever_task do |host|
+      roles = host.roles_array.join(",")
+      [fetch(:whenever_update_flags), "--roles=#{roles}", load_file]
+    end
+  end
+
+  desc "Clear application's crontab entries using Whenever"
+  task :clear_crontab do
+    setup_whenever_task do |host|
+      [fetch(:whenever_clear_flags), load_file]
+    end
+  end
+
+  after "deploy:updated",  "whenever:update_crontab"
+  after "deploy:reverted", "whenever:update_crontab"
+end
+
+namespace :load do
+  task :defaults do
+    set :whenever_roles,        ->{ :db }
+    set :whenever_command,      ->{ [:bundle, :exec, :whenever] }
+    set :whenever_command_environment_variables, ->{ fetch(:default_env).merge(rails_env: fetch(:whenever_environment)) }
+    set :whenever_identifier,   ->{ fetch :application }
+    set :whenever_environment,  ->{ fetch :rails_env, fetch(:stage, "production") }
+    set :whenever_variables,    ->{ "environment=#{fetch :whenever_environment}" }
+    set :whenever_load_file,    ->{ nil }
+    set :whenever_update_flags, ->{ "--update-crontab #{fetch :whenever_identifier} --set #{fetch :whenever_variables}" }
+    set :whenever_clear_flags,  ->{ "--clear-crontab #{fetch :whenever_identifier}" }
+    set :whenever_path,         ->{ release_path }
+  end
+end

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

@@ -0,0 +1,7 @@
+require 'capistrano/version'
+
+if defined?(Capistrano::VERSION) && Gem::Version.new(Capistrano::VERSION).release >= Gem::Version.new('3.0.0')
+  load File.expand_path("../capistrano/v3/tasks/whenever.rake", __FILE__)
+else
+  require 'whenever/capistrano/v2/hooks'
+end

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

@@ -0,0 +1,171 @@
+require 'fileutils'
+
+module Whenever
+  class CommandLine
+    def self.execute(options={})
+      new(options).run
+    end
+
+    def initialize(options={})
+      @options = options
+
+      @options[:crontab_command] ||= 'crontab'
+      @options[:file]            ||= 'config/schedule.rb'
+      @options[:cut]             ||= 0
+      @options[:identifier]      ||= default_identifier
+      @options[:console]    = true if @options[:console].nil?
+
+      if !File.exist?(@options[:file]) && @options[:clear].nil?
+        warn("[fail] Can't find file: #{@options[:file]}")
+        return_or_exit(false)
+      end
+
+      if [@options[:update], @options[:write], @options[:clear]].compact.length > 1
+        warn("[fail] Can only update, write or clear. Choose one.")
+        return_or_exit(false)
+      end
+
+      unless @options[:cut].to_s =~ /[0-9]*/
+        warn("[fail] Can't cut negative lines from the crontab #{options[:cut]}")
+        return_or_exit(false)
+      end
+      @options[:cut] = @options[:cut].to_i
+
+      @timestamp = Time.now.to_s
+    end
+
+    def run
+      if @options[:update] || @options[:clear]
+        write_crontab(updated_crontab)
+      elsif @options[:write]
+        write_crontab(whenever_cron)
+      else
+        puts Whenever.cron(@options)
+        puts "## [message] Above is your schedule file converted to cron syntax; your crontab file was not updated."
+        puts "## [message] Run `whenever --help' for more options."
+        return_or_exit(true)
+      end
+    end
+
+  protected
+
+    def default_identifier
+      File.expand_path(@options[:file])
+    end
+
+    def whenever_cron
+      return '' if @options[:clear]
+      @whenever_cron ||= [comment_open, Whenever.cron(@options), comment_close].compact.join("\n") + "\n"
+    end
+
+    def read_crontab
+      return @current_crontab if instance_variable_defined?(:@current_crontab)
+
+      command = [@options[:crontab_command]]
+      command << '-l'
+      command << "-u #{@options[:user]}" if @options[:user]
+
+      command_results  = %x[#{command.join(' ')} 2> /dev/null]
+      @current_crontab = $?.exitstatus.zero? ? prepare(command_results) : ''
+    end
+
+    def write_crontab(contents)
+      command = [@options[:crontab_command]]
+      command << "-u #{@options[:user]}" if @options[:user]
+      # Solaris/SmartOS cron does not support the - option to read from stdin.
+      command << "-" unless OS.solaris?
+
+      IO.popen(command.join(' '), 'r+') do |crontab|
+        crontab.write(contents)
+        crontab.close_write
+        stdout = crontab.read
+        puts stdout unless stdout == ''
+      end
+
+      success = $?.exitstatus.zero?
+
+      if success
+        action = 'written' if @options[:write]
+        action = 'updated' if @options[:update]
+        puts "[write] crontab file #{action}"
+        return_or_exit(true)
+      else
+        warn "[fail] Couldn't write crontab; try running `whenever' with no options to ensure your schedule file is valid."
+        return_or_exit(false)
+      end
+    end
+
+    def updated_crontab
+      # Check for unopened or unclosed identifier blocks
+      if read_crontab =~ Regexp.new("^#{comment_open_regex}\s*$") && (read_crontab =~ Regexp.new("^#{comment_close_regex}\s*$")).nil?
+        warn "[fail] Unclosed indentifier; Your crontab file contains '#{comment_open(false)}', but no '#{comment_close(false)}'"
+        return_or_exit(false)
+      elsif (read_crontab =~ Regexp.new("^#{comment_open_regex}\s*$")).nil? && read_crontab =~ Regexp.new("^#{comment_close_regex}\s*$")
+        warn "[fail] Unopened indentifier; Your crontab file contains '#{comment_close(false)}', but no '#{comment_open(false)}'"
+        return_or_exit(false)
+      end
+
+      # If an existing identifier block is found, replace it with the new cron entries
+      if read_crontab =~ Regexp.new("^#{comment_open_regex}\s*$") && read_crontab =~ Regexp.new("^#{comment_close_regex}\s*$")
+        # If the existing crontab file contains backslashes they get lost going through gsub.
+        # .gsub('\\', '\\\\\\') preserves them. Go figure.
+        read_crontab.gsub(Regexp.new("^#{comment_open_regex}\s*$.+^#{comment_close_regex}\s*$", Regexp::MULTILINE), whenever_cron.chomp.gsub('\\', '\\\\\\'))
+      else # Otherwise, append the new cron entries after any existing ones
+        [read_crontab, whenever_cron].join("\n\n")
+      end.gsub(/\n{3,}/, "\n\n") # More than two newlines becomes just two.
+    end
+
+    def prepare(contents)
+      # Strip n lines from the top of the file as specified by the :cut option.
+      # Use split with a -1 limit option to ensure the join is able to rebuild
+      # the file with all of the original seperators in-tact.
+      stripped_contents = contents.split($/,-1)[@options[:cut]..-1].join($/)
+
+      # Some cron implementations require all non-comment lines to be newline-
+      # terminated. (issue #95) Strip all newlines and replace with the default
+      # platform record seperator ($/)
+      stripped_contents.gsub!(/\s+$/, $/)
+    end
+
+    def comment_base(include_timestamp = true)
+      if include_timestamp
+        "Whenever generated tasks for: #{@options[:identifier]} at: #{@timestamp}"
+      else
+        "Whenever generated tasks for: #{@options[:identifier]}"
+      end
+    end
+
+    def comment_open(include_timestamp = true)
+      "# Begin #{comment_base(include_timestamp)}"
+    end
+
+    def comment_close(include_timestamp = true)
+      "# End #{comment_base(include_timestamp)}"
+    end
+
+    def comment_open_regex
+      "#{comment_open(false)}(#{timestamp_regex}|)"
+    end
+
+    def comment_close_regex
+      "#{comment_close(false)}(#{timestamp_regex}|)"
+    end
+
+    def timestamp_regex
+      " at: \\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2} ([+-]\\d{4}|UTC)"
+    end
+
+  private
+
+    def return_or_exit success
+      result = 1
+      result = 0 if success
+      if @options[:console]
+        exit(result)
+      else
+        result
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,181 @@
+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 '|'})|((\*?[\d\/,\-]*)\s){3}(\*?([\d\/,\-]|(#{MONTHS.join '|'}))*\s)(\*?([\d\/,\-]|(#{DAYS.join '|'}))*))$/i
+
+      attr_accessor :time, :task
+
+      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, chronic_options) || 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, options = {})
+        enumerate(times).each do |time|
+          enumerate(job.at, false).each do |at|
+            yield new(time, job.output, at, options).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?
+        @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 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)
+          @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 : range_or_integer(@at, 0..59, 'Minute')
+            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 : range_or_integer(@at, 0..23, 'Hour')
+            timing[2] = comma_separated_timing(day_frequency, 31, 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)
+              day_given? ? @at.day : 1
+            else
+              @at == 0 ? 1 : range_or_integer(@at, 1..31, 'Day')
+            end
+            timing[3] = comma_separated_timing(month_frequency, 12, 1)
+          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 == 0 ? 1 : range_or_integer(@at, 1..12, 'Month')
+            end
+          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')
+
+        DAYS.each_with_index do |day, i|
+          return (timing << i) * " " if string.downcase.index(day)
+        end
+
+        raise ArgumentError, "Couldn't parse: #{@time.inspect}"
+      end
+
+      def range_or_integer(at, valid_range, name)
+        must_be_between = "#{name} must be between #{valid_range.min}-#{valid_range.max}"
+        if at.is_a?(Range)
+          raise ArgumentError, "#{must_be_between}, #{at.min} given" unless valid_range.include?(at.min)
+          raise ArgumentError, "#{must_be_between}, #{at.max} given" unless valid_range.include?(at.max)
+          return "#{at.min}-#{at.max}"
+        end
+        raise ArgumentError, "#{must_be_between}, #{at} given" unless valid_range.include?(at)
+        at
+      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/whenever-1.1.2/lib/whenever/job.rb

@@ -0,0 +1,56 @@
+require 'shellwords'
+
+module Whenever
+  class Job
+    attr_reader :at, :roles, :mailto, :description
+
+    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(options.delete(:roles))
+      @description                      = options.delete(:description)
+      @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