recurring 0.1.0

data/History.txt

@@ -0,0 +1,5 @@
+== 0.1.0 / 2006-12-09
+
+* Initial releast
+  * Handles the basic API: include? find_in_range
+

data/Manifest.txt

@@ -0,0 +1,6 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/recurring.rb
+spec/recurring_spec.rb

data/README.txt

@@ -0,0 +1,65 @@
+Recurring::Schedule
+    by Chris Anderson
+    http://recurring.rubyforge.org
+
+== DESCRIPTION:
+  
+Recurring allows you to define Schedules, which can tell you whether or not a given Time falls in the Schedule, as well as being able to return a list of times which match the Schedule within a given range.
+
+Schedules can be like:
+* Every Tuesday at 5pm
+* The 1st and 15th of every other month
+* Every 2 hours
+* The first Friday of every month at 11:15am and 4:45:15pm
+
+== FEATURES/PROBLEMS:
+  
+= Features
+  * Fast searching of long ranges for matching times.
+  * Ability to define Schedules in a few flexible ways.
+  * Extensive RSpec specifications (run "rake spec" to see them)
+  * Extensive RSpec specifications (run "rake spec" to see them)
+
+= Problems / Todo
+  * Untested timezone support
+  * Plans to offer complex Schedule and Masks
+
+== SYNOPSYS:
+
+  # This Schedule will match every Tuesday at 5pm
+    @rs = Recurring::Schedule.new :unit => 'weeks', :weekdays => 'tuesday', :times => '5pm'
+    @rs.include?(Time.utc(2006,12,12,17)) #=> true
+    @rs.include?(Time.utc(2006,12,13,17)) #=> false 
+
+== REQUIREMENTS:
+
+* RSpec >= 0.7.4 to run the specs.
+
+== INSTALL:
+
+* just run <tt>gem install recurring</tt>
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2006 Chris Anderson
+
+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/Rakefile

@@ -0,0 +1,25 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+#require_gem 'rspec'
+#require 'rspec/lib/spec/rake/spectask'
+require './lib/recurring.rb'
+
+Hoe.new('recurring', Recurring::VERSION) do |p|
+  p.rubyforge_name = 'recurring'
+  p.summary = 'A scheduling library for recurring events'
+  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end
+
+desc "Run the specs"
+task :spec do
+  system "spec spec/recurring_spec.rb -f specdoc"
+end
+#Spec::Rake::SpecTask.new('spec') do |t|
+#  t.spec_files = FileList['examples/**/*.rb']
+#end
+
+# vim: syntax=Ruby

data/lib/recurring.rb

