cronos 0.3.1 → 0.4.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7b7d4c5d68b641d07b172cafc2f63c7a789bb1e54e53dd19c5ac577a2bd1a9f9
+  data.tar.gz: d2f3391d9133ea6cbde4c4a0e61ceae775ebf69dbd7fe28997c83a0c2888177b
+SHA512:
+  metadata.gz: 76f985fe6e9b0431e54e5437f6ea8fe14971dad147aec7fd0bec11bda12d4fdd7282a90b54c567aa62ee0fce098c93765a1299cd208dd6cf2f326bc28ff8353d
+  data.tar.gz: e4db5b26f822054a3e71e125f290f60957de866f582ac36db3357d9b1f75145d7df897aff3e3e447dee001c0d157f71fc66f70630b4c5086f06e0e0c65f7cd86

data/CHANGELOG

@@ -1,3 +1,7 @@
+== 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
 

data/README.rdoc

@@ -10,33 +10,41 @@ you are after instead of trying to remember the cron syntax and conventions.
 
   cron = Cronos::Interval
   
-  cron.new.hourly.to_s 
+  puts cron.new.hourly
   # => '0 * * * *'
 
-  cron.new.daily.to_s 
+  puts cron.new.daily
   # => '0 0 * * *'
   
-  cron.new.weekly.to_s 
+  puts cron.new.weekly
   # => '0 0 * * 0'
 
-  cron.new.weekdays.at(12.30).to_s 
+  puts cron.new.weekdays.at(12.30)
   # => '30 12 * * 1-5'
   
-  cron.new.weekends.at(12.30).to_s
+  puts cron.new.weekends.at(12.30)
   # => '30 12 * * 0,6'
 
-  cron.new.at('1.30pm').daily.to_s
+  puts cron.new.at('1.30pm').daily
   # => '30 13 * * *'
 
-  cron.new.every(6).hours.on('15th').of(:january).to_s
+  puts cron.new.every(6).hours.on('15th').of(:january)
   # => '0 0,6,12,18 15 1 *' 
 
-  cron.new.every(20).minutes.on(15..18).of(:jan, :feb, :mar).to_s
+  puts cron.new.every(20).minutes.on('15th'..'18th').of(:jan, :feb, :mar)
   # => '0,20,40 * 15-18 1,2,3 *'
 
-  cron.new.at(14.45).on_days(:monday, :tuesday).to_s
+  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

data/TODO

@@ -1,3 +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/version.rb

@@ -0,0 +1,3 @@
+module Cronos
+  VERSION = '0.4.2'
+end

data/lib/cronos.rb

@@ -1,14 +1,22 @@
+require 'cronos/version'
+
 module Cronos
 
-  VERSION = '0.3.1'
+  def self.schedule(task)
+    TaskInterval.new(task)
+  end
 
   class Interval
     attr_accessor :min, :hour, :day, :month, :dow
 
-    MONTHS = [:jan, :feb, :mar, :apr, :may, :jun, :jul, :aug, :sep, :oct, :nov, :dec]
+    MONTHS = [nil, :jan, :feb, :mar, :apr, :may, :jun, :jul, :aug, :sep, :oct, :nov, :dec]
 
     DAYS = [:sun, :mon, :tue, :wed, :thu, :fri, :sat]
 
+    def initialize(interval=nil)
+      @min, @hour, @day, @month, @dow = *parse_cron(interval) if interval
+    end
+
     # Time:
     #   at(12)
     #   at(1.30)
