hiccup 0.4.5 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 358dd23836a721b455842348afbc112ec39d761f
-  data.tar.gz: 5f54eaa0f43aa11de031123267ee373f54a11b10
+  metadata.gz: 7d10125513beb88e0c6c96db75cc928db898ad2f
+  data.tar.gz: fc07262a4ea66ef9d964f69e5a9d69971c2ee557
 SHA512:
-  metadata.gz: c521bbe940e1d55728835b5d4e9787868f5586af64254f61c4a98a679874a963e8774b3aba260d596ee3c72fac7ccf32ec60cb5b1ef37ace51380d1e7dbe7238
-  data.tar.gz: caa85c43bcdcaf32653d6c408d431f932a00c166b4ac6150ae95c7acf86185049000efc276ba3a1e934d1664c928f29882dbbc20fa83922590a11562f68197eb
+  metadata.gz: 72ab32b2d1fbaacf611d09063be2f223f322a4de8af2cb83c950a52b723d2ebdc6b6ae31281459d319d063e1a65d84dabd36befd07245909e9d694cf2c1718a3
+  data.tar.gz: bd3b19597a7ff8444ef1a51ac294e5bf1b56ef9d8d4473419d799adb87662638bd602939b8026a2fd0674592d5e3a21648775f57372921144f0580494df9d376

data/hiccup.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rails", "~> 3.2.8"
   s.add_development_dependency "turn"
   s.add_development_dependency "simplecov"
+  s.add_development_dependency "shoulda-context"
   s.add_development_dependency "pry"
   
   s.files         = `git ls-files`.split("\n")

data/lib/hiccup/convenience.rb

@@ -20,7 +20,8 @@ module Hiccup
     
     
     def ends?
-      (ends == true) || %w{true 1 t}.member?(ends)
+      return %w{true 1 t}.member?(ends) if ends.is_a?(String)
+      !!ends
     end
     
     

data/lib/hiccup/enumerable.rb

@@ -11,16 +11,7 @@ module Hiccup
     
     
     def enumerator
-      "Hiccup::Enumerable::#{kind.to_s.classify}Enumerator".constantize
-    end
-    
-    
-    
-    def occurrences_during_month(year, month)
-      puts "DEPRECATED: `occurrences_during_month` will be removed in 0.5.0. Use `occurrences_between` instead"
-      date1 = Date.new(year, month, 1)
-      date2 = Date.new(year, month, -1)
-      occurrences_between(date1, date2)
+      ScheduleEnumerator.enum_for(self)
     end
     
     
@@ -67,6 +58,7 @@ module Hiccup
       date == first_occurrence_on_or_after(date)
     end
     alias :contains? :occurs_on
+    alias :predicts? :occurs_on
     
     
     

data/lib/hiccup/enumerable/annually_enumerator.rb

@@ -4,53 +4,64 @@ module Hiccup
   module Enumerable
     class AnnuallyEnumerator < ScheduleEnumerator
       
-      
       def initialize(*args)
         super
-        
-        # Use more efficient iterator methods unless
-        # we have to care about leap years
-        
-        unless start_date.month == 2 && start_date.day == 29
-          def self.next_occurrence_after(date)
-            date.next_year(skip)
-          end
-          
-          def self.next_occurrence_before(date)
-            date.prev_year(skip)
-          end
-        end
+        @month, @day = start_date.month, start_date.day
+        @february_29 = month == 2 and day == 29
+      end
+      
+    protected
+      
+      
+      attr_reader :month, :day, :year
+      
+      def february_29?
+        @february_29
       end
       
       
+      
+      def advance!
+        @year += skip
+        to_date!
+      end
+      
+      def rewind!
+        @year -= skip
+        to_date!
+      end
+      
+      
+      
       def first_occurrence_on_or_after(date)
-        year, month, day = date.year, start_date.month, start_date.day
-        day = -1 if month == 2 && day == 29
+        @year = date.year
+        @year += skip if (date.month > month) or (date.month == month and date.day > day)
         
