did_craken 0.0.1

data/README.rdoc

@@ -0,0 +1,170 @@
+= Craken
+
+Craken is a rails plugin for managing and installing rake-centric crontab files 
+over Capistrano.
+
+What is a crontab?  A command list that cron will run at specified intervals.
+What is cron?  A daemon to execute scheduled commands.
+
+If you don't know these things already you should probably do a little research
+before using this tool :) Begin here: http://en.wikipedia.org/wiki/Cron
+
+Craken uses files called +raketab+s that are similar in every respect to crontab
+files except the commands are rake tasks instead of arbitrary unix commands.  The file
+goes in the craken directory inside config (i.e. #{RAILS_ROOT}/config/craken/raketab).
+
+Why not just let it run arbitrary commands instead of limiting it to rake tasks?
+The main issue this plugin attempts to alleviate is having to manage the 
+rails environment configuration for multiple deployments.  Craken will set up the
+crontab to change into the application's current directory and set rake to run in
+the correct environment.
+
+Raketab files can also handle ERB escaped text bound to the rake environment.
+
+A Capistrano file is also included to make it easy to install cron jobs on multiple 
+hosts.  A new :cron capistrano role is necessary to define which machines to install to.
+
+== Configuration
+
+Command line configuration options to the rake task (defaults are in parens):
+[+deploy_path+]        Where the application is deployed (RAILS_ROOT)
+[+crontab_exe+]        Where to find the crontab excutable (/usr/bin/crontab)
+[+rake_exe+]           The rake executable (/usr/bin/rake)
+[+raketab_rails_env+]  Rails environment mode to set the cron jobs to run in (RAILS_ENV)
+[+app_name+]           Name of the application (tries to figure it out from the deploy path)
+[+raketab_file+]       Where the raketab file is:
+
+  #{RAILS_ROOT}/config/craken/#{HOSTNAME}_raketab or 
+  #{RAILS_ROOT}/config/craken/raketab if the first is not found
+
+The +raketab_file+ can be a crontab file (no extension), a .yaml/.yml file or 
+an .rb file (see Other Formats below).
+
+== Example
+
+An example line from an example raketab file:
+
+  59 * * * * thing:to_do > /tmp/thing_to_do.log 2>&1
+
+This will run the rake task thing:to_do every 59th minute after every hour.
+The little redirect thing is added for effect; otherwise output will be mailed
+to the user who the crontab is installed on.
+
+When craken:install is run on the production box, the crontab will look like this:
+
+  ### foo raketab
+  59 * * * * cd /home/thatguy/u/apps/foo/current && /usr/bin/rake --silent RAILS_ENV=production thing:to_do > /tmp/thing_to_do.log 2>&1
+  ### foo raketab end
+
+The "magic" part of craken is the bit that crontab added:
+
+  cd /home/thatguy/u/apps/foo/current && /usr/bin/rake --silent RAILS_ENV=production
+
+=== Special crontab string support
+
+An example line to add a rake task to be executed after reboot:
+
+  @reboot thinking_sphinx:start > /tmp/ts_startup.log 2>&1
+
+All special strings and their effects:
+[<tt>@reboot</tt>]    execute after reboot
+[<tt>@yearly</tt>]    every year
+[<tt>@annually</tt>]  every year hipster version
+[<tt>@monthly</tt>]   every month, or better known as: <i>No roll in the hay for you this time honey!</i>
+[<tt>@weekly</tt>]    just like every month but weekly
+[<tt>@daily</tt>]     like brushing your teeth
+[<tt>@midnight</tt>]  when the ghosts come out
+[<tt>@hourly</tt>]    whenever the long hand of your watch is at 12
+
+Read more about crontab special strings here: http://unixhelp.ed.ac.uk/CGI/man-cgi?crontab+5
+== Other Formats
+
+You can also specify other types of files to describe +raketabs+.  You can have multiple formats and they 
+will be aggregated together.
+
+=== YAML 
+
+You can specify it in YAML.  For instance in a +config/craken/raketab.yml+:
+
+  my_command:
+    hour: 5
+    minute: 30
+    day: 1
+    month: September
+    command: thing:to_do > /tmp/thing_to_do.log 2>&1
+
+Here we've specified my_command to run at 5:30 AM on September 1st.  Aside from the command to run, 
+the timings have the following defaults: 0 minute, 0 hour, every day, every month, every weekday. So 
+you could specify in your raketab.yml:
+
+  my_other_command:
+    command: other:thing:to_do > /tmp/thing_to_do.log 2>&1
+    
+This will run at midnight of every day.  You can also specify weekday:
+
+  my_third_command:
+    weekday: thursday
+    command: third:thing:to_do > /tmp/thing_to_do.log 2>&1
+
+You can also specify the month number or weekday number as you would in a crontab.  Lastly, you can specify ranges or full match strings and they will be passed on to the crontab directly:
+
+  and_finally:
+    hour: *
+    weekday: 1-5
+    command: last:thing:to_do > /tmp/thing_to_do.log 2>&1
+
+Here, the command will run every hour from Monday to Friday.  Month and Weekday names are not supported when doing ranges in this fashion.
+
+=== Raketab DSL
+
+The other format is written in pure ruby using the +Raketab+ object.  In your +config/craken/raketab.rb+ file:
+
+  Raketab.new do |cron|
+    cron.schedule 'thing:to_do > /tmp/thing_to_do.log 2>&1', :every => :thursday
+  end
+
+The defaults are like those for the YAML file, so in this case, thing to do will run at midnight on thursdays.
+
+  Raketab.new do |cron|
+    cron.schedule 'thing:to_do > /tmp/thing_to_do.log 2>&1', :on => :september, :the => '1st', :at => '5:30'    
+  end
+  
+Here it will run only on the first of september at 5:30 AM.  Month and weekday names are also supported, and
+also the named units (hour, minute, month, day, weekday):
+
+  Raketab.new do |cron|
+    cron.schedule 'thing:to_do > /tmp/thing_to_do.log 2>&1', :on => september, :every => thursday
+  end
+
+Here it will run every Thursday in September.  Ranges (inclusive and exclusive), comma separated lists, in strings or using numbers or weekday and month names are also supported and their three letter abbreviations:
+
+  Raketab.new do |cron|
+    cron.schedule 'thing:to_do > /tmp/thing_to_do.log 2>&1',     :every => mon..fri
+    cron.schedule 'first:five:days > /tmp/thing_to_do.log 2>&1', :days => [1,2,3,4,5]
+    cron.schedule 'first:day:q1 > /tmp/thing_to_do.log 2>&1',    :the => '1st', :in => [jan,feb,mar]
+    cron.schedule 'first:day:q4 > /tmp/thing_to_do.log 2>&1',    :the => '1st', :months => 'October,November,December'
+  end
+
+You can find all the variants in the spec for Raketab and pick and choose which is most natural for you.
+
+= Running the Capistrano Script
+
+  cap craken:install
+
+Deploying to someplace other than production?  Rails environment is important so rake 
+is set in the right mode when the cron job runs:
+
+  cap -c rails_env=qa craken:install
+
+Different raketab files can be used to limit a subset of rake tasks to a particular 
+machine listed as a :cron role.  These files are prefixed with the name of the machine
+they need to be deployed to:
+
+  foo_raketab  # goes on the "foo" machine
+  bar_raketab  # goes on the "bar" machine
+  raketab      # goes on all machines except "foo" and "bar"
+
+Doug McInnes <doug.mcinnes@latimes.com>
+John Dewey <john.dewey@latimes.com>
+Reid MacDonald <reid.macdonald@latimes.com>
+Copyright (c) 2008 Los Angeles Times, released under the MIT license

data/lib/craken.rb

@@ -0,0 +1,112 @@
+require 'socket'
+require "#{File.dirname(__FILE__)}/raketab"
+
+module Craken
+  def self.determine_raketab_files
+    if File.directory?("#{DEPLOY_PATH}/config/craken/") # Use hostname specific raketab first.
+      raketabs = Dir["#{DEPLOY_PATH}/config/craken/*raketab*"].partition {|f| f =~ %r[/raketab.*$] }
+      raketabs.last.empty? ? raketabs.first : raketabs.last.grep(/#{HOSTNAME}_raketab/)
+    else
+      Dir["#{DEPLOY_PATH}/config/raketab*"]
+    end
+  end
+
+  HOSTNAME          = Socket.gethostname.split('.').first.downcase.strip
+  DEPLOY_PATH       = ENV['deploy_path'] || RAILS_ROOT
+  RAKETAB_FILES     = ENV['raketab_files'].split(":") rescue determine_raketab_files
+  CRONTAB_EXE       = ENV['crontab_exe'] || "/usr/bin/crontab"
+  RAKE_EXE          = ENV['rake_exe'] || ((rake = `which rake`.strip and rake.empty?) ? "/usr/bin/rake" : rake)
+  RAKETAB_RAILS_ENV = ENV['raketab_rails_env'] || RAILS_ENV
+  # assumes root of app is name of app, also takes into account 
+  # capistrano deployments
+  APP_NAME          = ENV['app_name'] || (DEPLOY_PATH =~ /\/([^\/]*)\/releases\/\d*$/ ? $1 : File.basename(DEPLOY_PATH))
+
+  # see here: http://unixhelp.ed.ac.uk/CGI/man-cgi?crontab+5
+  SPECIAL_STRINGS   = %w[@reboot @yearly @annually @monthly @weekly @daily @midnight @hourly]
+
+  CRONTAB_MARKER_START = "### #{APP_NAME} #{RAKETAB_RAILS_ENV} raketab start"
+  CRONTAB_MARKER_END = "### #{APP_NAME} #{RAKETAB_RAILS_ENV} raketab end"
+  # strip out the existing raketab cron tasks for this project
+  def load_and_strip
+    crontab = ''
+    old = false
+    `#{CRONTAB_EXE} -l`.each_line do |line|
+      line.strip!
+      if old || line == CRONTAB_MARKER_START
+        old = line != CRONTAB_MARKER_END
+      else
+        crontab << line
+        crontab << "\n"
+      end
+    end
+    crontab
+  end
+
+  def append_tasks(crontab, raketab)
+    crontab << "#{CRONTAB_MARKER_START}\n"
+    raketab.each_line do |line|
+      line.strip!
+      unless line =~ /^#/ || line.empty? # ignore comments and blank lines
+        sp = line.split
+        if SPECIAL_STRINGS.include?(sp.first)
+          crontab << sp.shift
+          tasks = sp
+        else
+          crontab << sp[0,5].join(' ')
+          tasks = sp[5,sp.size]
+        end
+        crontab << " cd #{DEPLOY_PATH} && #{RAKE_EXE} --silent RAILS_ENV=#{RAKETAB_RAILS_ENV}"
+        tasks.each do |task|
+          crontab << " #{task}"
+        end
+        crontab << "\n"
+      end
+    end
+    crontab << "#{CRONTAB_MARKER_END}\n"
+    crontab
+  end
+
+  # install new crontab
+  def install(crontab)
+    filename = ".crontab#{rand(9999)}" 
+    File.open(filename, 'w') { |f| f.write crontab }
+    `#{CRONTAB_EXE} #{filename}`
+    FileUtils.rm filename
+  end
+  
+  def raketab(files=RAKETAB_FILES)    
+    files.map do |file|
+      next unless File.exist?(file)
+      builder = file =~ /.(\w+)$/ ? "build_raketab_from_#{$1}" : "build_raketab"
+      send(builder.to_sym, file)
+    end.join("\n")
+  end
+  
+  private
+    def build_raketab_from_rb(file)
+      eval(File.new(file).read).tabs
+    end
+  
+    def build_raketab_from_yml(file)
+      yml = YAML::load(ERB.new(File.read(file)).result(binding))
+      yml.map do |name,tab|
+        format = []
+        format << (tab['min'] || tab['minute'] || '0')
+        format << (tab['hour'] || '0')
+        format << (tab['day'] || '*')
+        format << (tab['month'] =~ /^\d+$/ ? tab['month'] : Date._parse(tab['month'].to_s)[:mon] || '*')
+        format << ((day = tab['weekday'] || tab['wday'] and day =~ /^\d+$/ ? day : Date._parse(day.to_s)[:wday]) || '*')
+        format << tab['command']
+        format.join(' ')        
+      end.join("\n")
+    end
+    alias_method :build_raketab_from_yaml, :build_raketab_from_yml
+    
+    def build_raketab(file)
+      ERB.new(File.read(file)).result(binding)
+    end
+
+    def method_missing(method, *args)
+      method.to_s =~ /^build_raketab/ ? build_raketab(*args) : super
+    end
+end

data/lib/enumeration.rb

@@ -0,0 +1,89 @@
+class Enumeration  
+  include Comparable
+
+  def initialize(id)
+    @unit_id = id % self.class.size
+  end
+  private_class_method :new
+  
+  def self.for(var)
+    units[var.to_s =~ /^\d+$/ ? var.to_i - offset : abbrs.index(var[0,3].downcase.capitalize)] 
+  end
+
+  def succ
+    self.class.units[(@unit_id + 1) % self.class.size]
+  end
+
+  def between?(a,b)
+    true # always in rings, change for non rings
+  end
+  
+  def <=>(o)
+    @unit_id <=> o.instance_variable_get("@unit_id")
+  end
+  
+  def to_s
+    self.class.names[@unit_id]
+  end
+  
+  def to_i
+    @unit_id + self.class.offset
+  end
+  
+  def to_abbr
+    to_s[0,3]
+  end
+  
+  def coerce(o)
+    [self.class.for(o % self.class.size), self]
+  end
+
+  def +(o)
+    self.class.for((to_i + o.to_i) % self.class.size)
+  end
+
+  def -(o)
+    self.class.for((to_i - o.to_i) % self.class.size)
+  end
+
+  def inspect
+    "#<#{self.class.name.split("::").last}:#{to_s}>"
+  end
+      
+  def self.generate(names, offset=0)
+    klass = Class.new(self)
+    klass.send(:build_from, names)
+    klass.send(:offset=, offset)
+    klass.instance_eval { undef generate } 
+    klass
+  end
+
+  class << self
+    include Enumerable
+    def each
+      units.each { |u| yield u }
+    end
+    
+    attr_accessor :offset
+    attr_reader :names, :abbrs, :units, :size
+    def build_from(names)
+      @names = names.dup.freeze
+      @abbrs = names.map { |n| n[0,3] }.freeze
+
+      @size  = @names.size
+      @units = (0...@size).map { |n| new(n) }.freeze
+
+      @names.each_with_index do |c,i|
+        const = c.upcase
+        const_get(const)      rescue const_set(const, @units[i]) 
+        const_get(const[0,3]) rescue const_set(const[0,3], @units[i]) 
+      end
+    end
+    private :build_from
+  end
+end
+
+def Enumeration(*args)
+  Enumeration.generate(*args)
+end
+alias enum Enumeration

data/lib/raketab.rb

@@ -0,0 +1,104 @@
+require "#{File.dirname(__FILE__)}/enumeration"
+require 'date'
+
+class Raketab  
+  Month   = enum %w[January February March April May June July August September October November December], 1
+  Weekday = enum %w[Sunday Monday Tuesday Wednesday Thursday Friday Saturday]
+    
+  class << self
+    def methodize_enum(enum)
+      enum.each do |e| 
+        p = Proc.new { e }
+        define_method(e.to_s.downcase,    p) 
+        define_method(e.to_abbr.downcase, p) 
+      end
+    end
+    private :methodize_enum
+
+    def schedule(&block)
+      tab = Raketab.new
+      tab.instance_eval(&block)
+      tab
+    end
+  end
+  methodize_enum(Month)
+  methodize_enum(Weekday)
+  
+  def initialize
+    @tabs = []
+  end
+
+  def run(command, options={})
+    month, wday, mday, hour, min = options[:month]   || options[:months]   || options[:mon], 
+                                   options[:weekday] || options[:weekdays] || options[:wday], 
+                                   options[:day]     || options[:days]     || options[:mday],
+                                   options[:hour]    || options[:hours],
+                                   options[:minute]  || options[:minutes]  || options[:min]
+
+    # make sure we have ints instead of enums, yo
+    month, wday = [[month, Month], [wday, Weekday]].map do |element,type| 
+      if element.kind_of?(Array) # just arrays for now
+       element.each_with_index { |e,i| element[i] = enum_to_i(e,type) } 
+      else
+       enum_to_i(element,type)
+      end
+    end
+
+    [:each, :every, :on, :in, :at, :the].each do |type|
+      if options[type]
+        if(options[type] =~ /:/)
+          from = options[type]
+        else
+          from, ignore, exclusive, to = options[type].to_s.match(/(\w+)(\.\.(\.?)(\w+))?/)[1..4].map { |m| m.gsub(/s$/i, '') if m } 
+        end
+
+        parse = Date._parse(from)
+        range = to ? Date._parse(to) : {}
+
+        month ||= get_value(parse, range, exclusive == '.', :mon)
+        wday  ||= get_value(parse, range, exclusive == '.', :wday)
+        mday  ||= get_value(parse, range, exclusive == '.', :mday)
+        hour  ||= get_value(parse, range, exclusive == '.', :hour)
+        min   ||= get_value(parse, range, exclusive == '.', :min)
+      end
+    end
+
+    # deal with any arrays and ranges
+    min, hour, mday, wday, month = [min, hour, mday, wday, month].map do |type| 
+     type.respond_to?(:map) ? type.map.join(',') : type    
+    end
+
+    # special cases with hours
+    hour ||= options[:at].to_i if options[:at] # :at => "5 o'clock" / "5" / 5
+
+    # fill missing items
+    hour, min         = [hour, min].map { |t| t || '0' }
+    month, wday, mday = [month, wday, mday].map { |t| t || '*' }    
+    
+    # put it together
+    @tabs << "#{min} #{hour} #{mday} #{month} #{wday} #{command}"
+  end  
+
+  def tabs
+    @tabs.join("\n")
+  end
+
+  private
+    def get_value(from, to, exclusive, on)
+      value = (from[on] and to[on]) ? Range.new(from[on], to[on], exclusive) : from[on]
+      if value.is_a?(Range) and value.first > value.last
+        reverse = (value.last.to_i+(exclusive ? 0 : 1)..(value.first.to_i-1))
+        range = case on
+          when :mon  then 1..12
+          when :wday then 0..6
+          when :mday then 1..31
+        end
+        value = range.map - reverse.map
+      end
+      value
+    end
+
+    def enum_to_i(element, type)
+      element.kind_of?(type) ? element.to_i : element
+    end
+end  

data/spec/craken_spec.rb

@@ -0,0 +1,138 @@
+RAILS_ROOT = "foo/bar/baz"
+RAILS_ENV = "test"
+ENV['app_name'] = "craken_test"
+ENV['raketab_rails_env'] = "test"
+ENV['rake_exe'] = '/usr/bin/bundle exec rake'
+
+require File.dirname(__FILE__) + "/../lib/craken"
+require 'fileutils'
+
+describe Craken do
+
+  include Craken
+
+  describe "load_and_strip" do
+
+    it "should load the user's installed crontab" do
+      # figured out how to do this from here:
+      # http://jakescruggs.blogspot.com/2007/11/mocking-backticks-and-other-kernel.html
+      self.should_receive(:`).with(/crontab -l/).and_return('')
+      load_and_strip
+    end
+
+    it "should strip out preinstalled raketab commands associated with the project" do
+
+crontab = <<EOS
+### craken_test test raketab start
+this is a test
+one more line
+### craken_test test raketab end
+EOS
+
+      self.should_receive(:`).with(/crontab -l/).and_return(crontab)
+      load_and_strip.should be_empty
+    end
+
+    it "should not strip out preinstalled raketab commands not associated with the project" do
+
+crontab = <<EOS
+1 2 3 4 5 blah blah
+### craken_test test raketab start
+this is a test
+one more line
+### craken_test test raketab end
+6 7 8 9 10 foo bar
+EOS
+
+      self.should_receive(:`).with(/crontab -l/).and_return(crontab)
+      load_and_strip.should == "1 2 3 4 5 blah blah\n6 7 8 9 10 foo bar\n"
+    end
+  end
+
+  describe "append_tasks" do
+    before(:each) do
+      @crontab = "1 2 3 4 5 blah blah\n6 7 8 9 10 foo bar\n"
+    end
+
+    it "should add comments to the beginning and end of the rake tasks it adds to crontab" do
+      raketab = "0 1 0 0 0 foo:bar"
+      cron = append_tasks(@crontab, raketab)
+      cron.should match(/### craken_test test raketab start\n0 1 0 0 0 /)
+      cron.should match(/### craken_test test raketab end\n$/)
+    end
+
+    it "should ignore comments in the raketab string" do
+raketab = <<EOS
+# comment to ignore
+0 1 0 0 0 foo:bar
+# another comment to ignore
+EOS
+      cron = append_tasks(@crontab, raketab)
+      cron.should_not match(/# comment to ignore/)
+      cron.should_not match(/# another comment to ignore/)
+    end
+    
+    it "should not munge the eight crontab special strings" do
+raketab = <<EOS
+@reboot brush:teeth
+@yearly dont_forget_girlfriends:birthday
+@annually just_damn_remember:it
+@monthly do_some:sport
+@weekly get:stash
+@daily take:shower
+@midnight stop_working_on_os:projects
+@hourly drink:water
+EOS
+      cron = append_tasks(@crontab, raketab)
+      cron.should match(/@reboot (.*)/)
+      cron.should match(/@yearly (.*)/)
+      cron.should match(/@annually (.*)/)
+      cron.should match(/@monthly (.*)/)
+      cron.should match(/@weekly (.*)/)
+      cron.should match(/@daily (.*)/)
+      cron.should match(/@midnight (.*)/)
+      cron.should match(/@hourly (.*)/)
+    end
+
+    it "should not munge the crontab time configuration" do
+raketab = <<EOS
+0 1 0 0 0 foo:bar
+1,2,3,4,5,6 0 7,8 4 5 baz:blarg
+EOS
+      cron = append_tasks(@crontab, raketab)
+      cron.should match(/0 1 0 0 0 [^\d]/)
+      cron.should match(/1,2,3,4,5,6 0 7,8 4 5 [^\d]/)
+    end
+
+    it "should add a cd command, rake command and environment variables" do
+      raketab = "0 1 0 0 0 foo:bar"
+      cron = append_tasks(@crontab, raketab)
+      cron.should match(/0 1 0 0 0 cd #{Craken::DEPLOY_PATH} && #{Craken::RAKE_EXE} --silent RAILS_ENV=#{Craken::RAKETAB_RAILS_ENV} foo:bar/)
+    end
+    
+    it "should use the rake command given via ENV['rake_exe']" do
+      raketab = "0 1 0 0 0 foo:bar"
+      cron = append_tasks(@crontab, raketab)
+      cron.should include('/usr/bin/bundle exec rake')
+    end
+
+    it "should ignore additional data at the end of the configuration" do
+      raketab = "0 1 0 0 0 foo:bar >> /tmp/foobar.log 2>&1"
+      cron = append_tasks(@crontab, raketab)
+      cron.should match(/0 1 0 0 0 cd #{Craken::DEPLOY_PATH} && #{Craken::RAKE_EXE} --silent RAILS_ENV=#{Craken::RAKETAB_RAILS_ENV} foo:bar >> \/tmp\/foobar.log 2>&1/)
+    end
+  end
+
+  describe "install" do
+    it "should install crontab by creating a temporary file, running crontab, then deleting the temp file" do
+      crontab = "crontab"
+      file_handle = mock("file handle")
+      file_handle.should_receive(:write).with(crontab)
+      File.should_receive(:open).with(/.crontab[0-9]*/, 'w').and_yield(file_handle)
+      self.should_receive(:`).with(/crontab .crontab[0-9]*$/)
+      FileUtils.should_receive(:rm).with(/.crontab[0-9]*/)
+      install(crontab)
+    end
+  end
+
+end

data/spec/enumeration_spec.rb

@@ -0,0 +1,136 @@
+describe Enumeration do
+  Weekday = enum %w[Sunday Monday Tuesday Wednesday Thursday Friday Saturday]
+
+  describe 'creation' do
+    it "should create an enumeration by Enumeration.generate, Enumeration(), or enum" do
+      ABC1 = Enumeration.generate(%w[a b c])
+      ABC1.units.should == [ABC1::A, ABC1::B, ABC1::C]
+
+      ABC2 = Enumeration(%w[a b c])
+      ABC2.units.should == [ABC1::A, ABC1::B, ABC1::C]
+
+      ABC3 = enum %w[a b c]
+      ABC3.units.should == [ABC1::A, ABC1::B, ABC1::C]
+    end
+
+    it "should not generate an enumeration itself" do
+      ABC4 = enum %w[a b c]
+      ABC4.methods.grep(/generate/).should be_empty
+      lambda{ ABC4.generate(%w[a b c]) }.should raise_error(NoMethodError)
+    end
+
+    it "should allow an offset from zero to be specified" do
+      ABC = enum %w[a b c], 1
+      ABC.offset.should == 1
+      ABC.size.should == 3
+      ABC.units.map { |l| l.to_i }.should == [1,2,3]
+    end
+  end
+  
+  describe 'properties' do
+    it "should generate the right size of elements" do
+      Weekday.units.size.should == 7
+      Weekday.size.should == Weekday.units.size      
+    end
+
+    it "should generate an enumeration based on an collection of names" do
+      # full names
+      Weekday.names.should == %w[Sunday Monday Tuesday Wednesday Thursday Friday Saturday]    
+      Weekday.units.should == 
+        [Weekday::SUNDAY, Weekday::MONDAY, Weekday::TUESDAY, Weekday::WEDNESDAY, Weekday::THURSDAY, Weekday::FRIDAY, Weekday::SATURDAY]
+
+      # abbreviationss
+      Weekday.abbrs.should == %w[Sun Mon Tue Wed Thu Fri Sat]
+      Weekday.units.should == 
+        [Weekday::SUN, Weekday::MON, Weekday::TUE, Weekday::WED, Weekday::THU, Weekday::FRI, Weekday::SAT]
+      Weekday.units.map { |w| w.to_i }.should == (0..6).map
+    end
+    
+    it "should get units based on integer value" do
+      (0..6).each do |value|
+        Weekday.for(value).should == Weekday.units[value]
+      end
+      
+      # and respect offsets
+      (1..3).each do |value|
+        ABC.for(value).should == ABC.units[value - ABC.offset]
+      end        
+    end
+    
+    it "should be enumerable on the units" do
+      Weekday.methods.grep(/^each$/).should == %w[each]
+      Weekday.is_a?(Enumerable)
+      Weekday.map {|x| x.to_i }.should == Weekday.units.map {|x| x.to_i }
+    end
+
+    it "should not be able to create new units" do
+      lambda { Weekday.new(7) }.should raise_error(NoMethodError)
+    end
+  end
+  
+  describe 'units' do
+    it "should be comparable" do
+      Weekday::SUN.methods.grep(/^succ$/).should == %w[succ]
+      Weekday::SUN.is_a?(Comparable)
+      Weekday::SUN.should < Weekday::MON
+      Weekday::SUN.should <= Weekday::MON
+      Weekday::MON.should > Weekday::SUN
+      Weekday::MON.should >= Weekday::SUN
+      Weekday::SUN.should == Weekday::SUN
+      Weekday::WED.between?(Weekday::MON, Weekday::FRI).should be_true
+      Weekday::FRI.between?(Weekday::THU, Weekday::SUN).should be_true # if a ring
+      
+    end
+    
+    # this should be configurable!? is true for now!
+    it "should be a ring of values (cross boundries)" do 
+      Weekday::SAT.succ.should == Weekday::SUN      
+      Weekday::SUN.succ.should == Weekday::MON
+    end
+    
+    it "should work in a range" do
+      (Weekday::MON..Weekday::FRI).map.should == Weekday.units[1..5]
+    end
+    
+    it "should have to_s be it's name" do
+      %w[Sunday Monday Tuesday Wednesday Thursday Friday Saturday].each do |name|
+        Weekday.for(name).to_s.should == name
+      end
+    end
+    
+    it "should have to_abbr to get it's three letter abbreviation" do
+      %w[Sun Mon Tue Wed Thu Fri Sat].each do |abbr|
+        Weekday.for(abbr).to_abbr.should == abbr
+      end
+    end
+    
+    it "should show the enumerable name and unit name in inspect" do
+      %w[Sunday Monday Tuesday Wednesday Thursday Friday Saturday].each do |name|
+        Weekday.for(name).inspect.should == "#<Weekday:#{name}>"
+      end
+    end
+    
+    it "should use integer values in arithmatic (+/-) and return another unit" do
+      Weekday.each_with_index do |w,i|
+        (Weekday::SUN + i).should == w
+      end
+      Weekday.map.reverse.each_with_index do |w,i|
+        (Weekday::SUN - i - 1).should == w
+      end
+      # ring / identity
+      (Weekday::SUN + 7).should == Weekday::SUN 
+      (Weekday::SUN - 7).should == Weekday::SUN 
+    end
+
+    it "should use integer values in arithmatic (+/-) and return another unit with coersion to weekday on integer" do
+      Weekday.each_with_index do |w,i|
+        (1 + w).should == Weekday.map[(i+1) % Weekday.size]
+      end
+      Weekday.each_with_index do |w,i|
+        (i - w).should == Weekday::SUN
+      end      
+      (0 + Weekday::MON).should == Weekday::MON
+      (2 - Weekday::MON).should == Weekday::MON 
+    end
+  end
+end

data/spec/raketab_spec.rb

@@ -0,0 +1,171 @@
+describe Raketab do
+  it "should have defaults (0 for hour, minutes and * for days and months)" do
+   Raketab.schedule { run 'test' }.tabs.should == '0 0 * * * test'
+  end
+  
+  it "should set all the fields by name" do
+    Raketab.schedule { run 'test', :min => 1 }.tabs.should     == "1 0 * * * test"
+    Raketab.schedule { run 'test', :minute => 1 }.tabs.should  == "1 0 * * * test"
+    Raketab.schedule { run 'test', :hour => 1 }.tabs.should    == "0 1 * * * test"
+    Raketab.schedule { run 'test', :day => 1 }.tabs.should     == "0 0 1 * * test"
+    Raketab.schedule { run 'test', :mday => 1 }.tabs.should    == "0 0 1 * * test"
+    Raketab.schedule { run 'test', :month => 1 }.tabs.should   == "0 0 * 1 * test"
+    Raketab.schedule { run 'test', :mon => 1 }.tabs.should     == "0 0 * 1 * test"
+    Raketab.schedule { run 'test', :wday => 1 }.tabs.should    == "0 0 * * 1 test"
+    Raketab.schedule { run 'test', :weekday => 1 }.tabs.should == "0 0 * * 1 test"
+  end
+  
+  it "should set month and weekday fields by method name" do
+    Raketab.schedule { run 'test', :month => january }.tabs.should == "0 0 * 1 * test"
+    Raketab.schedule { run 'test', :mon => jan }.tabs.should       == "0 0 * 1 * test"
+    Raketab.schedule { run 'test', :wday => monday }.tabs.should   == "0 0 * * 1 test"
+    Raketab.schedule { run 'test', :weekday => mon }.tabs.should   == "0 0 * * 1 test"
+  end
+
+  it "should set the fields by comma string" do
+    Raketab.schedule { run 'test', :minutes => '1,2,3' }.tabs.should  == "1,2,3 0 * * * test"
+    Raketab.schedule { run 'test', :hours => '1,2,3' }.tabs.should    == "0 1,2,3 * * * test"
+    Raketab.schedule { run 'test', :days => '1,2,3' }.tabs.should     == "0 0 1,2,3 * * test"
+    Raketab.schedule { run 'test', :months => '1,2,3' }.tabs.should   == "0 0 * 1,2,3 * test"
+    Raketab.schedule { run 'test', :weekdays => '1,2,3' }.tabs.should == "0 0 * * 1,2,3 test"
+  end
+  
+  it "should set the fields by array populated by method names" do
+    Raketab.schedule { run 'test', :months => [jan,feb,mar] }.tabs.should   == "0 0 * 1,2,3 * test"
+    Raketab.schedule { run 'test', :weekdays => [mon,tue,wed] }.tabs.should == "0 0 * * 1,2,3 test"
+  end
+  
+  it "should set the fields by array" do
+    Raketab.schedule { run 'test', :minutes => [1,2,3] }.tabs.should  == "1,2,3 0 * * * test"
+    Raketab.schedule { run 'test', :hours => [1,2,3] }.tabs.should    == "0 1,2,3 * * * test"
+    Raketab.schedule { run 'test', :days => [1,2,3] }.tabs.should     == "0 0 1,2,3 * * test"
+    Raketab.schedule { run 'test', :months => [1,2,3] }.tabs.should   == "0 0 * 1,2,3 * test"
+    Raketab.schedule { run 'test', :weekdays => [1,2,3] }.tabs.should == "0 0 * * 1,2,3 test"
+  end
+  
+  it "should set the fields by inclusive ranges" do
+    Raketab.schedule { run 'test', :minutes => 1..3 }.tabs.should  == "1,2,3 0 * * * test"
+    Raketab.schedule { run 'test', :hours => 1..3 }.tabs.should    == "0 1,2,3 * * * test"
+    Raketab.schedule { run 'test', :days => 1..3 }.tabs.should     == "0 0 1,2,3 * * test"
+    Raketab.schedule { run 'test', :months => 1..3 }.tabs.should   == "0 0 * 1,2,3 * test"
+    Raketab.schedule { run 'test', :weekdays => 1..3 }.tabs.should == "0 0 * * 1,2,3 test"
+  end
+  
+  it "should set the fields by exclusive ranges" do
+    Raketab.schedule { run 'test', :minutes => 1...4 }.tabs.should  == "1,2,3 0 * * * test"
+    Raketab.schedule { run 'test', :hours => 1...4 }.tabs.should    == "0 1,2,3 * * * test"
+    Raketab.schedule { run 'test', :days => 1...4 }.tabs.should     == "0 0 1,2,3 * * test"
+    Raketab.schedule { run 'test', :months => 1...4 }.tabs.should   == "0 0 * 1,2,3 * test"
+    Raketab.schedule { run 'test', :weekdays => 1...4 }.tabs.should == "0 0 * * 1,2,3 test"
+  end
+  
+  it "should set weekday with symbol or string of the day name or abbreviation" do
+    Raketab.schedule { run 'test', :on => :thursday }.tabs.should  == '0 0 * * 4 test'
+    Raketab.schedule { run 'test', :on => 'Thursday' }.tabs.should == '0 0 * * 4 test'
+    Raketab.schedule { run 'test', :on => :thu }.tabs.should       == '0 0 * * 4 test'
+    Raketab.schedule { run 'test', :on => 'Thurs' }.tabs.should    == '0 0 * * 4 test'
+  end
+  
+  
+  it "should set month with symbol or string of the month name or abbreviation" do
+    Raketab.schedule { run 'test', :on => :september }.tabs.should  == '0 0 * 9 * test'
+    Raketab.schedule { run 'test', :on => 'September' }.tabs.should == '0 0 * 9 * test'
+    Raketab.schedule { run 'test', :on => :sep }.tabs.should        == '0 0 * 9 * test'
+    Raketab.schedule { run 'test', :on => 'Sep' }.tabs.should       == '0 0 * 9 * test'
+  end
+  
+  it "should set month with any syntactic sugar" do
+    Raketab.schedule { run 'test', :every => :september }.tabs.should == '0 0 * 9 * test'
+    Raketab.schedule { run 'test', :each => :september }.tabs.should  == '0 0 * 9 * test'
+    Raketab.schedule { run 'test', :on => :september }.tabs.should    == '0 0 * 9 * test'
+    Raketab.schedule { run 'test', :in => :september }.tabs.should    == '0 0 * 9 * test'
+  end
+  
+  it "should set day with any syntactic sugar" do
+    Raketab.schedule { run 'test', :every => '1st' }.tabs.should == '0 0 1 * * test'
+    Raketab.schedule { run 'test', :each => '2nd' }.tabs.should  == '0 0 2 * * test'
+    Raketab.schedule { run 'test', :the => '3rd' }.tabs.should   == '0 0 3 * * test'
+  end
+  
+  it "should set the time of day, with AM/PM or military time" do
+    Raketab.schedule { run 'no meridiem', :at => '12:30' }.tabs.should   == '30 12 * * * no meridiem'
+    Raketab.schedule { run 'am meridiem', :at => '12:30AM' }.tabs.should == '30 0 * * * am meridiem'
+    Raketab.schedule { run 'pm meridiem', :at => '12:30PM' }.tabs.should == '30 12 * * * pm meridiem'
+    Raketab.schedule { run 'military',    :at => '23:30' }.tabs.should   == '30 23 * * * military'
+  end
+  
+  it "should set all the fields if they are all provided" do
+    Raketab.schedule do |t| 
+      t.run 'test', :every => :sep, :the => '1st', :on => :thursdays, :at => "12:30" 
+    end.tabs.should == "30 12 1 9 4 test"
+  end
+  
+  it "should set the range of months" do
+    Raketab.schedule { run 'inclusive full', :in => 'September..November' }.tabs.should  == '0 0 * 9,10,11 * inclusive full'
+    Raketab.schedule { run 'exclusive full', :in => 'September...December' }.tabs.should == '0 0 * 9,10,11 * exclusive full'
+    Raketab.schedule { run 'inclusive abbr', :in => 'Sep..Nov' }.tabs.should             == '0 0 * 9,10,11 * inclusive abbr'
+    Raketab.schedule { run 'exclusive abbr', :in => 'Sep...Dec' }.tabs.should            == '0 0 * 9,10,11 * exclusive abbr'
+  end
+  
+  it "should set the range of months across year boundry" do
+    Raketab.schedule { run 'inclusive full reverse', :in => 'November..January' }.tabs.should    == '0 0 * 1,11,12 * inclusive full reverse'
+    Raketab.schedule { run 'exclusive full reverse', :in => 'November...February' }.tabs.should  == '0 0 * 1,11,12 * exclusive full reverse'
+    Raketab.schedule { run 'inclusive abbr reverse', :in => 'Nov..Jan' }.tabs.should             == '0 0 * 1,11,12 * inclusive abbr reverse'
+    Raketab.schedule { run 'exclusive abbr reverse', :in => 'Nov...Feb' }.tabs.should            == '0 0 * 1,11,12 * exclusive abbr reverse'
+  end
+  
+  it "should set the range of days" do
+    Raketab.schedule { run 'inclusive full', :on => 'Monday..Thursday' }.tabs.should == '0 0 * * 1,2,3,4 inclusive full'
+    Raketab.schedule { run 'exclusive full', :on => 'Monday...Friday' }.tabs.should  == '0 0 * * 1,2,3,4 exclusive full'
+    Raketab.schedule { run 'inclusive abbr', :on => 'Mon..Thur' }.tabs.should        == '0 0 * * 1,2,3,4 inclusive abbr'
+    Raketab.schedule { run 'exclusive abbr', :on => 'Mon...Fri' }.tabs.should        == '0 0 * * 1,2,3,4 exclusive abbr'
+  end
+  
+  it "should set the range of days across week boundry" do
+    Raketab.schedule { run 'inclusive full', :on => 'Thursday..Monday' }.tabs.should  == '0 0 * * 0,1,4,5,6 inclusive full'
+    Raketab.schedule { run 'exclusive full', :on => 'Thursday...Monday' }.tabs.should == '0 0 * * 0,4,5,6 exclusive full'
+    Raketab.schedule { run 'inclusive abbr', :on => 'Thu..Mon' }.tabs.should         == '0 0 * * 0,1,4,5,6 inclusive abbr'
+    Raketab.schedule { run 'exclusive abbr', :on => 'Thu...Mon' }.tabs.should        == '0 0 * * 0,4,5,6 exclusive abbr'
+  end
+  
+  it "should set the range of months using month name methods" do
+    Raketab.schedule { run 'inclusive full', :in => september..november }.tabs.should  == '0 0 * 9,10,11 * inclusive full'
+    Raketab.schedule { run 'exclusive full', :in => september...december }.tabs.should == '0 0 * 9,10,11 * exclusive full'
+    Raketab.schedule { run 'inclusive abbr', :in => sep..nov }.tabs.should             == '0 0 * 9,10,11 * inclusive abbr'
+    Raketab.schedule { run 'exclusive abbr', :in => sep...dec }.tabs.should            == '0 0 * 9,10,11 * exclusive abbr'
+  end
+  
+  it "should set the range of months across year boundry using month name methods" do
+    Raketab.schedule { run 'inclusive full reverse', :in => november..january }.tabs.should    == '0 0 * 1,11,12 * inclusive full reverse'
+    Raketab.schedule { run 'exclusive full reverse', :in => november...february }.tabs.should  == '0 0 * 1,11,12 * exclusive full reverse'
+    Raketab.schedule { run 'inclusive abbr reverse', :in => nov..jan }.tabs.should             == '0 0 * 1,11,12 * inclusive abbr reverse'
+    Raketab.schedule { run 'exclusive abbr reverse', :in => nov...feb }.tabs.should            == '0 0 * 1,11,12 * exclusive abbr reverse'
+  end
+  
+  it "should set the range of days using weekday name methods" do
+    Raketab.schedule { run 'inclusive full', :on => monday..thursday }.tabs.should == '0 0 * * 1,2,3,4 inclusive full'
+    Raketab.schedule { run 'exclusive full', :on => monday...friday }.tabs.should  == '0 0 * * 1,2,3,4 exclusive full'
+    Raketab.schedule { run 'inclusive abbr', :on => mon..thu }.tabs.should         == '0 0 * * 1,2,3,4 inclusive abbr'
+    Raketab.schedule { run 'exclusive abbr', :on => mon...fri }.tabs.should        == '0 0 * * 1,2,3,4 exclusive abbr'
+  end
+  
+  it "should set the range of days across week boundry using weekday name methods" do
+    Raketab.schedule { run 'inclusive full', :on => thursday..monday }.tabs.should  == '0 0 * * 0,1,4,5,6 inclusive full'
+    Raketab.schedule { run 'exclusive full', :on => thursday...monday }.tabs.should == '0 0 * * 0,4,5,6 exclusive full'
+    Raketab.schedule { run 'inclusive abbr', :on => thu..mon }.tabs.should          == '0 0 * * 0,1,4,5,6 inclusive abbr'
+    Raketab.schedule { run 'exclusive abbr', :on => thu...mon }.tabs.should         == '0 0 * * 0,4,5,6 exclusive abbr'
+  end
+  
+  it "should set the time with just a number on at" do
+    Raketab.schedule { run 'test', :at => "5 o'clock" }.tabs.should == '0 5 * * * test'
+    Raketab.schedule { run 'test', :at => "5" }.tabs.should         == '0 5 * * * test'
+    Raketab.schedule { run 'test', :at => 5 }.tabs.should           == '0 5 * * * test'
+  end
+  
+  it "should handle multiple cron jobs" do
+    Raketab.schedule do
+       run '1st', :at => "5 o'clock" 
+       run '2nd', :on => :thursday
+    end.tabs.should == "0 5 * * * 1st\n0 0 * * 4 2nd"
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: did_craken
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Doug McInnes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-14 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Craken is a rails plugin for managing and installing rake-centric crontab files over Capistrano.
+email: 
+- didier@nocoffee.fr
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- lib/craken.rb
+- lib/enumeration.rb
+- lib/raketab.rb
+- README.rdoc
+- spec/craken_spec.rb
+- spec/enumeration_spec.rb
+- spec/raketab_spec.rb
+has_rdoc: true
+homepage: https://github.com/latimes/craken
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: A Rails plugin for managing and installing rake-centric crontab files.
+test_files: 
+- spec/craken_spec.rb
+- spec/enumeration_spec.rb
+- spec/raketab_spec.rb