@@ -0,0 +1,304 @@
+module Recurring
+  VERSION = '0.1.0'
+
+  class << self
+    # returns a number starting with 1
+    def week_in_month date
+      (((date.day - 1).to_f / 7.0) + 1).floor
+    end
+
+    # just a wrapper for strftime
+    def week_of_year date
+    	date.strftime('%U').to_i
+    end
+  end
+  
+  
+  # Initialize a Schedule object with the proper options to calculate occurances in 
+  # that schedule. Schedule#new take a hash of options <tt>:unit, :frequency, :anchor, :weeks, :monthdays, :weekdays, :times</tt>
+  #
+  # =  Monthly
+  # [Every two months from an anchor time] <tt>Recurring::Schedule.new :unit => 'months', :frequency => 2, :anchor => Time.utc(2006,4,15,10,30)</tt>
+  # [The first and fifteenth of every month] <tt>Recurring::Schedule.new :unit => 'months', :monthdays => [1,15]</tt>
+  # [The first and eighteenth of every third month] <tt>Recurring::Schedule.new :unit => 'months', :frequency => 3, :anchor => Time.utc(2006,4,15,10,30), :monthdays => [10,18]</tt>
+  # [The third Monday of every month at 6:30pm] <tt>Recurring::Schedule.new :unit => 'months', :weeks => 3, :weekdays => :monday, :times => '6:30pm'</tt>
+  # =  Weekly
+  # [Monday, Wednesday, and Friday of every week] <tt>Recurring::Schedule.new :unit => 'weeks', :weekdays => %w{monday weds friday}</tt>
+  # [Every week at the same time on the same day of the week as the anchor (Weds at 5:30pm)] <tt>Recurring::Schedule.new :unit => 'weeks', :anchor => Time.utc(2006,12,6,17,30)</tt>
+  # [Equivalently, Every Wednesday at 5:30] <tt>Recurring::Schedule.new :unit => 'weeks', :weekdays => 'weds', :times => '5:30pm'</tt>
+  # =  Daily
+  # [Everyday at the time of the anchor] <tt>Recurring::Schedule.new :unit => 'days', :anchor => Time.utc(2006,11,1,10,15,22)</tt>
+  # [Everyday at 7am and 5:45:20pm] <tt>Recurring::Schedule.new :unit => 'days', :times => '7am 5:45:20pm'</tt>
+  # =  Hourly
+  # [Every hour at 15 minutes, 30 minutes, and 45 minutes and 30 seconds] <tt>Recurring::Schedule.new :unit => 'hours', :times => '0:15 4:30 0:45:30'</tt>
+  # [Offset every 2 hours from the anchor] <tt>Recurring::Schedule.new :unit => 'hours', :anchor => Time.utc(2001,5,15,11,17)</tt>
+  # =  Minutely
+  # [Every five minutes offset from the anchor] <tt>Recurring::Schedule.new :unit => 'minutes', :frequency => 5, :anchor => Time.utc(2006,9,1,10,30)</tt>
+  # [Every minute at second 15] <tt>Recurring::Schedule.new :unit => 'minutes', :times => '0:0:15'</tt>
+  # 
+  # See the specs using "rake spec" for even more examples.
+    class Schedule
+    
+    attr_reader :unit, :frequency, :anchor, :weeks, :monthdays, :weekdays, :times
+    
+    # * options is a hash with keys <tt>:unit, :frequency, :anchor, :weeks, :monthdays, :weekdays, :times</tt>
+    # * valid units are <tt>months, weeks, days, hours, and minutes</tt>
+    # * :frequency defaults to 1
+    # * :anchor is required if the frequency is other than one
+    # * :weeks alongside :weekdays is used to specify the nth instance of a weekday in a month. 
+    # * :weekdays takes an array of strings like <tt>%w{monday weds friday}</tt>
+    # * :monthdays takes an array of days of the month, eg. <tt>[1,7,15]</tt>
+    # * :times takes a string with a simple format. <tt>"4pm 5:15pm 6:45:30pm"</tt>
+    def initialize options
+      raise ArgumentError, 'specify a valid unit' unless options[:unit] &&
+        %w{months weeks days hours minutes}.include?(options[:unit])
+      raise ArgumentError, 'frequency > 1 requires an anchor Time' if options[:frequency] && !options[:anchor]
+      @unit = options[:unit].to_sym
+      @frequency = options[:frequency] || 1
+      @anchor = options[:anchor]
+      @times = parse_times options[:times]
+      @weeks = Array(options[:weeks]) if options[:weeks]
+      @weekdays = Array(options[:weekdays]).collect{|d|d.to_sym} if options[:weekdays]
+      @monthdays = Array(options[:monthdays]) if options[:monthdays]
+      
+      @anchor_multiple = options[:times].nil? && options[:weeks].nil? && options[:weekdays].nil? && options[:monthdays].nil?
+    end
+    
+    
+    # Returns true or false depending on whether or not the time is included in the schedule.
+    def include? date
+      @resolution = nil	
+      return true if check_anchor? && date == @anchor 
+      return mismatch(:month) unless month_matches?(date) if @unit == :months
+      return mismatch(:week) unless week_matches?(date) if [:months, :weeks].include?(@unit)
+      if [:months, :weeks, :days].include?(@unit)
+        return mismatch(:day) unless day_matches?(date)
+	      return mismatch(:time) unless time_matches?(date)
+      end
+      if @unit == :hours
+	      return mismatch(:hour) unless hour_matches?(date)
+	      return mismatch(:sub_hour) unless sub_hour_matches?(date)
+      end
+      if @unit == :minutes
+	      return mismatch(:minute) unless minute_matches?(date)
+	      return mismatch(:second) unless second_matches?(date)
+      end
+      @resolution = nil	
+      true
+    end
+
+    # Starts from the argument, and returns the next included time. Returns the argument if it is included in the schedule.
+    def find_next date
+      loop do
+      	return date if include?(date)
+      	date = beginning_of_next @resolution, date
+      end
+    end
+    
+    # Takes a range, which can specified as two Times, or as an object that returns times from the methods .first and .last
+    #
+    # <tt>rs.find_in_range(Time.now, Time.now+24*60*60)</tt>
+    #
+    # or
+    #
+    # <tt>range = (Time.now..Time.now+24*60*60)</tt>
+    #
+    # <tt>rs.find_in_range(range)</tt>
+    def find_in_range *range
+      range = range[0] if range.length == 1
+      start = range.first
+      result = []
+      loop do
+        rnext = find_next start
+        break if rnext > range.last
+        result << rnext
+        start = rnext + 1
+      end
+      result
+    end
+
+    # Two Schedules are equal if they have the same attributes.
+    def == other
+      [:unit, :frequency, :anchor, :weeks, :monthdays, :weekdays, :times].all? do |attribute|
+        self.send(attribute) == other.send(attribute)
+      end
+    end
+
+    private
+
+      def beginning_of_next scope, date
+  	    case scope
+  	    when :year
+  	      Time.utc(date.year + 1)
+      	when :month
+      	  date.month < 12 ? Time.utc(date.year, date.month+1) : beginning_of_next(:year, date)
+      	when :week
+      	  to_sunday = 7 - date.wday
+      	  next_week = (date + to_sunday*24*60*60)
+      	  Time.utc(next_week.year, next_week.month, next_week.day)
+      	when :day
+      	  dayp = date + (24*60*60)
+      	  Time.utc(dayp.year, dayp.month, dayp.day)
+      	when :time
+      	  next_time date
+      	else
+      	  date + 1
+      	end
+      end
+
+      def next_time date
+      	me = {:hour => date.hour, :minute => date.min, :second => date.sec, :me => true}      
+      	my_times = times + [me]
+      	my_times += [{:hour => @anchor.hour, :minute => @anchor.min, :second => @anchor.sec}] if check_anchor?
+      	my_times.sort! do |a,b|
+      	  v = a[:hour] <=> b[:hour]
+      	  v = a[:minute] <=> b[:minute] if v == 0
+      	  v = a[:second] <=> b[:second] if v == 0
+      	  v
+      	end
+      	ntime = my_times[my_times.index(me)+1]
+      	if ntime
+      	  Time.utc(date.year, date.month, date.day, ntime[:hour], ntime[:minute], ntime[:second])
+      	else
+      	  beginning_of_next :day, date
+      	end
+      end
+
+      def mismatch unit
+	      @resolution = unit
+	      false
+      end
+
+      def month_matches? date
+      	#only concerned with multiples
+      	return true if @frequency == 1
+      	(date.month - @anchor.month) % @frequency == 0
+      end
+
+      def week_matches? date
+	      if @unit == :weeks 
+      	  return true if @frequency == 1
+      	  return (Recurring.week_of_year(date) - Recurring.week_of_year(@anchor)) % @frequency == 0
+      	end
+      	if @weeks
+      	  @weeks.include?(Recurring.week_in_month(date))
+      	else
+      	  true
+      	end
+      end
+
+      def day_matches? date
+      	if @unit == :days 
+      	  return true if @frequency == 1
+      	  return (date.day - @anchor.day) % @frequency == 0
+      	end
+      	return @monthdays.include?(date.day) if @monthdays
+      	if @weekdays
+      	  day_nums = @weekdays.collect{|w| ordinal_weekday w}
+      	  return day_nums.include?(date.wday)
+      	end
+      	if @unit == :weeks && check_anchor?
+      	  return @anchor.wday == date.wday    
+      	end
+      	return true if check_anchor? && date.day == @anchor.day
+      end
+
+      def time_matches? date
+      	#concerned with groups of hour minute second
+      	if check_anchor? 
+      	  return @anchor.hour == date.hour && @anchor.min == date.min && @anchor.sec == date.sec
+      	end
+      	@times.any? do |time|
+      	  time[:hour] == date.hour && time[:minute] == date.min && time[:second] == date.sec
+      	end
+      end
+
+      def hour_matches? date
+      	#only concerned with multiples
+      	return true if @frequency == 1
+      	(date.hour - @anchor.hour) % @frequency == 0
+      end
+
+      def sub_hour_matches? date
+      	if check_anchor? 
+      	  return @anchor.min == date.min && @anchor.sec == date.sec
+      	end
+      	times.any? do |time|
+      	  time[:minute] == date.min && time[:second] == date.sec
+      	end
+      end
+
+      def minute_matches? date
+      	#only concerned with multiples
+      	return true if @frequency == 1
+      	(date.min - @anchor.min) % @frequency == 0
+      end
+
+      def second_matches? date
+	      if check_anchor? 
+	        return @anchor.sec == date.sec
+	      end
+	      times.any? do |time|
+	        time[:second] == date.sec
+	      end
+      end
+
+      def check_anchor?
+	      @anchor && @anchor_multiple
+      end
+
+      def ordinal_weekday symbol
+	      lookup = {0 => [:sunday, :sun],
+                1 => [:monday, :mon],
+                2 => [:tuesday, :tues],
+                3 => [:wednesday, :weds],
+                4 => [:thursday, :thurs],
+                5 => [:friday, :fri],
+                6 => [:saturday, :sat]}
+	      lookup.select{|k,v| v.include?(symbol)}.first.first
+      end
+    
+    # def ordinal_month symbol
+    #   lookup = {1 => [:january, :jan],
+    #             2 => [:february, :feb],
+    #             3 => [:march, :mar],
+    #             4 => [:april, :apr],
+    #             5 => [:may],
+    #             6 => [:june, :jun],
+    #             7 => [:july, :jul],
+    #             8 => [:august, :aug],
+    #             9 => [:september, :sept],
+    #             10 => [:october, :oct],
+    #             11 => [:november, :nov],
+    #             12 => [:december, :dec]}
+    #   lookup.select{|k,v| v.include?(symbol)}.first.first
+    # end
+
+      def parse_times string
+      	unless string
+      	  return [{:hour => 0, :minute => 0, :second => 0}]
+      	end
+      	times = string.downcase.gsub(',','').split(' ')
+      	parsed = times.collect do |st|
+    	  st = st.gsub /pm|am/, ''
+    	  am_pm = $&
+    	  time = {}
+    	  time[:hour], time[:minute], time[:second] = st.split(':').collect {|n| n.to_i}
+    	  time[:minute] ||= 0
+    	  time[:second] ||= 0
+    	  time[:hour] = time[:hour] + 12 if am_pm == 'pm'
+    	  time
+	    end
+	    parsed
+    end  
+  end
+end
+
+  
+# RDS does not match ranges as such, just times specified to varying precision
+# eg, you can construct a Schedule that matches all of February, by not specifying the 
+# week, day, or time. If you want February through August, you'll have to specify all the months
+# individually.
+
+# Change of Behaviour in Recurring: Schedules include only points in time. The Mask model handles ranges.
+