-        result = Date.new(year, month, day)
-        year += 1 if result < date
+        remainder = (@year - start_date.year) % skip
+        @year += (skip - remainder) if remainder > 0
         
-        remainder = (year - start_date.year) % skip
-        year += (skip - remainder) if remainder > 0
-        
-        Date.new(year, month, day)
+        to_date!
       end
       
       def first_occurrence_on_or_before(date)
-        year, month, day = date.year, start_date.month, start_date.day
-        day = -1 if month == 2 && day == 29
-        
-        result = Date.new(year, month, day)
-        year -= 1 if result > date
+        @year = date.year
+        @year -= 1 if (date.month < month) or (date.month == month and date.day < day)
         
-        # what if year is before start_date.year?
-        remainder = (year - start_date.year) % skip
-        year -= remainder if remainder > 0
+        remainder = (@year - start_date.year) % skip
+        @year -= remainder if remainder > 0
         
+        to_date!
+      end
+      
+      
+      
+      def to_date!
+        return Date.new(year, month, 28) if february_29? and !leap_year?(year)
         Date.new(year, month, day)
       end
       
       
+      
     end
   end
 end

data/lib/hiccup/enumerable/monthly_date_enumerator.rb

@@ -0,0 +1,14 @@
+require 'hiccup/enumerable/schedule_enumerator'
+
+module Hiccup
+  module Enumerable
+    class MonthlyDateEnumerator < MonthlyEnumerator
+    protected
+      
+      def occurrences_in_month(year, month)
+        monthly_pattern
+      end
+      
+    end
+  end
+end

data/lib/hiccup/enumerable/monthly_enumerator.rb

@@ -4,81 +4,117 @@ module Hiccup
   module Enumerable
     class MonthlyEnumerator < ScheduleEnumerator
       
-      
-      def first_occurrence_on_or_after(date)
-        result = nil
-        monthly_pattern.each do |occurrence|
-          temp = nil
-          (0...30).each do |i| # If an occurrence doesn't occur this month, try up to 30 months in the future
-            temp = monthly_occurrence_to_date(occurrence, shift_date_by_months(date, i))
-            break if temp && (temp >= date)
-          end
-          next unless temp
-          
-          remainder = months_between(temp, start_date) % skip
-          temp = monthly_occurrence_to_date(occurrence, shift_date_by_months(temp, skip - remainder)) if remainder > 0
-          next unless temp
-          
-          result = temp if !result || (temp < result)
+      def self.for(schedule)
+        if schedule.monthly_pattern.all? { |occurrence| Fixnum === occurrence }
+          MonthlyDateEnumerator
+        else
+          self
         end
-        result
       end
       
-      def first_occurrence_on_or_before(date)
-        result = nil
-        monthly_pattern.each do |occurrence|
-          temp = nil
-          (0...30).each do |i| # If an occurrence doesn't occur this month, try up to 30 months in the past
-            temp = monthly_occurrence_to_date(occurrence, shift_date_by_months(date, -i))
-            break if temp && (temp <= date)
-          end
-          next unless temp
-          
-          remainder = months_between(temp, start_date) % skip
-          temp = monthly_occurrence_to_date(occurrence, shift_date_by_months(temp, -remainder)) if remainder > 0
-          next unless temp
-          
-          result = temp if !result || (temp > result)
-        end
-        result
+      
+      
+      def started?
+        !@position.nil?
       end
       
       
-    private
       
+    protected
+      
+      attr_reader :year, :month, :cycle, :last_day_of_month
       
-      def shift_date_by_months(date, months)
-        date.next_month(months)
+      
+      
+      def advance!
+        @position += 1
+        next_month if @position >= cycle.length
+        
+        day = cycle[@position]
+        return self.next if day > last_day_of_month
+        Date.new(year, month, day)
       end
       
+      def rewind!
+        @position -= 1
+        prev_month if @position < 0
+        
+        day = cycle[@position]
+        return self.prev if day > last_day_of_month
+        Date.new(year, month, day)
+      end
       
-      def monthly_occurrence_to_date(occurrence, date)
-        year, month = date.year, date.month
+      
+      
+      def first_occurrence_on_or_after(date)
+        @year, @month = date.year, date.month
+        get_context
+        
+        @position = cycle.index { |day| day >= date.day }
+        next_month unless @position
         
-        day = begin
+        day = cycle[@position]
+        return self.next if day > last_day_of_month
+        Date.new(year, month, day)
+      end
+      
+      def first_occurrence_on_or_before(date)
+        @year, @month = date.year, date.month
+        get_context
+        
+        @position = cycle.index { |day| day <= date.day }
+        prev_month unless @position
+        
+        day = cycle[@position]
+        return self.prev if day > last_day_of_month
+        Date.new(year, month, day)
+      end
+      
+      
+      
+      def occurrences_in_month(year, month)
+        wday_of_first_of_month = Date.new(year, month, 1).wday
+        monthly_pattern.map do |occurrence|
           if occurrence.is_a?(Array)
             ordinal, weekday = occurrence
-            wday_of_first_of_month = Date.new(year, month, 1).wday
             wday = Date::DAYNAMES.index(weekday)
             day = wday
             day = day + 7 if (wday < wday_of_first_of_month)
             day = day - wday_of_first_of_month
             day = day + (ordinal * 7) - 6
+            day
           else
             occurrence
           end
         end
-        
-        last_day_of_month = Date.new(year, month, -1).day
-        (day > last_day_of_month) ? nil : Date.new(year, month, day)
       end
       
       
-      def months_between(later_date, earlier_date)
-        ((later_date.year - earlier_date.year) * 12) + (later_date.month - earlier_date.month).to_int
+      
+      def next_month
+        @position = 0
+        @month += skip
+        @year, @month = year + 1, month - 12 if month > 12
+        get_context
+      end
+      
+      def prev_month
+        @position = @cycle.length - 1
+        @month -= skip
+        @year, @month = year - 1, month + 12 if month < 1
+        get_context
+      end
+      
+      def get_context
+        @last_day_of_month = [4, 6, 9, 11].member?(month) ? 30 : 31
+        @last_day_of_month = leap_year?(year) ? 29 : 28 if month == 2
+        @cycle = occurrences_in_month(year, month).sort
       end
       
       
+      
     end
   end
 end
+
+require "hiccup/enumerable/monthly_date_enumerator"

data/lib/hiccup/enumerable/schedule_enumerator.rb

@@ -3,63 +3,99 @@ module Hiccup
   module Enumerable
     class ScheduleEnumerator
       
-      def initialize(schedule, date)
+      def self.enum_for(schedule)
+        case schedule.kind
+        when :weekly then WeeklyEnumerator
+        when :annually then AnnuallyEnumerator
+        when :monthly then MonthlyEnumerator.for(schedule)
+        else NeverEnumerator
+        end
+      end
+      
+      
+      
+      def initialize(schedule, seed_date)
         @schedule = schedule
-        @date = date
-        @date = @date.to_date if @date.respond_to?(:to_date)
-        @date = start_date if (@date < start_date)
-        @date = end_date if (ends? && @date > end_date)
-        @current_date = nil
+        @ends = schedule.ends?
+        @seed_date = seed_date
+        @seed_date = seed_date.to_date if seed_date.respond_to?(:to_date)
+        @seed_date = start_date if (seed_date < start_date)
+        @seed_date = end_date if (ends? && seed_date > end_date)
+        @cursor = nil
       end
       
-      attr_reader :schedule
-      delegate :start_date, :weekly_pattern, :monthly_pattern, :ends?, :end_date, :skip, :to => :schedule
+      attr_reader :schedule, :seed_date, :cursor
       
       
       
       def next
-        @current_date = if @current_date
-          next_occurrence_after(@current_date)
-        else
-          first_occurrence_on_or_after(@date)
-        end
-        @current_date = nil if (ends? && @current_date && @current_date > end_date)
-        @current_date
+        @cursor = started? ? advance! : first_occurrence_on_or_after(seed_date)
+        return nil if ends? && @cursor > end_date
+        @cursor
       end
       
       def prev
-        @current_date = if @current_date
-          next_occurrence_before(@current_date)
-        else
-          first_occurrence_on_or_before(@date)
-        end
-        @current_date = nil if (@current_date && @current_date < start_date)
-        @current_date
+        @cursor = started? ? rewind! : first_occurrence_on_or_before(seed_date)
+        return nil if @cursor < start_date
+        @cursor
       end
       
       
       
-      # These two methods DO NOT assume that
-      # date is predicted by the given schedule
+      def started?
+        !@cursor.nil?
+      end
       
-      def first_occurrence_on_or_after(date)
-        raise NotImplementedError
+      def ends?
+        @ends
       end
       
-      def first_occurrence_on_or_before(date)
-        raise NotImplementedError
+      
+      
+    protected
+      
+      
+      
+      delegate :start_date, :weekly_pattern, :monthly_pattern, :end_date, :skip, :to => :schedule
+      
+      
+      
+      def leap_year?(year)
+        return false unless (year % 4).zero?
+        return (year % 400).zero? if (year % 100).zero?
+        true
       end
       
       
+      
       # These two methods DO assume that
       # date is predicted by the given schedule
+      # Subclasses can probably supply more
+      # performant implementations of these.
+      
+      def advance!
+        puts "calling ScheduleEnumerator#advance! slow!"
+        first_occurrence_on_or_after(cursor + 1)
+      end
+      
+      def rewind!
+        puts "calling ScheduleEnumerator#rewind! slow!"
+        first_occurrence_on_or_before(cursor - 1)
+      end
+      
+      
+      
+      # These two methods DO NOT assume that
+      # date is predicted by the given schedule
+      # Subclasses _must_ provide implementations
+      # of these methods.
       
-      def next_occurrence_after(date)
-        first_occurrence_on_or_after(date + 1)
+      def first_occurrence_on_or_after(date)
+        raise NotImplementedError
       end
       
-      def next_occurrence_before(date)
-        first_occurrence_on_or_before(date - 1)
+      def first_occurrence_on_or_before(date)
+        raise NotImplementedError
       end
       
       

data/lib/hiccup/enumerable/weekly_enumerator.rb

@@ -4,60 +4,110 @@ module Hiccup
   module Enumerable
     class WeeklyEnumerator < ScheduleEnumerator
       
-      
       def initialize(*args)
         super
         
-        # Use more efficient iterator methods if
-        # weekly_pattern is simple enough
+        @wday_pattern = weekly_pattern.map do |weekday|
+          Date::DAYNAMES.index(weekday)
+        end.sort
         
-        if weekly_pattern.length == 1
-          def self.next_occurrence_after(date)
-            date + skip * 7
-          end
-          
-          def self.next_occurrence_before(date)
-            date - skip * 7
-          end
+        start_wday = start_date.wday
+        if start_wday <= @wday_pattern.first or start_wday > @wday_pattern.last
+          @base_date = start_date
+        else
+          @base_date = start_date - (start_wday - @wday_pattern.first)
         end
+        
+        @starting_index = wday_pattern.index { |wday| wday >= start_wday } || 0
+        @cycle = calculate_cycle(schedule)
+      end
+      
+    protected
+      
+      
+      
+      attr_reader :base_date,
+                  :wday_pattern,
+                  :starting_index,
+                  :cycle,
+                  :position
+      
+      
+      
+      def advance!
+        date = cursor + cycle[position]
+        @position = (position + 1) % cycle.length
+        date
+      end
+      
+      def rewind!
+        @position = position <= 0 ? cycle.length - 1 : position - 1
+        cursor - cycle[position]
       end
       
       
+      
       def first_occurrence_on_or_after(date)
         result = nil
         wday = date.wday
-        weekly_pattern.each do |weekday|
-          wd = Date::DAYNAMES.index(weekday)
+        wday_pattern.each do |wd|
           wd = wd + 7 if wd < wday
           days_in_the_future = wd - wday
           temp = date + days_in_the_future
           
-          remainder = ((temp - start_date) / 7).to_i % skip
+          remainder = ((temp - base_date) / 7).to_i % skip
           temp += (skip - remainder) * 7 if remainder > 0
           
           result = temp if !result || (temp < result)
         end
+        @position = position_of(result)
         result
       end
       
       def first_occurrence_on_or_before(date)
         result = nil
         wday = date.wday
-        weekly_pattern.each do |weekday|
-          wd = Date::DAYNAMES.index(weekday)
+        wday_pattern.each do |wd|
           wd = wd - 7 if wd > wday
           days_in_the_past = wday - wd
           temp = date - days_in_the_past
           
-          remainder = ((temp - start_date) / 7).to_i % skip
+          remainder = ((temp - base_date) / 7).to_i % skip
           temp -= remainder * 7 if remainder > 0
           
           result = temp if !result || (temp > result)
         end
+        @position = position_of(result)
         result
       end
       
       
+      
+      def calculate_cycle(schedule)
+        cycle = []
+        offset = wday_pattern[starting_index]
+        wdays = wday_pattern.map { |wday| wday - offset }.sort
+        
+        while wdays.first <= 0
+          wdays.push (wdays.shift + 7 * skip)
+        end
+        
+        cycle = [wdays.first]
+        wdays.each_cons(2) do |wday1, wday2|
+          cycle << (wday2 - wday1)
+        end
+        cycle
+      end
+      
+      def position_of(date)
+        date_i = wday_pattern.index(date.wday)
+        position = date_i - starting_index
+        position += wday_pattern.length if position < 0
+        position
+      end
+      
+      
+      
     end
   end
 end

data/lib/hiccup/inferable.rb

@@ -21,8 +21,10 @@ module Hiccup
         dates = extract_array_of_dates!(dates)
         enumerator = DatesEnumerator.new(dates)
         guesser = options.fetch :guesser, Guesser.new(self, options.merge(verbose: verbosity >= 2))
-        schedules = []
+        scorer = options.fetch(:scorer, Scorer.new(options.merge(verbose: verbosity >= 2)))
         
+        dates = []
+        schedules = []
         confidences = []
         high_confidence_threshold = 0.6
         min_confidence_threshold  = 0.35
@@ -32,10 +34,15 @@ module Hiccup
         
         until enumerator.done?
           date = enumerator.next
-          guesser << date
-          confidence = guesser.confidence.to_f
+          dates << date
+          guesses = guesser.generate_guesses(dates)
+          
+          # ! can guess and confidence be nil here??
+          guess, confidence = scorer.pick_best_guess(guesses, dates)
+          
+          confidence = confidence.to_f
           confidences << confidence
-          predicted = guesser.predicted?(date)
+          predicted = guess.predicts?(date)
           
           # if the last two confidences are both below a certain
           # threshhold and both declining, back up to where we
@@ -51,20 +58,20 @@ module Hiccup
           
           if predicted && confidence >= min_confidence_threshold
             iterations_since_last_confident_schedule = 0
-            last_confident_schedule = guesser.schedule
+            last_confident_schedule = guess
           else
             iterations_since_last_confident_schedule += 1
           end
           
-          rewind_by = iterations_since_last_confident_schedule == guesser.count ? iterations_since_last_confident_schedule - 1 : iterations_since_last_confident_schedule
+          rewind_by = iterations_since_last_confident_schedule == dates.count ? iterations_since_last_confident_schedule - 1 : iterations_since_last_confident_schedule
           
           
           
           if verbosity >= 1
             output = "  #{enumerator.index.to_s.rjust(3)} #{date}"
-            output << " #{"[#{guesser.count}]".rjust(5)}  =>  "
-            output << "~#{(guesser.confidence.to_f * 100).to_i.to_s.rjust(2, "0")} @ "
-            output << guesser.schedule.humanize.ljust(130)
+            output << " #{"[#{dates.count}]".rjust(5)}  =>  "
+            output << "~#{(confidence * 100).to_i.to_s.rjust(2, "0")} @ "
+            output << guess.humanize.ljust(130)
             output << "  :( move back #{rewind_by}" unless confident
             puts output
           end
@@ -76,13 +83,13 @@ module Hiccup
             if last_confident_schedule
               schedules << last_confident_schedule
             elsif allow_null_schedules
-              guesser.dates.take(guesser.count - rewind_by).each do |date|
+              dates.take(dates.count - rewind_by).each do |date|
                 schedules << self.new(:kind => :never, :start_date => date)
               end
             end
             
             enumerator.rewind_by(rewind_by)
-            guesser.restart!
+            dates = []
             confidences = []
             iterations_since_last_confident_schedule = 0
             last_confident_schedule = nil
@@ -92,7 +99,7 @@ module Hiccup
         if last_confident_schedule
           schedules << last_confident_schedule
         elsif allow_null_schedules
-          guesser.dates.each do |date|
+          dates.each do |date|
             schedules << self.new(:kind => :never, :start_date => date)
           end
         end

data/lib/hiccup/inferable/guesser.rb

@@ -9,46 +9,15 @@ module Hiccup
         @verbose = options.fetch(:verbose, false)
         @allow_skips = options.fetch(:allow_skips, true)
         @max_complexity = options.fetch(:max_complexity, 3)
-        @scorer = options.fetch(:scorer, Scorer.new(options))
-        start!
       end
       
-      attr_reader :confidence, :schedule, :dates, :scorer, :max_complexity
+      attr_reader :max_complexity
       
       def allow_skips?
         @allow_skips
       end
       
-      def start!
-        @dates = []
-        @schedule = nil
-        @confidence = 0
-      end
-      alias :restart! :start!
-      
-      
-      
       
-      def <<(date)
-        @dates << date
-        @schedule, @confidence = best_schedule_for(@dates)
-        date
-      end
-      
-      def count
-        @dates.length
-      end
-      
-      def predicted?(date)
-        @schedule && @schedule.contains?(date)
-      end
-      
-      
-      
-      def best_schedule_for(dates)
-        guesses = generate_guesses(dates)
-        scorer.pick_best_guess(guesses, dates)
-      end
       
       def generate_guesses(dates)
         @start_date = dates.first

data/lib/hiccup/version.rb

@@ -1,3 +1,3 @@
 module Hiccup
-  VERSION = "0.4.5"
+  VERSION = "0.5.0"
 end

data/test/enumerable_test.rb

@@ -28,6 +28,15 @@ class EnumerableTest < ActiveSupport::TestCase
     assert_equal expected_dates, actual_dates
   end
   
+  test "annual recurrence with a skip, starting enumeration on an off year" do
+    schedule = Schedule.new({
+      :kind => :annually,
+      :skip => 2,
+      :start_date => Date.new(2009,3,4)})
+    assert_equal "2011-03-04", (schedule.first_occurrence_on_or_after Date.new(2010, 03, 01)).to_s
+    assert_equal "2011-03-04", (schedule.first_occurrence_on_or_before Date.new(2012, 03, 01)).to_s
+  end
+  
   
   
   def test_occurs_on_weekly
@@ -79,6 +88,17 @@ class EnumerableTest < ActiveSupport::TestCase
     assert_equal expected_dates, dates,                 "occurrences_during_month did not correctly observe end date for weekly schedule"
   end
   
+  test "should keep weekly occurrences during a week together when skipping" do
+    schedule = Schedule.new(
+      :kind => :weekly,
+      :weekly_pattern => %w{Tuesday Thursday},
+      :start_date => Date.new(2013, 10, 2), # Wednesday
+      :skip => 2)
+    
+    dates = occurrences_during_month(schedule, 2013, 10).map(&:day)
+    assert_equal [3,  15, 17,  29, 31], dates
+  end
+  
   
   
   def test_monthly_occurrences_during_month
@@ -233,7 +253,7 @@ class EnumerableTest < ActiveSupport::TestCase
       :kind => :weekly,
       :weekly_pattern => %w{Monday},
       :skip => 3,
-      :start_date => Date.new(2011,1,1)})
+      :start_date => Date.new(2011,1,1)}) # Saturday
     expected_dates = [[1,3], [1,24], [2,14], [3,7], [3,28]]
     expected_dates.map! {|pair| Date.new(2011, *pair)}
     assert_equal expected_dates, schedule.occurrences_between(Date.new(2011,1,1), Date.new(2011,3,31))
@@ -349,7 +369,7 @@ class EnumerableTest < ActiveSupport::TestCase
   
   if ENV['PERFORMANCE_TEST']
     test "performance test" do
-      n = 100
+      n = 1000
       
       # Each of these schedules should describe 52 events
       

data/test/inferrable_test.rb

@@ -262,4 +262,21 @@ class InferableTest < ActiveSupport::TestCase
   
   
   
+  if ENV['PERFORMANCE_TEST']
+    test "performance test" do
+      Benchmark.bm(20) do |x|
+        [10, 25, 50, 100, 250, 500].each do |n|
+          seed = Date.today
+          dates = (0...n).each_with_object([]) { |i, array| array << seed + i * 7 }
+          x.report("#{n} dates") do
+            Schedule.infer(dates)
+          end
+        end
+      end
+    end
+  end
+  
+  
+  
+  
 end

data/test/leap_year_test.rb

@@ -0,0 +1,20 @@
+require "test_helper"
+
+
+class LeapYearTest < ActiveSupport::TestCase
+  include Hiccup
+  
+  
+  
+  test "should correctly determine whether a year is a leap year or not" do
+    enum = Enumerable::ScheduleEnumerator.new(Schedule.new, Date.today)
+    
+    assert enum.send(:leap_year?, 1988), "1988 is a leap year"
+    assert enum.send(:leap_year?, 2000), "2000 is a leap year"
+    refute enum.send(:leap_year?, 1998), "1998 is not a leap year"
+    refute enum.send(:leap_year?, 1900), "1900 is not a leap year"
+  end
+  
+  
+  
+end

data/test/test_helper.rb

@@ -5,4 +5,5 @@ require "rails/test_help"
 require "active_support/core_ext"
 require "turn"
 require "hiccup/schedule"
+require "shoulda/context"
 require "pry"

data/test/weekly_enumerator_test_test.rb

@@ -0,0 +1,120 @@
+require "test_helper"
+
+
+class WeeklyEnumeratorTest < ActiveSupport::TestCase
+  include Hiccup
+  
+  
+  
+  test "should generate a cycle of [7] for something that occurs every week on one day" do
+    assert_equal [7], cycle_for(
+      :start_date => Date.new(2013, 9, 23),
+      :weekly_pattern => ["Monday"])
+  end
+  
+  test "should generate a cycle of [21] for something that occurs every _third_ week on one day" do
+    assert_equal [21], cycle_for(
+      :start_date => Date.new(2013, 9, 23),
+      :weekly_pattern => ["Monday"],
+      :skip => 3)
+  end
+  
+  
+  
+  test "should generate a cycle of [6, 8] for something that occurs every other Saturday and Sunday when the start date is a Sunday" do
+    assert_equal [6, 8], cycle_for(
+      :start_date => Date.new(2013, 9, 22),
+      :weekly_pattern => ["Saturday", "Sunday"],
+      :skip => 2)
+  end
+  
+  test "should generate a cycle of [8, 6] for something that occurs every other Saturday and Sunday when the start date is a Saturday" do
+    assert_equal [8, 6], cycle_for(
+      :start_date => Date.new(2013, 9, 28),
+      :weekly_pattern => ["Saturday", "Sunday"],
+      :skip => 2)
+  end
+  
+  
+  
+  test "should generate a cycle of [2, 2, 10] for something that occurs every other Monday, Wednesday, Friday when the start date is a Monday" do
+    assert_equal [2, 2, 10], cycle_for(
+      :start_date => Date.new(2013, 9, 23),
+      :weekly_pattern => ["Monday", "Wednesday", "Friday"],
+      :skip => 2)
+  end
+  
+  test "should generate a cycle of [2, 10, 2] for something that occurs every other Monday, Wednesday, Friday when the start date is a Wednesday" do
+    assert_equal [2, 10, 2], cycle_for(
+      :start_date => Date.new(2013, 9, 25),
+      :weekly_pattern => ["Monday", "Wednesday", "Friday"],
+      :skip => 2)
+  end
+  
+  test "should generate a cycle of [10, 2, 2] for something that occurs every other Monday, Wednesday, Friday when the start date is a Friday" do
+    assert_equal [10, 2, 2], cycle_for(
+      :start_date => Date.new(2013, 9, 27),
+      :weekly_pattern => ["Monday", "Wednesday", "Friday"],
+      :skip => 2)
+  end
+  
+  
+  
+  test "should generate a cycle of [2, 5] for something that occurs every Tuesday and Thursday when the start date is a Friday" do
+    assert_equal [2, 5], cycle_for(
+      :start_date => Date.new(2013, 9, 27),
+      :weekly_pattern => ["Tuesday", "Thursday"])
+  end
+  
+  
+  
+  context "#position_of" do
+    setup do
+      @schedule = Schedule.new(
+        :kind => :weekly,
+        :start_date => Date.new(2013, 9, 26), # Thursday
+        :weekly_pattern => ["Tuesday", "Thursday", "Friday"],
+        :skip => 2)
+    end
+    
+    should "be a sane test" do
+      assert_equal [1, 11, 2], cycle_for(@schedule)
+    end
+    
+    should "find the correct position for the given date" do
+      assert_equal 0,   position_of(@schedule, 2013, 9, 26)
+      assert_equal 1,   position_of(@schedule, 2013, 9, 27)
+      assert_equal 2,   position_of(@schedule, 2013, 10, 8)
+      assert_equal 0,   position_of(@schedule, 2013, 10, 10)
+      assert_equal 1,   position_of(@schedule, 2013, 10, 11)
+      assert_equal 2,   position_of(@schedule, 2013, 10, 22)
+    end
+  end
+  
+  
+  
+private
+  
+  def cycle_for(options={})
+    schedule = build_schedule(options)
+    enumerator = schedule.enumerator.new(schedule, Date.today)
+    enumerator.send :calculate_cycle, schedule
+  end
+  
+  def position_of(schedule, *args)
+    date = build_date(*args)
+    enumerator = schedule.enumerator.new(schedule, date)
+    enumerator.send :position_of, date
+  end
+  
+  def build_schedule(options={})
+    return options if options.is_a? Schedule
+    Schedule.new(options.merge(:kind => :weekly))
+  end
+  
+  def build_date(*args)
+    return Date.new(*args) if args.length == 3
+    args.first
+  end
+  
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hiccup
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.5.0
 platform: ruby
 authors:
 - Bob Lail
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-24 00:00:00.000000000 Z
+date: 2013-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -94,6 +94,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda-context
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -131,6 +145,7 @@ files:
 - lib/hiccup/core_ext/hash.rb
 - lib/hiccup/enumerable.rb
 - lib/hiccup/enumerable/annually_enumerator.rb
+- lib/hiccup/enumerable/monthly_date_enumerator.rb
 - lib/hiccup/enumerable/monthly_enumerator.rb
 - lib/hiccup/enumerable/never_enumerator.rb
 - lib/hiccup/enumerable/schedule_enumerator.rb
@@ -152,9 +167,11 @@ files:
 - test/humanizable_test.rb
 - test/ical_serializable_test.rb
 - test/inferrable_test.rb
+- test/leap_year_test.rb
 - test/performance_test.rb
 - test/test_helper.rb
 - test/validatable_test.rb
+- test/weekly_enumerator_test_test.rb
 homepage: http://boblail.github.com/hiccup/
 licenses: []
 metadata: {}
@@ -185,6 +202,8 @@ test_files:
 - test/humanizable_test.rb
 - test/ical_serializable_test.rb
 - test/inferrable_test.rb
+- test/leap_year_test.rb
 - test/performance_test.rb
 - test/test_helper.rb
 - test/validatable_test.rb
+- test/weekly_enumerator_test_test.rb