@@ -19,14 +27,14 @@ module Cronos
     def at(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
+      raise ArgumentError, "invalid hour value for 'at'" if @hour > 12 && meridian
+      raise ArgumentError, "invalid minute value for 'at'" if @min > 59
         
       case meridian
-        when 'am': @hour = 0 if @hour == 12 
-        when 'pm': @hour += 12 if @hour < 12
+        when 'am' then @hour = 0 if @hour == 12
+        when 'pm' then @hour += 12 if @hour < 12
       end
-      raise "invalid hour value for 'at'" if @hour > 23
+      raise ArgumentError, "invalid hour value for 'at'" if @hour > 23
       self
     end
 
@@ -37,19 +45,20 @@ module Cronos
     #
     # or use as an alias for #on or #days
     #   every(:monday)
+    #   every(:mon, :tues)
+    #   every('Monday'.. 'Wednesday')
     #   every('February', :march)
+    #   every('Feb'..'June')
     #
     def every(*multiple)
-      return RepeatInterval.new(multiple.first, self) if multiple.first.is_a?(Fixnum)
+      return RepeatInterval.new(multiple.first, self) if multiple.first.is_a?(Numeric)
 
-      abbrs = multiple.map {|i| i.to_s.downcase[0..2].to_sym }
-
-      if abbrs.all? {|abbr| MONTHS.include?(abbr) }
-        of(*abbrs)
-      elsif abbrs.all? {|abbr| DAYS.include?(abbr) }
-        days(*abbrs)
+      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"
+        raise ArgumentError, "Unknown interval type passed to #every"
       end
     end
 
@@ -57,6 +66,7 @@ module Cronos
     #   on(13)
     #   on('13th')
     #   on(13..17)
+    #   on('13th'..'17th')
     #   on(13...18)
     #   on_the('13th')
     #
@@ -76,6 +86,7 @@ module Cronos
     #   days('Monday')
     #   days(:mon)
     #   days(1..3)
+    #   days('mon'..'wed')
     #   days(1...4)
     #   on_day(:monday)
     #   days(:mon, :tues)
@@ -85,7 +96,7 @@ module Cronos
       if args.first.is_a?(Range)
         @dow = format_range(args.first)
       else
-        list = args.map {|day| DAYS.index(day.to_s.downcase[0..2].to_sym) }
+        list = args.map {|day| day_value(day) unless day.is_a?(Numeric) }
         @dow = list.join(',')
       end
       self
@@ -99,6 +110,7 @@ module Cronos
     #   of(:jan)
     #   of(:jan, :feb, :mar)
     #   of(1..3)
+    #   of('jan'..'mar')
     #   of(1...4)
     #   of_months(1, 2, 3)
     #   in(:january)
@@ -107,7 +119,7 @@ module Cronos
       if args.first.is_a?(Range)
         @month = format_range(args.first)
       else
-        list = args.map {|month| MONTHS.index(month.to_s.downcase[0..2].to_sym) + 1 unless month.is_a?(Fixnum) }
+        list = args.map {|month| month_value(month) unless month.is_a?(Numeric) }
         @month = list.join(',')
       end
       self
@@ -193,6 +205,12 @@ module Cronos
 
     private
 
+    def parse_cron(string)
+      parts = string.squeeze(' ').split(' ')
+      parts.collect! {|p| Integer(p) rescue p == '*' ? nil : p }
+      parts[0..4]
+    end
+
     def parse_time(time)
       meridian = /pm|am/i.match(time.to_s)[0].downcase rescue nil
       hour, min = *time.to_s.split('.')
@@ -205,10 +223,37 @@ module Cronos
     end
 
     def format_range(range)
-      list = Array(range).sort
+      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)
@@ -216,14 +261,16 @@ module Cronos
       end
 
       def minutes
-        raise 'Multiple of minutes will not fit into an hour' if (60 % @multiple) > 0
+        raise ArgumentError, '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
+        raise ArgumentError, 'Multiple of hours will not fit into a day' if (24 % @multiple) > 0
+
         calculate_intervals(24)
         @interval.min  = 0
         @interval.hour = self 
@@ -231,7 +278,8 @@ module Cronos
       end
 
       def months
-        raise 'Multiple of months will not fit into a year' if (12 % @multiple) > 0
+        raise ArgumentError, 'Multiple of months will not fit into a year' if (12 % @multiple) > 0
+
         calculate_intervals(12, 1)
         @interval.min  ||= 0
         @interval.hour ||= 0
@@ -258,4 +306,20 @@ module Cronos
 
   end
 
+  class TaskInterval < Interval
+    attr_accessor :task
+
+    def initialize(task)
+      @task = task
+    end
+
+    def to_s
+      "#{super} #{@task}"
+    end
+
+    def to_hash
+      super.merge(:command => task)
+    end
+  end
+
 end

data/spec/cronos_spec.rb

@@ -1,325 +1,353 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
+describe Cronos do
+
+  it "should return task interval instance from schedule method" do
+    expect(Cronos.schedule('ls')).to be_kind_of(Cronos::TaskInterval)
+  end
+
+  it "should return task interval hash with command" do
+    expect(Cronos.schedule('ls').at('8.00am').to_hash[:command]).to eq('ls')
+  end
+end
+
 describe Cronos::Interval do
 
   it "should return default interval for every minute" do
-    interval.to_s.should == '* * * * *'
+    expect(interval.to_s).to eq('* * * * *')
   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 => '*'}
+    expect(interval.at(2.01).on_the('3rd').of(:april).to_hash).to eq({:minute => '1', :hour => '2', :day => '3', :month => '4', :weekday => '*'})
+  end
+
+  it "should instantiate interval from cron string" do
+    cron_string = '30 12 * * 0'
+    expect(Cronos::Interval.new(cron_string).to_s).to eq(cron_string)
   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 * * *'
+      expect(interval.at(8).to_s).to eq('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 * * *'
+      expect(interval.at(8.21).to_s).to eq('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 * * *'
+      expect(interval.at(8.20).to_s).to eq('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 * * *'
+      expect(interval.at('8.21pm').to_s).to eq('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 * * *'
+      expect(interval.at('12.21pm').to_s).to eq('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 * * *'
+      expect(interval.at('12.21am').to_s).to eq('21 0 * * *')
     end
 
     it "should raise error if hours out of range" do
-      lambda { interval.daily.at('24.21') }.should raise_error
+      expect { interval.daily.at('24.21') }.to raise_error(ArgumentError)
     end
 
     it "should raise error if minutes out of range" do
-      lambda { interval.daily.at('23.60') }.should raise_error
+      expect { interval.daily.at('23.60') }.to raise_error(ArgumentError)
     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 * *'
+      expect(interval.on(15).to_s).to eq('* * 15 * *')
     end
 
     it "should output interval from day string with ordinal suffix" do
-      interval.on('15th').to_s.should == '* * 15 * *'
+      expect(interval.on('15th').to_s).to eq('* * 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 * *'
+      expect(interval.on(15..17).to_s).to eq('* * 15-17 * *')
     end
     
+    it "should output interval from string inclusive range as dashed day of month range " do
+      expect(interval.on('15th'..'17th').to_s).to eq('* * 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 * *'
+      expect(interval.on(15...18).to_s).to eq('* * 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 * *'
+      expect(interval.on(15, 16, 17).to_s).to eq('* * 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 * *'
+      expect(interval.on('15th', '16th', '17th').to_s).to eq('* * 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 *'
+      expect(interval.of(:january).to_s).to eq('* * * 1 *')
     end
 
     it "should output interval with month number from a symbol short month name" do
-      interval.of(:jan).to_s.should == '* * * 1 *'
+      expect(interval.of(:jan).to_s).to eq('* * * 1 *')
     end
 
     it "should output interval with month number from a strong month name" do
-      interval.of('January').to_s.should == '* * * 1 *'
+      expect(interval.of('January').to_s).to eq('* * * 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 *'
+      expect(interval.of(:january, :february, :march).to_s).to eq('* * * 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 *'
+      expect(interval.of(:jan, :feb, :mar).to_s).to eq('* * * 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 *'
+      expect(interval.of('January', 'February', 'March').to_s).to eq('* * * 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 *'
+      expect(interval.of(1..3).to_s).to eq('* * * 1-3 *')
+    end
+
+    it "should output interval from string inclusive range as dashed month range " do
+      expect(interval.of('jan'..'mar').to_s).to eq('* * * 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 *'
+      expect(interval.of(1...4).to_s).to eq('* * * 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'
+      expect(interval.days(:monday).to_s).to eq('* * * * 1')
     end
 
     it "should output interval with day number from a string day name" do
-      interval.days('Mondays').to_s.should == '* * * * 1'
+      expect(interval.days('Mondays').to_s).to eq('* * * * 1')
     end
 
     it "should output interval with day number from a symbol short day name" do
-      interval.days(:mon).to_s.should == '* * * * 1'
+      expect(interval.days(:mon).to_s).to eq('* * * * 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'
+      expect(interval.days(:monday, :wednesday, :friday).to_s).to eq('* * * * 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'
+      expect(interval.days(:mon, :wed, :fri).to_s).to eq('* * * * 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'
+      expect(interval.days('Monday', 'Wednesday', 'Friday').to_s).to eq('* * * * 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'
+      expect(interval.days(1..3).to_s).to eq('* * * * 1-3')
+    end
+
+    it "should output interval from string inclusive range as dashed dow range " do
+      expect(interval.days('mon'..'wed').to_s).to eq('* * * * 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'
+      expect(interval.days(1...4).to_s).to eq('* * * * 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 * * * *'
+      expect(interval.hourly.to_s).to eq('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'
+      expect(interval.hourly.to_s).to eq('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 * * *'
+      expect(interval.daily.to_s).to eq('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'
+      expect(interval.daily.to_s).to eq('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 * * *'
+      expect(interval.daily.to_s).to eq('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 * * *'
+      expect(interval.midnight.to_s).to eq('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 * * *'
+      expect(interval.midday.to_s).to eq('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'
+      expect(interval.weekly.to_s).to eq('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'
+      expect(interval.weekly.to_s).to eq('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'
+      expect(interval.daily.to_s).to eq('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 * *'
+      expect(interval.monthly.to_s).to eq('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 * *'
+      expect(interval.monthly.to_s).to eq('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 * *'
+      expect(interval.monthly.to_s).to eq('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'
+      expect(interval.weekends.to_s).to eq('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'
+      expect(interval.weekdays.to_s).to eq('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 * * * *'
+      expect(interval.every(15).minutes.to_s).to eq('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
+      expect { interval.every(13).minutes }.to raise_error(ArgumentError)
     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 * * *'
+      expect(interval.every(6).hours.to_s).to eq('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
+      expect { interval.every(13).minutes }.to raise_error(ArgumentError)
     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 * * *'
+      expect(interval.every(6).hours.to_s).to eq('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
+      expect { interval.every(7).minutes }.to raise_error(ArgumentError)
     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'
+      expect(interval.every(:sunday).to_s).to eq('* * * * 0')
     end
 
     it "should output interval for list of days as days of week" do
-      interval.every(:thursay, 'Friday').to_s.should == '* * * * 4,5'
+      expect(interval.every(:thursay, 'Friday').to_s).to eq('* * * * 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 *'
+      expect(interval.every(:january).to_s).to eq('* * * 1 *')
     end
 
     it "should output interval for list of months as months" do
-      interval.every(:february, 'March').to_s.should == '* * * 2,3 *'
+      expect(interval.every(:february, 'March').to_s).to eq('* * * 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'
+      expect(interval.weekly.at(3.30).to_s).to eq('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 * *'
+      expect(interval.monthly.at(3.30).to_s).to eq('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 * *'
+      expect(interval.monthly.on_the('15th').at(3.30).to_s).to eq('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'
+      expect(interval.at('11pm').on_days(:monday, :tuesday).to_s).to eq('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 *'
+      expect(interval.on(15).of(:january).to_s).to eq('* * 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 *'
+      expect(interval.on(15, 16, 17).of(:january).to_s).to eq('* * 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 *'
+      expect(interval.on(15..17).of(:january).to_s).to eq('* * 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 *'
+      expect(interval.on(15).of(:jan, :jun, :dec).to_s).to eq('* * 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 *'
+      expect(interval.at('2.13pm').on_the(15).of(:january).to_s).to eq('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 *'
+      expect(interval.every(15).minutes.on_the('15th').of(:january).to_s).to eq('0,15,30,45 * 15 1 *')
     end
   end
 
@@ -327,3 +355,11 @@ describe Cronos::Interval do
     @interval ||= Cronos::Interval.new
   end
 end
+
+describe Cronos::TaskInterval do
+
+  it "should output task at end of interval string" do
+    expect(Cronos::TaskInterval.new('ls').at('12pm').to_s).to eq('0 12 * * * ls')
+  end
+
+end

data/spec/spec_helper.rb

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

metadata

@@ -1,63 +1,67 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: cronos
-version: !ruby/object:Gem::Version 
-  version: 0.3.1
+version: !ruby/object:Gem::Version
+  version: 0.4.2
 platform: ruby
-authors: 
+authors:
 - Adam Meehan
-autorequire: cronos
+autorequire:
 bindir: bin
 cert_chain: []
-
-date: 2009-02-03 00:00:00 +11:00
-default_executable: 
-dependencies: []
-
-description: Tool for generating cron intervals using a natural syntax
+date: 2022-03-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A builder DSL for generating cron intervals using a human readable English
+  syntax
 email: adam.meehan@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- README.rdoc
-- LICENSE
-- TODO
+extra_rdoc_files: []
+files:
 - CHANGELOG
-files: 
 - LICENSE
 - README.rdoc
 - Rakefile
 - TODO
-- CHANGELOG
 - lib/cronos.rb
-- spec/spec_helper.rb
+- lib/cronos/version.rb
 - spec/cronos_spec.rb
-has_rdoc: true
+- spec/spec_helper.rb
 homepage: http://github.com/adzap/cronos
-post_install_message: 
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/adzap/cronos
+post_install_message:
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
+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'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: 
-rubygems_version: 1.3.1
-signing_key: 
-specification_version: 2
+rubygems_version: 3.0.3.1
+signing_key:
+specification_version: 4
 summary: Tool for generating cron intervals using a natural syntax
 test_files: []
-