data/spec/recurring_spec.rb

@@ -0,0 +1,602 @@
+require 'rubygems'
+require_gem 'rspec'
+require File.dirname(__FILE__) + "/../lib/recurring"
+require 'yaml'
+
+def results_should_be_included results, schedule
+  results.each do |t|
+    schedule.should_include t
+  end
+end
+
+def should_find_in_range schedule, length, *range
+  result = schedule.find_in_range(range.first, range.last)
+  result.length.should_be length
+  results_should_be_included result, schedule
+end
+
+context "Initializing a Schedule" do
+ 
+  specify "should accept the frequency, unit, and anchor params" do
+    rs = Recurring::Schedule.new :unit => 'days', :frequency => 2, :anchor => Time.utc(2006,8,11)
+    rs.unit.should_be :days
+    rs.frequency.should_be 2
+    rs.anchor.should == Time.utc(2006,8,11)
+  end
+
+  specify "should check for valid units" do
+    lambda{@rs = Recurring::Schedule.new :unit => 'day', :times => '4:29am'}.should_raise ArgumentError
+  end
+
+  specify "should parse the time param" do
+    rs = Recurring::Schedule.new :unit => 'days', :times => '4:30pm 5pm 3:30:30'
+    rs.times.should == [{:hour => 16, :minute => 30, :second => 0}, {:hour => 17, :minute => 0, :second => 0}, {:hour => 3, :minute => 30, :second => 30}] 
+  end
+  
+  specify "should provide a sensible default time param" do
+    rs = Recurring::Schedule.new :unit => 'days'
+    rs.times.should == [{:hour => 0, :minute => 0, :second => 0}]
+  end
+ 
+  specify "should flip out if the units are not provided" do
+    lambda{Recurring::Schedule.new :argument => 'no units, dogg'}.should_raise ArgumentError
+  end
+ 
+  specify "should accept weeks and days params" do
+    rs = Recurring::Schedule.new :unit => 'months', :weeks => [1,2], :weekdays => %w{monday wednesday}
+    rs.weeks.should == [1,2]
+    rs.weekdays.should == [:monday, :wednesday]
+  end
+
+  specify "should accept days as integers" do
+    rs = Recurring::Schedule.new :unit => 'months', :monthdays => [1,15]
+    rs.monthdays.should == [1,15]
+  end
+
+end
+
+context "A complex Schedule" do
+  setup do
+    @rs = Recurring::Schedule.new :unit => 'months', :frequency => 2, :anchor => Time.utc(2006,4,15,10,30), :monthdays => [3,7], :times => '5pm 4:45:12am'
+  end
+  
+  specify "should be marshallable" do
+    rm = Marshal.dump(@rs)
+    Marshal.load(rm).should == @rs
+  end
+
+  specify "should be YAMLable" do
+    rm = YAML.dump(@rs)
+    YAML.load(rm).should == @rs
+  end
+
+  specify "should be equal to a schedule with the same params" do
+    r2 = Recurring::Schedule.new :unit => 'months', :frequency => 2, :anchor => Time.utc(2006,4,15,10,30), :monthdays => [3,7], :times => '5pm 4:45:12am'
+    r2.should == @rs
+  end
+
+  specify "should not be equal to a slightly different schedule" do
+    r2 = Recurring::Schedule.new :unit => 'months', :frequency => 2, :anchor => Time.utc(2006,4,15,10,30), :monthdays => [3,7], :times => '5pm 4:45:11am'
+    r2.should_not_equal @rs
+  end
+
+end
+
+#MONTHS
+
+context "A bi-monthly Schedule without more params" do
+
+  setup do
+    @rs = Recurring::Schedule.new :unit => 'months', :frequency => 2, :anchor => Time.utc(2006,4,15,10,30)
+  end
+
+  specify "should include the anchor date" do
+    @rs.should_include Time.utc(2006,4,15,10,30)
+  end
+
+  specify "should include dates offset by the frequency" do
+    @rs.should_include Time.utc(2006,6,15,10,30)
+  end
+
+  specify "should not include the beginnings of days for which it includes points in the middle" do
+    @rs.should_not_include Time.utc(2006,6,15)
+    @rs.should_not_include Time.utc(2006,4,15)
+  end
+
+  specify "should not include dates with wrong months" do
+    @rs.should_not_include Time.utc(2006,5,15,10,30)
+  end
+
+  specify "should not include dates without matching time parts" do
+    @rs.should_not_include Time.utc(2006,4,16)
+    @rs.should_not_include Time.utc(2006,6,15,10,15)
+  end
+
+  specify "should find that the start point is the next included date when the start point matches" do
+    included = Time.utc(2006,6,15,10,30)
+    @rs.find_next(included).should == included
+  end
+
+  specify "should find the next date when the start point doesn't match" do
+    @rs.find_next(Time.utc(2006,6,15)).should == Time.utc(2006,6,15,10,30)
+  end
+
+end
+
+context "A monthly schedule with monthday params" do
+  setup do
+    @rs = Recurring::Schedule.new :unit => 'months', :monthdays => [1,15]
+    #    @rs.anchor = Time.utc(2006,6,18,12,30) #should react appropriately to the presence of a (no longer useless) anchor
+  end
+
+  specify "should include the start of matching days" do
+    @rs.should_include Time.utc(2006,6,15)
+    @rs.should_include Time.utc(2006,7,1)
+  end
+
+  specify "should not include the middle of matching days" do
+    @rs.should_not_include Time.utc(2006,6,15,14)
+    @rs.should_not_include Time.utc(2006,7,1,11,30)
+    @rs.should_not_include Time.utc(2006,7,1,0,0,30)
+  end
+
+  specify "should not include the start of non-matching days" do
+    @rs.should_not_include Time.utc(2006,6,14)
+    @rs.should_not_include Time.utc(2006,7,2)
+  end
+
+  specify "should not include times with no matching component" do
+    @rs.should_not_include Time.utc(2006,6,14,11,8)
+    @rs.should_not_include Time.utc(2006,7,2,5,30) 
+  end
+
+  specify "should find the next date" do
+    @rs.find_next(Time.utc(2006,3,4)).should == Time.utc(2006,3,15)
+    @rs.find_next(Time.utc(2006,3,17)).should == Time.utc(2006,4,1)
+  end
+
+end
+
+context "A bi-monthly Schedule with monthday params" do
+
+  setup do
+    @rs = Recurring::Schedule.new :unit => 'months', :frequency => 2, :anchor => Time.utc(2006,4,15,10,30), :monthdays => [10,18]
+  end
+
+  specify "should include the beginnings of matching days" do
+    @rs.should_include Time.utc(2006,6,10)
+    @rs.should_include Time.utc(2006,8,18)
+  end
+
+  specify "should not include the beginnings of non_matching days" do
+    @rs.should_not_include Time.utc(2006,6,11)
+  end
+
+  specify "should not include the beginning of the anchor day" do
+    @rs.should_not_include Time.utc(2006,4,15)
+  end
+
+  specify "should not include the anchor time" do
+    @rs.should_not_include Time.utc(2006,4,15,10,30)
+  end
+
+  specify "should find the next date when the start point doesn't match" do
+    @rs.find_next(Time.utc(2006,6,15)).should == Time.utc(2006,6,18)
+  end
+
+  specify "should find the next date" do
+    @rs.find_next(Time.utc(2006,5,4)).should == Time.utc(2006,6,10)
+    @rs.find_next(Time.utc(2006,6,11)).should == Time.utc(2006,6,18)
+  end
+end 
+
+context "A monthly schedule with week params" do
+end
+
+context "A third-monthly schedule with week params" do
+  
+    setup do
+      lambda{@rs = Recurring::Schedule.new :unit => 'months', :week => 1, :frequency => 3}.should_raise ArgumentError
+    end
+
+    specify "should walk up the stairs" do
+    end
+
+    # should = *specify
+    # 
+    # should "walk up the stairs" do
+    #   @rs.should_include Time.utc(2007,11,14)
+    # end
+end
+
+context "A monthly schedule with week params and weekday params" do
+
+  setup do
+    @rs = Recurring::Schedule.new :unit => 'months', :weeks => 1, :weekdays => :monday
+  end
+
+  specify "should include the beginnings of matching days" do
+    @rs.should_include Time.utc(2006,12,4)
+  end
+
+  specify "should not include the matching days in off weeks" do
+    @rs.should_not_include Time.utc(2006,12,18)
+    @rs.should_not_include Time.utc(2006,11,27)
+  end
+
+end
+
+context "A monthly schedule with weekday params but no week params" do
+end
+
+context "A six-monthly schedule with week, weekday, and times params" do
+end
+
+#WEEKLY
+
+context "A weekly schedule with weekday params" do
+  
+  setup do
+    @rs = Recurring::Schedule.new :unit => 'weeks', :weekdays => %w{sunday monday weds friday}
+  end
+
+  specify "should include the beginnings of matching days" do
+    @rs.should_include Time.utc(2006,12,3)
+    @rs.should_include Time.utc(2006,12,6)
+    @rs.should_include Time.utc(2006,11,27)
+  end
+
+  specify "should not include the middle of matching days" do
+    @rs.should_not_include Time.utc(2006,12,6,10,30)
+    @rs.should_not_include Time.utc(2006,11,27,0,30)
+    @rs.should_not_include Time.utc(2006,12,7)
+  end
+
+  specify "should find the next date" do
+    @rs.find_next(Time.utc(2006,12,2)).should == Time.utc(2006,12,3)
+    @rs.find_next(Time.utc(2006,11,30)).should == Time.utc(2006,12,1)
+  end
+
+end
+
+context "A weekly schedule with only an anchor" do
+  
+  setup do
+    @rs = Recurring::Schedule.new :unit => 'weeks', :anchor => Time.utc(2006,12,6,17,30)
+  end
+
+  specify "should include times that are offset by one week" do
+    @rs.should_include Time.utc(2006,12,20,17,30)
+  end
+
+  specify "should not include times that are not offset by one week" do
+    @rs.should_not_include Time.utc(2006,12,19,17,30)
+    @rs.should_not_include Time.utc(2006,12,20)
+    @rs.should_not_include Time.utc(2006,5,6,17,30)
+  end
+  
+  specify "should find the next date" do
+    @rs.find_next(Time.utc(2006,5,4)).should == Time.utc(2006,5,10,17,30)
+    @rs.find_next(Time.utc(2006,6,11)).should == Time.utc(2006,6,14,17,30)
+  end
+end
+
+context "A third-weekly schedule with weekday and times params" do
+
+  setup do
+    @rs = Recurring::Schedule.new :unit => 'weeks', :frequency => 3, :anchor => Time.utc(2006,12,1), :weekdays => %w{mon fri sat}, :times => '3pm' 
+  end
+
+  specify "should include the proper times on the right days of matching weeks" do
+    @rs.should_include Time.utc(2006,11,27,15)
+    @rs.should_include Time.utc(2006,12,1,15)
+    @rs.should_include Time.utc(2006,12,2,15)
+    @rs.should_include Time.utc(2006,12,18,15)
+  end
+
+  specify "should not include the beginnings of matching days" do
+    @rs.should_not_include Time.utc(2006,12,1)
+  end
+
+  specify "should not include the proper times on the right days of non-matching weeks" do
+    @rs.should_not_include Time.utc(2006,12,4,15)
+  end
+
+  specify "should find the next date" do
+    @rs.find_next(Time.utc(2006,12,4)).should == Time.utc(2006,12,18,15)
+    @rs.find_next(Time.utc(2006,12,18)).should == Time.utc(2006,12,18,15)
+  end
+  
+end
+
+context "Recurring.week_of_year" do
+
+  specify "should return the same value for days in the same week" do
+    [[2006,12,1],
+    [2006,12,2],
+    [2006,11,28],
+    [2006,11,26]].collect do |args| 
+        Time.utc *args
+    end.each do |t|
+      Recurring.week_of_year(t).should == 48
+    end
+    
+    [[2006,12,7], 
+    [2006,12,9], 
+    [2006,12,3]].collect do |args| 
+        Time.utc *args
+    end.each do |t|
+      Recurring.week_of_year(t).should == 49
+    end 
+  end
+
+end
+
+context "A weekly schedule with times params but no days params" do
+
+  setup do
+    @rs = Recurring::Schedule.new :unit => 'weeks', :times => '4pm'
+  end
+
+  specify "should flip out hard" do
+    lambda{@rs.find_next(Time.utc(2006,1,1,16))}.should_raise RangeError
+  end
+
+end
+
+#DAILY
+
+context "A daily schedule with no other params" do
+
+  setup do
+    @rs = Recurring::Schedule.new :unit => 'days'
+  end
+
+  specify "should match the beginning of every day" do
+    @rs.should_include Time.utc(2006,11,5)
+    @rs.should_include Time.mktime(2006,11,5)
+  end
+
+  specify "should not match the middle of any day" do
+    @rs.should_not_include Time.utc(2006,11,5,5)
+    @rs.should_not_include Time.utc(2006,11,5,0,0,22)
+  end
+
+  specify "should find the next date" do
+    @rs.find_next(Time.utc(2006,5,4,2)).should == Time.utc(2006,5,5)
+    @rs.find_next(Time.utc(2006,6,13,5)).should == Time.utc(2006,6,14)
+  end
+
+end
+
+context "A daily schedule with an anchor" do
+  setup do
+    @rs = Recurring::Schedule.new :unit => 'days', :anchor => Time.utc(2006,11,1,10,15,22)
+  end
+
+  specify "should include daily mulitples of the anchor" do
+    @rs.should_include Time.utc(2006,11,7,10,15,22)
+  end
+
+  specify "should not include other times in any day" do
+    @rs.should_not_include Time.utc(2006,11,7)
+    @rs.should_not_include Time.utc(2006,11,7,10,15,21)
+  end
+
+  specify "should find the next date" do
+    @rs.find_next(Time.utc(2006,5,4,12)).should == Time.utc(2006,5,5,10,15,22)
+    @rs.find_next(Time.utc(2006,6,13,5)).should == Time.utc(2006,6,13,10,15,22)
+  end
+end
+
+context "A fourth-daily schedule with only the unit and frequency != 1" do
+  specify "should have an ArgumentError" do
+    lambda{@rs = Recurring::Schedule.new :unit => 'days', :frequency => 4}.should_raise ArgumentError
+  end
+end
+
+context "A fourth-daily schedule with no other params" do
+
+  setup do
+    @rs = Recurring::Schedule.new :unit => 'days', :frequency => 4, :anchor => Time.utc(2006,11,1,9,30)
+  end
+
+  specify "should check the anchor" do
+    @rs.send(:check_anchor?).should == true
+  end
+
+  specify "should include the anchor" do
+    @rs.should_include Time.utc(2006,11,1,9,30)
+  end
+  
+  specify "should not include the beginning of the anchor day" do
+    @rs.should_not_include Time.utc(2006,11,1)
+  end
+  
+  specify "should include the time of the anchor, every four days" do
+    @rs.should_include Time.utc(2006,11,5,9,30)
+  end
+
+  specify "should not include the beginnings of matching days" do
+    @rs.should_not_include Time.utc(2006,11,5)
+  end
+
+end
+
+context "A daily schedule with times params" do
+end
+
+context "A third-daily schedule with times params" do
+end
+
+context "A daily schedule with monthday params" do
+end
+
+#HOURLY
+
+context "An hourly schedule with no other params" do
+
+  setup do
+    @rs = Recurring::Schedule.new :unit => 'hours'
+  end
+
+  specify "should include the top of every hour" do
+    @rs.should_include Time.utc(2006,3,4,5)
+  end
+
+  specify "should not include times with non zero minutes or seconds" do
+    @rs.should_not_include Time.utc(2006,3,4,5,6)
+    @rs.should_not_include Time.utc(2006,3,4,5,0,6)
+  end
+
+end
+
+context "An hourly schedule with an anchor" do
+  setup do
+    @rs = Recurring::Schedule.new :unit => 'hours', :anchor => Time.utc(2001,5,15,11,17) 
+  end
+
+  specify "should include any time with the same sub hour parts" do
+    @rs.should_include Time.utc(2006,5,15,14,17)
+  end
+ 
+  specify "should include the anchor time" do
+  end
+
+  specify "should not include any times with different sub hour parts" do
+  end
+ 
+end
+
+context "An bi-hourly schedule with time params" do
+  
+  setup do
+    @rs = Recurring::Schedule.new :unit => 'hours', :frequency => 2, :times => '0:22 0:13:14', :anchor => Time.utc(2006)
+  end
+  
+  specify "should find 4 times in 4 hours" do
+    should_find_in_range(@rs, 4, Time.utc(2006,12,12), Time.utc(2006,12,12,4) )
+  end
+  
+  specify "should include times every other hour with the valid minutes and seconds" do
+    @rs.should_include Time.utc(2006,1,1,0,22)
+    @rs.should_include Time.utc(2006,1,1,0,13,14)
+    @rs.should_include Time.utc(2006,1,1,2,22)
+    @rs.should_include Time.utc(2006,1,1,16,13,14)
+  end
+  
+  specify "should not include times with mismatched minutes or hours" do
+    @rs.should_not_include Time.utc(2006,12,12)
+    @rs.should_not_include Time.utc(2006,1,1,1,22)
+    @rs.should_not_include Time.utc(2006,1,1,3,13,14)
+    @rs.should_not_include Time.utc(2006,1,1,2,23)
+    @rs.should_not_include Time.utc(2006,1,1,16,13,24)
+  end
+  
+end
+
+context "An hourly schedule with times params" do
+
+  setup do
+    @rs = Recurring::Schedule.new :unit => 'hours', :times => '0:15 4:30 0:45:30'
+  end
+
+  specify "should include matching times" do
+    @rs.should_include Time.utc(2001,11,11,11,15)
+    @rs.should_include Time.utc(2001,1,1,1,30)
+    @rs.should_include Time.utc(2009,12,14,3,45,30)
+  end
+
+  specify "should not include non matching times" do
+    @rs.should_not_include Time.utc(2001,11,11,11,15,05)
+    @rs.should_not_include Time.utc(2001,1,1,1,30,1)
+    @rs.should_not_include Time.utc(2001,1,1,1,35)
+    @rs.should_not_include Time.utc(2009,12,14,3,45)
+  end
+
+  specify "should find the next date" do
+    @rs.find_next(Time.utc(2006,5,4,12)).should == Time.utc(2006,5,4,12,15)
+    @rs.find_next(Time.utc(2006,6,13,5,31)).should == Time.utc(2006,6,13,5,45,30)
+  end
+
+end
+
+context "An eight-hourly schedule with times params" do
+end
+
+context "An hourly schedule with monthday params" do
+  
+  specify "should ignore the monthday params" do
+  end
+
+end
+
+#MINUTELY
+
+context "A minutely schedule with times params" do
+
+end
+
+context "A 5-minutely schedule with no other params" do
+  
+  setup do
+    @rs = Recurring::Schedule.new :unit => 'minutes', :frequency => 5, :anchor => Time.utc(2006,9,1,10,30)
+  end
+
+  specify "should include a five minute multiples of the anchor time" do
+    @rs.should_include Time.utc(2006,9,1,10,30)
+    @rs.should_include Time.utc(2006,9,1,10,35)
+    @rs.should_include Time.utc(2006,9,1,20,30)
+  end
+
+  specify "should not include times with different seconds" do
+    @rs.should_not_include Time.utc(2006,9,1,10,30,30)
+  end
+
+  specify "should find the next date" do
+    @rs.find_next(Time.utc(2006,5,4,12,1)).should == Time.utc(2006,5,4,12,5)
+    @rs.find_next(Time.utc(2006,6,13,5,31)).should == Time.utc(2006,6,13,5,35)
+  end
+
+  specify "should ignore higher than second precision from the anchor" do
+  end
+  
+  specify "should find 7 times in a 30 minute range" do
+    should_find_in_range(@rs, 7, Time.utc(2006,12,12,0,45), Time.utc(2006,12,12,1,15))
+    @rs.find_in_range( Time.utc(2006,12,12,0,45), Time.utc(2006,12,12,1,15) ).first.class.should_be Time  
+  end
+
+  specify "should find in a range given as an object with first and last params" do
+    range = mock('range')
+    range.should_receive(:first).and_return(Time.utc(2006,12,12,0,45))
+    range.should_receive(:last).any_number_of_times.and_return(Time.utc(2006,12,12,1,15))
+    @rs.find_in_range(range).first.class.should_be Time  
+  end
+
+  specify "should find in a range given as a Range" do
+    range = (Time.utc(2006,12,12,0,45)..Time.utc(2006,12,12,1,15))
+    @rs.find_in_range(range).first.class.should_be Time  
+  end
+
+  specify "should find 10 times in a 45 minute range" do
+    should_find_in_range(@rs, 10, Time.utc(2006,12,12,1), Time.utc(2006,12,12,1,45))
+    @rs.find_in_range( Time.utc(2006,12,12,0,45), Time.utc(2006,12,12,1,15) ).first.class.should_be Time  
+  end
+end
+
+#SECONDLY
+
+
+#ETC
+
+context "a daily schedule with a time 4:29am" do
+  setup do
+    @rs = Recurring::Schedule.new :unit => 'days', :times => '4:29am'
+  end
+  specify "should include any day at the time specified" do
+    @rs.should_include Time.utc(2001,3,4,4,29)
+  end
+  specify "should not include times other than 4:29am" do
+    @rs.should_not_include Time.utc(2004,5,17,1,39)
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: recurring
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-12-10 00:00:00 -08:00
+summary: A scheduling library for recurring events
+require_paths: 
+- lib
+email: ryand-ruby@zenspider.com
+homepage: "    by Chris Anderson"
+rubyforge_project: recurring
+description: "Schedules can be like: * Every Tuesday at 5pm * The 1st and 15th of every other month * Every 2 hours * The first Friday of every month at 11:15am and 4:45:15pm  == FEATURES/PROBLEMS:  = Features * Fast searching of long ranges for matching times. * Ability to define Schedules in a few flexible ways. * Extensive RSpec specifications (run \"rake spec\" to see them) * Extensive RSpec specifications (run \"rake spec\" to see them)  = Problems / Todo * Untested timezone support * Plans to offer complex Schedule and Masks  == SYNOPSYS:"
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Ryan Davis
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/recurring.rb
+- spec/recurring_spec.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.6
+    version: