vrinek-cronos 0.6.1

data/CHANGELOG

@@ -0,0 +1,30 @@
+== 0.6.1 2009-08-07
+- fixed README
+
+== 0.6.0 2009-08-07
+- added Cronos::Parser with syntax: Cronos::Parser.new(cron_string).now? => true or false
+
+== 0.5.1 2009-08-07
+- will try to combine multiple times eg. at(12, 15, '5:00 pm') will return "0 12,15,17 * * *"
+
+== 0.5.0 2009-08-07
+- can now use multiple times eg. at(12.30, 15.15, '5.20 pm')
+
+== 0.4.0 2009-03-06
+- every method now handles days and months eg. every(:mon, :tue), every('mon'..'wed'), every(:jan, :feb) etc.
+- added schedule method which takes a command and outputs it in the cron string
+
+== 0.3.1 2009-02-03
+- added ranges to #days
+
+== 0.3.0 2009-01-27
+- better range handling for #on and #of including support for end excluded ranges
+- aliased #of with #in
+- make #every more flexible to allow use with for days and months eg. every(:thursday, 'Friday') or every(:jan, :feb)
+- adde midnight and midday methods
+
+== 0.2.2 2009-01-17
+- fix to ensure string values in hash from to_hash method
+
+== 0.2.1 2009-01-17
+- added to_hash method with CronEdit compatible key names

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Adam Meehan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,83 @@
+= Cronos
+
+A Ruby DSL for outputting Cron intervals. 
+
+Using a natural syntax to write cron task intervals assists in generating the correct cron interval
+you are after instead of trying to remember the cron syntax and conventions.
+
+
+== Examples
+
+  cron = Cronos::Interval
+  
+  puts cron.new.hourly
+  # => '0 * * * *'
+
+  puts cron.new.daily
+  # => '0 0 * * *'
+  
+  puts cron.new.weekly
+  # => '0 0 * * 0'
+
+  puts cron.new.weekdays.at(12.30)
+  # => '30 12 * * 1-5'
+  
+  puts cron.new.weekends.at(12.30)
+  # => '30 12 * * 0,6'
+
+  puts cron.new.at('1.30pm').daily
+  # => '30 13 * * *'
+
+  puts cron.new.every(6).hours.on('15th').of(:january)
+  # => '0 0,6,12,18 15 1 *' 
+
+  puts cron.new.every(20).minutes.on('15th'..'18th').of(:jan, :feb, :mar)
+  # => '0,20,40 * 15-18 1,2,3 *'
+
+  puts cron.new.at(14.45).every(:monday, :tuesday)
+  # => '45 14 * * 1,2'
+
+
+You can also output the whole cron task string using the schedule method:
+
+  puts Cronos.schedule('some_task').every(:Sunday).at('3am')
+  # => '0 3 * * 0 some_task'
+
+This does not actually schedule the task in cron. Cronos is merely a DSL to output the cron intervals.
+
+== Caveats
+
+Certain combinations produce unintuitive results. They should be obvious but just in case I will
+list some. Such as
+
+  weekly.on_days(:monday, :tuesday) 
+
+Will actually run the task *twice* weekly
+
+TODO: more weird stuff?
+
+Also cron itself allows days of month and days of week to be set. These are independent of each other.
+
+For example:
+
+  on_the('15th').of(:jan).on_days(:mon, :tue)
+
+This will be run on the 15th of January AND every Monday and Tuesday of January, so be aware. Though it
+is a strange combination anyway, the result is the union of both and not the intersection.
+
+
+== Install
+
+  sudo gem install vrinek-cronos -s http://gems.github.com
+  
+
+== Credits
+
+Adam Meehan (http://duckpunching.com, adam.meehan@gmail.com)
+
+Kostas Karachalios (kostas.karachalios@gmail.com)
+
+
+== License
+
+Copyright (c) 2008 Adam Meehan, released under the MIT license

data/Rakefile

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+require 'spec/rake/spectask'
+require 'lib/cronos'
+
+GEM = "cronos"
+GEM_VERSION = Cronos::VERSION
+AUTHOR = "Adam Meehan"
+EMAIL = "adam.meehan@gmail.com"
+HOMEPAGE = "http://github.com/adzap/cronos"
+SUMMARY = "Tool for generating cron intervals using a natural syntax"
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.rdoc", "LICENSE", 'TODO', "CHANGELOG"]
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  
+  # Uncomment this to add a dependency
+  # s.add_dependency "foo"
+  
+  s.require_path = 'lib'
+  s.autorequire = GEM
+  s.files = %w(LICENSE README.rdoc Rakefile TODO CHANGELOG) + Dir.glob("{lib,spec}/**/*")
+end
+
+task :default => :spec
+
+desc "Run specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = %w(-fs --color)
+end
+
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end

data/TODO

@@ -0,0 +1,7 @@
+TODO:
+- more examples
+- more everything as its a start
+- default time setting, when time not explicit, instead of midnight
+- instantiate interval from cron string
+- say method to output English description as comment at end of cron interval
+

data/lib/cronos.rb

@@ -0,0 +1,396 @@
+module Cronos
+
+  VERSION = '0.6.1'
+
+  def self.schedule(task)
+    TaskInterval.new(task)
+  end
+
+  class Interval
+    attr_accessor :min, :hour, :day, :month, :dow
+
+    MONTHS = [nil, :jan, :feb, :mar, :apr, :may, :jun, :jul, :aug, :sep, :oct, :nov, :dec]
+
+    DAYS = [:sun, :mon, :tue, :wed, :thu, :fri, :sat]
+    
+=begin rdoc
+  Time:
+    at(12)
+    at(1.30)
+    at('01.30')
+    at(14.30)
+    at('2pm')
+    at('2:20')
+    at('5:15pm')
+    
+    at(12.30, '3.15 pm', 22, '15:30')
+  Note that the last one will return an array of cron strings
+=end
+    def at(*times)
+      @hours = []
+      @mins = []
+      
+      times.each do |time|
+        @hour, @min, meridian = parse_time(time)
+
+        raise "invalid hour value for 'at'" if @hour > 12 && meridian
+        raise "invalid minute value for 'at'" if @min > 59
+
+        case meridian
+        when 'am'
+          @hour = 0 if @hour == 12 
+        when 'pm'
+          @hour += 12 if @hour < 12
+        end
+
+        raise "invalid hour value for 'at'" if @hour > 23
+
+        @hours << @hour
+        @mins << @min
+      end
+      
+      self
+    end
+    
+=begin rdoc
+  Repeats an interval:
+    every(10).minutes
+    every(6).hours
+    every(2).months
+  
+  or use as an alias for #on or #days
+    every(:monday)
+    every(:mon, :tues)
+    every('Monday'.. 'Wednesday')
+    every('February', :march)
+    every('Feb'..'June')
+=end
+    def every(*multiple)
+      return RepeatInterval.new(multiple.first, self) if multiple.first.is_a?(Fixnum)
+
+      if multiple.all? {|abbr| is_month?(abbr) }
+        of(*multiple)
+      elsif multiple.all? {|abbr| is_day?(abbr) }
+        days(*multiple)
+      else
+        raise "Unknown interval type passed to #every"
+      end
+    end
+    
+=begin rdoc
+  Days of month:
+    on(13)
+    on('13th')
+    on(13..17)
+    on('13th'..'17th')
+    on(13...18)
+    on_the('13th')
+=end
+    def on(*args)
+      if args.first.is_a?(Range)
+        @day = format_range(args.first)
+      else
+        list = args.collect {|day| day.to_s.to_i }
+        @day = list.join(',')
+      end
+      self
+    end
+    alias on_the on
+    
+=begin rdoc
+  Days of the week:
+    days(:monday)
+    days('Monday')
+    days(:mon)
+    days(1..3)
+    days('mon'..'wed')
+    days(1...4)
+    on_day(:monday)
+    days(:mon, :tues)
+    on_days(:mon, :tues)
+=end
+    def days(*args)
+      if args.first.is_a?(Range)
+        @dow = format_range(args.first)
+      else
+        list = args.map {|day| day_value(day) unless day.is_a?(Fixnum) }
+        @dow = list.join(',')
+      end
+      self
+    end
+    alias on_days days
+    alias on_day days
+    
+=begin rdoc
+  Months:
+    of(:january)
+    of('January')
+    of(:jan)
+    of(:jan, :feb, :mar)
+    of(1..3)
+    of('jan'..'mar')
+    of(1...4)
+    of_months(1, 2, 3)
+    in(:january)
+=end
+    def of(*args)
+      if args.first.is_a?(Range)
+        @month = format_range(args.first)
+      else
+        list = args.map {|month| month_value(month) unless month.is_a?(Fixnum) }
+        @month = list.join(',')
+      end
+      self
+    end
+    alias of_months of
+    alias in of
+
+    def hourly
+      @min  = 0
+      @hour = nil
+      self
+    end
+
+    def daily
+      @min   ||= 0
+      @hour  ||= 0
+      @day   = nil
+      self
+    end
+    alias once_a_day daily
+
+    def midnight
+      @min  = 0
+      @hour = 0
+      self
+    end
+    alias at_midnight midnight
+
+    def midday
+      @min  = 0
+      @hour = 12
+      self
+    end
+    alias at_midday midday
+
+    def weekly
+      @min   ||= 0
+      @hour  ||= 0
+      @dow   ||= 0
+      @day   = nil
+      @month = nil
+      self
+    end
+    alias once_a_week weekly
+    
+    def monthly
+      @min   ||= 0
+      @hour  ||= 0
+      @day   ||= 1
+      @month = nil
+      @dow   = nil
+      self
+    end
+    alias once_a_month monthly
+
+    def weekdays
+      @min  ||= 0
+      @hour ||= 0
+      @dow  = '1-5'
+      self
+    end
+    
+    def weekends
+      @min  ||= 0
+      @hour ||= 0
+      @dow  = '0,6'
+      self
+    end
+    
+=begin rdoc
+  Returns the rules as a cron string (like the ones used in /etc/crontab)
+=end
+    def to_s
+      if @hours and @mins and @hours.length == @mins.length and @mins.length > 1
+        try_to_combine([@hours, @mins].transpose.collect do |hour, min|
+          cron_string hour, min
+        end)
+      else
+        cron_string
+      end
+    end
+    
+=begin rdoc
+  Returns the rules as a human-readable hash
+=end
+    def to_hash
+      if @hours and @mins and @hours.length == @mins.length and @mins.length > 1
+        [@hours, @mins].transpose.collect do |hour, min|
+          cron_hash hour, min
+        end
+      else
+        cron_hash
+      end
+    end
+
+    private
+    
+    def try_to_combine(cron_strings)
+      if (multiples = cron_strings.collect{ |str| str.split ' '}.transpose).select{ |a| a.uniq.length > 1}.length > 1
+        return cron_strings # no can do
+      elsif cron_strings.uniq.length == 1
+        cron_strings.first
+      else
+        multiples.collect{|a| a.uniq.join ","}.join ' '
+      end
+    end
+    
+    def cron_string(hour = nil, min = nil)
+      "#{min || @min || '*'} #{hour || @hour || '*'} #{day || '*'} #{month || '*'} #{dow || '*'}"
+    end
+    
+    def cron_hash(hour = nil, min = nil)
+      {
+        :minute  => "#{min   || @min  || '*'}",
+        :hour    => "#{hour  || @hour || '*'}",
+        :day     => "#{day   || '*'}",
+        :month   => "#{month || '*'}",
+        :weekday => "#{dow   || '*'}"
+      }
+    end
+    
+    def parse_time(time)
+      meridian = /pm|am/i.match(time.to_s)[0].downcase rescue nil
+      hour, min = *time.to_s.split(/[\.:]/)
+
+      hour = hour.to_i
+      min = min.strip.ljust(2, '0').to_i if min
+      min ||= 0
+
+      return hour, min, meridian
+    end
+
+    def format_range(range)
+      values = [range.first, range.last]
+
+      if values.all? {|v| v.to_i > 0 }
+        first, last = values.first.to_i, values.last.to_i
+      elsif values.all? {|abbr| is_month?(abbr) }
+        first, last = month_value(values.first), month_value(values.last)
+      elsif values.all? {|abbr| is_day?(abbr) }
+        first, last = day_value(values.first), day_value(values.last)
+      end
+
+      int_range = range.exclude_end? ? first...last : first..last
+      list = Array(int_range).sort
+      "#{list.first}-#{list.last}"
+    end
+
+    def is_month?(value)
+      MONTHS.include?(value.to_s.downcase[0..2].to_sym)
+    end
+
+    def month_value(value)
+      MONTHS.index(value.to_s.downcase[0..2].to_sym)
+    end
+
+    def is_day?(value)
+      DAYS.include?(value.to_s.downcase[0..2].to_sym)
+    end
+
+    def day_value(value)
+      DAYS.index(value.to_s.downcase[0..2].to_sym)
+    end
+
+    class RepeatInterval
+      def initialize(multiple, interval)
+        @multiple, @interval = multiple, interval
+      end
+
+      def minutes
+        raise 'Multiple of minutes will not fit into an hour' if (60 % @multiple) > 0
+        calculate_intervals(60)
+        @interval.min = self 
+        @interval
+      end
+      
+      def hours
+        raise 'Multiple of hours will not fit into a day' if (24 % @multiple) > 0
+        calculate_intervals(24)
+        @interval.min  = 0
+        @interval.hour = self 
+        @interval
+      end
+
+      def months
+        raise 'Multiple of months will not fit into a year' if (12 % @multiple) > 0
+        calculate_intervals(12, 1)
+        @interval.min  ||= 0
+        @interval.hour ||= 0
+        @interval.day  ||= 1
+        @interval.month = self 
+        @interval
+      end
+
+      def calculate_intervals(base, initial = 0)
+        repeats = (base / @multiple) - 1
+        set = [initial]
+        1.upto(repeats) {|factor| set << (factor * @multiple + initial) }
+        @intervals = set
+      end
+
+      def to_s
+        @intervals.join(',')
+      end
+
+      def to_a
+        @intervals
+      end
+    end
+  end
+  
+=begin rdoc
+  == Usage:
+    cron = Cronos::Interval.new.at('11pm').on_days(:monday, :tuesday).to_s # => '0 23 * * 1,2'
+    Cronos::Parser.new(cron).now? # => true or false
+=end
+  class Parser
+=begin rdoc
+  The cron_string should ideally come from Cronos::Interval#to_s
+=end
+    def initialize(cron_string)
+      @cron_string = cron_string
+    end
+    
+=begin rdoc
+  Returns true or false depending if the time matches the cron string given on initialization
+=end
+    def now?(time = Time.now)
+      min, hour, day, month, wday = @cron_string.split ' '
+      
+      [:min, :hour, :day, :month, :wday].all? do |period|
+        p = eval(period.to_s)
+        p == '*' or p.split(',').collect{ |parts|
+          if parts[/-/]
+            first, last = parts.split '-'
+            (first..last).to_a
+          else
+            parts
+          end
+        }.flatten.include? eval("time.#{period}").to_s
+      end
+    end
+  end
+  
+  class TaskInterval < Interval
+    attr_accessor :task
+
+    def initialize(task)
+      @task = task
+    end
+
+    def to_s
+      "#{super} #{@task}"
+    end
+  end
+end

data/spec/cronos_spec.rb

@@ -0,0 +1,482 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'activesupport'
+
+describe Cronos do
+
+  it "should return task interval instance from schedule method" do
+    Cronos.schedule('ls').should be_kind_of(Cronos::TaskInterval)
+  end
+
+end
+
+describe Cronos::Interval do
+
+  it "should return default interval for every minute" do
+    interval.to_s.should == '* * * * *'
+  end
+
+  it "should return hash of values from to_hash method" do
+    interval.at(2.01).on_the('3rd').of(:april).to_hash.should == {:minute => '1', :hour => '2', :day => '3', :month => '4', :weekday => '*'}
+  end
+
+  describe "at method" do
+    it "should output interval from integer with hour as integer value and 0 minute" do
+      interval.at(8).to_s.should == '0 8 * * *'
+    end
+
+    it "should output interval from a float with hour value from integer part and minute from decimal part" do
+      interval.at(8.21).to_s.should == '21 8 * * *'
+    end
+    
+    it "should output interval from a float with hour value from integer part and minute from decimal part left justified to 2 digits" do
+      interval.at(8.20).to_s.should == '20 8 * * *'
+    end
+
+    it "should output interval from time string with pm meridian having hour adjusted 24 hour time" do
+      interval.at('8.21pm').to_s.should == '21 20 * * *'
+    end
+    
+    it "should output interval from time string with pm meridian having hour unadjusted if hour is 12" do
+      interval.at('12.21pm').to_s.should == '21 12 * * *'
+    end
+
+    it "should output interval from time string with am meridian having hour adjusted to 0 if hour is 12" do
+      interval.at('12.21am').to_s.should == '21 0 * * *'
+    end
+
+    it "should raise error if hours out of range" do
+      lambda { interval.daily.at('24.21') }.should raise_error
+    end
+
+    it "should raise error if minutes out of range" do
+      lambda { interval.daily.at('23.60') }.should raise_error
+    end
+    
+    it "should output string interval for multiple times" do
+      interval.at(8, 10, 22).to_s.should == '0 8,10,22 * * *'
+      interval.at(8.20, 10.30, 22.55).to_s.should == ['20 8 * * *', '30 10 * * *', '55 22 * * *']
+    end
+    
+    it "should output a combined string interval for multiple times (that can be combined)" do
+      interval.at(8, 10, 22).to_s.should == '0 8,10,22 * * *'
+      interval.at(8.20, 10.20, 22.20).to_s.should == '20 8,10,22 * * *'
+      interval.at('8:20', 10.20, '10:20 pm').to_s.should == '20 8,10,22 * * *'
+
+      interval.at(8, 8, 8, 5).to_s.should == '0 8,5 * * *'
+    end
+    
+    it "should output string interval for mixed formats multiple times" do
+      interval.at('8:20 am', '10:30', '22:55', '5:15pm').to_s.should == ['20 8 * * *', '30 10 * * *', '55 22 * * *', '15 17 * * *']
+      interval.at(12.30, '3.15 pm', 22, '15:30').to_s.should == ['30 12 * * *', '15 15 * * *', '0 22 * * *', '30 15 * * *']
+    end
+    
+    it "should output hash interval for multiple times" do
+      interval.at(8, 10, 22).to_hash.should == [
+        {
+          :minute  => "0",
+          :hour    => "8",
+          :day     => "*",
+          :month   => "*",
+          :weekday => "*"
+        }, {
+          :minute  => "0",
+          :hour    => "10",
+          :day     => "*",
+          :month   => "*",
+          :weekday => "*"
+        }, {
+          :minute  => "0",
+          :hour    => "22",
+          :day     => "*",
+          :month   => "*",
+          :weekday => "*"
+        }
+      ]
+
+      interval.at(8.20, 10.30, 22.55).to_hash.should == [
+        {
+          :minute  => "20",
+          :hour    => "8",
+          :day     => "*",
+          :month   => "*",
+          :weekday => "*"
+        }, {
+          :minute  => "30",
+          :hour    => "10",
+          :day     => "*",
+          :month   => "*",
+          :weekday => "*"
+        }, {
+          :minute  => "55",
+          :hour    => "22",
+          :day     => "*",
+          :month   => "*",
+          :weekday => "*"
+        }
+      ]
+    end
+  end
+  
+  describe "on method" do
+    it "should output interval from integer with day of month as value" do
+      interval.on(15).to_s.should == '* * 15 * *'
+    end
+
+    it "should output interval from day string with ordinal suffix" do
+      interval.on('15th').to_s.should == '* * 15 * *'
+    end
+
+    it "should output interval from inclusive range as dashed day of month range " do
+      interval.on(15..17).to_s.should == '* * 15-17 * *'
+    end
+    
+    it "should output interval from string inclusive range as dashed day of month range " do
+      interval.on('15th'..'17th').to_s.should == '* * 15-17 * *'
+    end
+
+    it "should output interval from exclusive range as dashed day of month range " do
+      interval.on(15...18).to_s.should == '* * 15-17 * *'
+    end
+
+    it "should output interval from integer array as day number list" do
+      interval.on(15, 16, 17).to_s.should == '* * 15,16,17 * *'
+    end
+
+    it "should output interval from day string array as day number list" do
+      interval.on('15th', '16th', '17th').to_s.should == '* * 15,16,17 * *'
+    end
+  end
+
+  describe "of method" do
+    it "should output interval with month number from a symbol month name" do
+      interval.of(:january).to_s.should == '* * * 1 *'
+    end
+
+    it "should output interval with month number from a symbol short month name" do
+      interval.of(:jan).to_s.should == '* * * 1 *'
+    end
+
+    it "should output interval with month number from a strong month name" do
+      interval.of('January').to_s.should == '* * * 1 *'
+    end
+
+    it "should output interval with comma seperated month numbers from array of symbol month names" do
+      interval.of(:january, :february, :march).to_s.should == '* * * 1,2,3 *'
+    end
+
+    it "should output interval with comma seperated month numbers from array of short symbol month names" do
+      interval.of(:jan, :feb, :mar).to_s.should == '* * * 1,2,3 *'
+    end
+
+    it "should output interval with comma seperated month numbers from array of string month names" do
+      interval.of('January', 'February', 'March').to_s.should == '* * * 1,2,3 *'
+    end
+
+    it "should output interval from integer inclusive range as dashed month range " do
+      interval.of(1..3).to_s.should == '* * * 1-3 *'
+    end
+
+    it "should output interval from string inclusive range as dashed month range " do
+      interval.of('jan'..'mar').to_s.should == '* * * 1-3 *'
+    end
+
+    it "should output interval from integer exclusive range as dashed month range " do
+      interval.of(1...4).to_s.should == '* * * 1-3 *'
+    end
+  end
+
+  describe "days method" do
+    it "should output interval with day number from a symbol day name" do
+      interval.days(:monday).to_s.should == '* * * * 1'
+    end
+
+    it "should output interval with day number from a string day name" do
+      interval.days('Mondays').to_s.should == '* * * * 1'
+    end
+
+    it "should output interval with day number from a symbol short day name" do
+      interval.days(:mon).to_s.should == '* * * * 1'
+    end
+
+    it "should output interval with day numbers from array of symbol day names" do
+      interval.days(:monday, :wednesday, :friday).to_s.should == '* * * * 1,3,5'
+    end
+
+    it "should output interval with day numbers from array of symbol short day names" do
+      interval.days(:mon, :wed, :fri).to_s.should == '* * * * 1,3,5'
+    end
+
+    it "should output interval with day numbers from array of string day names" do
+      interval.days('Monday', 'Wednesday', 'Friday').to_s.should == '* * * * 1,3,5'
+    end
+
+    it "should output interval from integer inclusive range as dashed dow range " do
+      interval.days(1..3).to_s.should == '* * * * 1-3'
+    end
+
+    it "should output interval from string inclusive range as dashed dow range " do
+      interval.days('mon'..'wed').to_s.should == '* * * * 1-3'
+    end
+
+    it "should output interval from integer exclusive range as dashed dow range " do
+      interval.days(1...4).to_s.should == '* * * * 1-3'
+    end
+  end
+
+  describe "hourly method" do
+    it "should output interval to run at start of every hour" do
+      interval.hourly.to_s.should == '0 * * * *'
+    end
+
+    it "should only affect the hour and minutes" do
+      interval.day = 1
+      interval.month = 1
+      interval.dow = 1
+      interval.hourly.to_s.should == '0 * 1 1 1'
+    end
+  end
+
+  describe "daily method" do
+    it "should output interval to run at 00:00 every day by default" do
+      interval.daily.to_s.should == '0 0 * * *'
+    end
+
+    it "should only affect the hour, minutes and day" do
+      interval.month = 1
+      interval.dow = 1
+      interval.daily.to_s.should == '0 0 * 1 1'
+    end
+
+    it "should preserve hour and minutes if set" do
+      interval.min = 10
+      interval.hour = 11
+      interval.daily.to_s.should == '10 11 * * *'
+    end
+  end
+
+  describe "midnight method" do
+    it "should output interval to run at 00:00" do
+      interval.midnight.to_s.should == '0 0 * * *'
+    end
+  end
+
+  describe "midday method" do
+    it "should output interval to run at 12:00" do
+      interval.midday.to_s.should == '0 12 * * *'
+    end
+  end
+
+  describe "weekly method" do
+    it "should output interval to run on Sunday at 00:00 by default" do
+      interval.weekly.to_s.should == '0 0 * * 0'
+    end
+
+    it "should override day of month and month" do
+      interval.day = 1
+      interval.month = 1
+      interval.weekly.to_s.should == '0 0 * * 0'
+    end
+
+    it "should preserve hour, minute and day of week if set" do
+      interval.min = 10
+      interval.hour = 11
+      interval.dow = 1
+      interval.daily.to_s.should == '10 11 * * 1'
+    end
+  end
+
+  describe "monthly method" do
+    it "should output interval to run on the 1st day of every month at 00:00 by default" do
+      interval.monthly.to_s.should == '0 0 1 * *'
+    end
+
+    it "should override day of month and month" do
+      interval.day = 1
+      interval.month = 1
+      interval.monthly.to_s.should == '0 0 1 * *'
+    end
+
+    it "should preserve hour, minute and day if set" do
+      interval.min = 10
+      interval.hour = 11
+      interval.day = 12
+      interval.monthly.to_s.should == '10 11 12 * *'
+    end
+  end
+
+  describe "weekends method" do
+    it "should output interval to run at 00:00 every Saturday and Sunday" do
+      interval.weekends.to_s.should == '0 0 * * 0,6'
+    end
+  end
+
+  describe "weekdays method" do
+    it "should output interval to run at 00:00 every day Monday to Friday" do
+      interval.weekdays.to_s.should == '0 0 * * 1-5'
+    end
+  end
+
+  describe "every(x).minutes" do
+    it "should output interval for list of minutes differing by arg value" do
+      interval.every(15).minutes.to_s.should == '0,15,30,45 * * * *'
+    end
+
+    it "should raise error if x not a divisor of 60" do
+      lambda { interval.every(13).minutes }.should raise_error
+    end
+  end
+
+  describe "every(x).hours" do
+    it "should output interval for 0 minute and list of hours differing by arg value" do
+      interval.every(6).hours.to_s.should == '0 0,6,12,18 * * *'
+    end
+
+    it "should raise error if x not a divisor of 24" do
+      lambda { interval.every(13).minutes }.should raise_error
+    end
+  end
+
+  describe "every(x).months" do
+    it "should output interval for 00:00 on 1st day of month and list of months differing by arg value" do
+      interval.every(6).hours.to_s.should == '0 0,6,12,18 * * *'
+    end
+
+    it "should raise error if x not a divisor of 12" do
+      lambda { interval.every(7).minutes }.should raise_error
+    end
+  end
+  
+  describe "every(day_name)" do
+    it "should output interval for day symbol as day of week" do
+      interval.every(:sunday).to_s.should == '* * * * 0'
+    end
+
+    it "should output interval for list of days as days of week" do
+      interval.every(:thursay, 'Friday').to_s.should == '* * * * 4,5'
+    end
+  end
+
+  describe "every(month_name)" do
+    it "should output interval for month symbol as month" do
+      interval.every(:january).to_s.should == '* * * 1 *'
+    end
+
+    it "should output interval for list of months as months" do
+      interval.every(:february, 'March').to_s.should == '* * * 2,3 *'
+    end
+  end
+
+  describe "combinations" do
+    it "weekly.at(3.30) should output '30 3 * * 0'" do
+      interval.weekly.at(3.30).to_s.should == '30 3 * * 0'
+    end
+
+    it "monthly.at(3.30) should output '30 3 * * *'" do
+      interval.monthly.at(3.30).to_s.should == '30 3 1 * *'
+    end
+
+    it "monthly.on_the('15th').at(3.30) should output '30 3 15 * *'" do
+      interval.monthly.on_the('15th').at(3.30).to_s.should == '30 3 15 * *'
+    end
+
+    it "at('11pm').on_days(:monday, :tuesday) should output '0 11 * * 1,2'" do
+      interval.at('11pm').on_days(:monday, :tuesday).to_s.should == '0 23 * * 1,2'
+    end
+
+    it "on(15).of(:january) should output '* * 15 1 *'" do
+      interval.on(15).of(:january).to_s.should == '* * 15 1 *'
+    end
+
+    it "on(15, 16, 17).of(:january) should output '* * 15,16,17 1 *'" do
+      interval.on(15, 16, 17).of(:january).to_s.should == '* * 15,16,17 1 *'
+    end
+    
+    it "on(15..17).of(:january) should output '* * 15-17 1 *'" do
+      interval.on(15..17).of(:january).to_s.should == '* * 15-17 1 *'
+    end
+
+    it "on(15, 16, 17).of(:january) should output '* * 15 1,6,12 *'" do
+      interval.on(15).of(:jan, :jun, :dec).to_s.should == '* * 15 1,6,12 *'
+    end
+    
+    it "at('2.13pm').on_the_('15th').of(:january) should output '13 14 15 1'" do
+      interval.at('2.13pm').on_the(15).of(:january).to_s.should == '13 14 15 1 *'
+    end
+    
+    it "every(15).minutes.on_the('15th').of(:january) should output '0,15,30,45 * 15 1 *'" do
+      interval.every(15).minutes.on_the('15th').of(:january).to_s.should == '0,15,30,45 * 15 1 *'
+    end
+  end
+
+  def interval
+    @interval ||= Cronos::Interval.new
+  end
+end
+
+describe Cronos::TaskInterval do
+
+  it "should output task at end of interval string" do
+    Cronos::TaskInterval.new('ls').at('12pm').to_s.should == '0 12 * * * ls'
+  end
+
+end
+
+describe Cronos::Parser do
+  describe '#now?' do
+    it "should return true if cron_string is all stars" do
+      Cronos::Parser.new("* * * * *").now?(time).should == true
+      Cronos::Parser.new("* * * * *").now?.should == true
+    end
+
+    it "should return true if cron_string matches parts and rest is stars" do
+      Cronos::Parser.new("* 14 * * *").now?(time).should == true
+      Cronos::Parser.new("40 14 * * *").now?(time).should == true
+      Cronos::Parser.new("40 * * * *").now?(time).should == true
+      Cronos::Parser.new("40 * 5 * *").now?(time).should == true
+      Cronos::Parser.new("* * * 8 *").now?(time).should == true
+      Cronos::Parser.new("* 14 * 8 *").now?(time).should == true
+      Cronos::Parser.new("* 14 * * 3").now?(time).should == true
+    end
+
+    it "should return true if cron_string is in range" do
+      Cronos::Parser.new("* 10-20 * * *").now?(time).should == true
+      Cronos::Parser.new("30-50 10-20 * * *").now?(time).should == true
+      Cronos::Parser.new("30-50 * * * 1-5").now?(time).should == true
+    end
+
+    it "should return true if cron_string matches on a lists" do
+      Cronos::Parser.new("20,40 10,14,20 * * *").now?(time).should == true
+      Cronos::Parser.new("20,40 * 5,12 * *").now?(time).should == true
+      Cronos::Parser.new("20,40 14 5,12 * *").now?(time).should == true
+      Cronos::Parser.new("20,40 * 5,12 * 2,3,6").now?(time).should == true
+    end
+    
+    it "should return false if cron_string does not match some parts" do
+      Cronos::Parser.new("* 15 * * *").now?(time).should == false
+      Cronos::Parser.new("45 14 * * *").now?(time).should == false
+      Cronos::Parser.new("30 * * * *").now?(time).should == false
+      Cronos::Parser.new("40 * 6 * *").now?(time).should == false
+      Cronos::Parser.new("* * * 10 *").now?(time).should == false
+      Cronos::Parser.new("* 15 * 8 *").now?(time).should == false
+      Cronos::Parser.new("* 14 * 8 2").now?(time).should == false
+    end
+
+    it "should return false if cron_string is not in range" do
+      Cronos::Parser.new("* 20-25 * * *").now?(time).should == false
+      Cronos::Parser.new("10-30 10-20 * * *").now?(time).should == false
+      Cronos::Parser.new("* 10-20 * * 4-5").now?(time).should == false
+    end
+
+    it "should return false if cron_string does not match on a lists" do
+      Cronos::Parser.new("20,40 10,20 * * *").now?(time).should == false
+      Cronos::Parser.new("20,35 * 5,12 * *").now?(time).should == false
+      Cronos::Parser.new("20,40 14 3,8,12 * *").now?(time).should == false
+      Cronos::Parser.new("20,40 14 5,12 * 0,6").now?(time).should == false
+    end
+  end
+  
+  def time
+    @time ||= Time.local(2009, "aug", 5, 14, 40, 23) # day is Wednesday (3)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rubygems'
+require 'spec'
+require 'cronos'

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: vrinek-cronos
+version: !ruby/object:Gem::Version 
+  version: 0.6.1
+platform: ruby
+authors: 
+- Adam Meehan
+autorequire: cronos
+bindir: bin
+cert_chain: []
+
+date: 2009-08-07 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Tool for generating cron intervals using a natural syntax
+email: adam.meehan@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE
+- TODO
+- CHANGELOG
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- TODO
+- CHANGELOG
+- lib/cronos.rb
+- spec/cronos_spec.rb
+- spec/spec_helper.rb
+has_rdoc: false
+homepage: http://github.com/adzap/cronos
+licenses: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Tool for generating cron intervals using a natural syntax
+test_files: []
+