hiccup 0.3.0 → 0.4.0

data/README.mdown

@@ -13,7 +13,7 @@ class Schedule
   hiccup :enumerable,
          :validatable,
          :humanizable,
-         :inferrable,
+         :inferable,
          :serializable => [:ical]
   
 end
@@ -60,7 +60,7 @@ Mixes in ActiveModel validations for recurrence models
 
 Represents a recurring pattern in a human-readable string
 
-### Inferrable
+### Inferable
 
 Infers a schedule from an array of dates
 

data/lib/hiccup/core_ext/date.rb

@@ -3,24 +3,6 @@ module Hiccup
     module Date
       
       
-      def get_months_since(earlier_date)
-        ((self.year - earlier_date.year) * 12) + (self.month - earlier_date.month).to_int
-      end
-      
-      def get_years_since(earlier_date)
-        (self.year - earlier_date.year)
-      end
-      
-      
-      def get_months_until(later_date)
-        later_date.months_since(self)
-      end
-      
-      def get_years_until(later_date)
-        later_date.years_since(self)
-      end
-      
-      
       
       def get_nth_wday_of_month
         (day - 1) / 7 + 1

data/lib/hiccup/enumerable/annually_enumerator.rb

@@ -0,0 +1,56 @@
+require 'hiccup/enumerable/schedule_enumerator'
+
+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
+      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
+        
+        result = Date.new(year, month, day)
+        year += 1 if result < date
+        
+        remainder = (year - start_date.year) % skip
+        year += (skip - remainder) if remainder > 0
+        
+        Date.new(year, month, day)
+      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
+        
+        # what if year is before start_date.year?
+        remainder = (year - start_date.year) % skip
+        year -= remainder if remainder > 0
+        
+        Date.new(year, month, day)
+      end
+      
+      
+    end
+  end
+end

data/lib/hiccup/enumerable/monthly_enumerator.rb

@@ -0,0 +1,84 @@
+require 'hiccup/enumerable/schedule_enumerator'
+
+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)
+        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
+      end
+      
+      
+    private
+      
+      
+      def shift_date_by_months(date, months)
+        date.next_month(months)
+      end
+      
+      
+      def monthly_occurrence_to_date(occurrence, date)
+        year, month = date.year, date.month
+        
+        day = begin
+          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
+          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
+      end
+      
+      
+    end
+  end
+end

data/lib/hiccup/enumerable/never_enumerator.rb

@@ -0,0 +1,19 @@
+require 'hiccup/enumerable/schedule_enumerator'
+
+module Hiccup
+  module Enumerable
+    class NeverEnumerator < ScheduleEnumerator
+      
+      
+      def first_occurrence_on_or_after(date)
+        date if date == start_date
+      end
+      
+      def first_occurrence_on_or_before(date)
+        date
+      end
+      
+      
+    end
+  end
+end

data/lib/hiccup/enumerable/schedule_enumerator.rb

@@ -0,0 +1,67 @@
+
+module Hiccup
+  module Enumerable
+    class ScheduleEnumerator
+      
+      def initialize(schedule, date)
+        @schedule = schedule
+        @date = date
+        @date = @date.to_date if @date.respond_to?(:to_date)
+        @current_date = nil
+      end
+      
+      attr_reader :schedule
+      delegate :start_date, :weekly_pattern, :monthly_pattern, :ends?, :end_date, :skip, :to => :schedule
+      
+      
+      
+      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
+      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
+      end
+      
+      
+      
+      # These two methods DO NOT assume that
+      # date is predicted by the given schedule
+      
+      def first_occurrence_on_or_after(date)
+        raise NotImplementedError
+      end
+      
+      def first_occurrence_on_or_before(date)
+        raise NotImplementedError
+      end
+      
+      
+      # These two methods DO assume that
+      # date is predicted by the given schedule
+      
+      def next_occurrence_after(date)
+        first_occurrence_on_or_after(date + 1)
+      end
+      
+      def next_occurrence_before(date)
+        first_occurrence_on_or_before(date - 1)
+      end
+      
+      
+      
+    end
+  end
+end

data/lib/hiccup/enumerable/weekly_enumerator.rb

@@ -0,0 +1,63 @@
+require 'hiccup/enumerable/schedule_enumerator'
+
+module Hiccup
+  module Enumerable
+    class WeeklyEnumerator < ScheduleEnumerator
+      
+      
+      def initialize(*args)
+        super
+        
+        # Use more efficient iterator methods if
+        # weekly_pattern is simple enough
+        
+        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
+        end
+      end
+      
+      
+      def first_occurrence_on_or_after(date)        
+        result = nil
+        wday = date.wday
+        weekly_pattern.each do |weekday|
+          wd = Date::DAYNAMES.index(weekday)
+          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
+          temp += (skip - remainder) * 7 if remainder > 0
+          
+          result = temp if !result || (temp < result)
+        end
+        result
+      end
+      
+      def first_occurrence_on_or_before(date)
+        result = nil
+        wday = date.wday
+        weekly_pattern.each do |weekday|
+          wd = Date::DAYNAMES.index(weekday)
+          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
+          temp -= remainder * 7 if remainder > 0
+          
+          result = temp if !result || (temp > result)
+        end
+        result
+      end
+      
+      
+    end
+  end
+end

data/lib/hiccup/enumerable.rb

@@ -1,173 +1,65 @@
-require "hiccup/convenience"
 require "hiccup/core_ext/date"
-require "hiccup/core_ext/duration"
+require "hiccup/enumerable/annually_enumerator"
+require "hiccup/enumerable/monthly_enumerator"
+require "hiccup/enumerable/never_enumerator"
+require "hiccup/enumerable/weekly_enumerator"
 
 
 module Hiccup
   module Enumerable
-    include Convenience
+    
+    
+    
+    def enumerator
+      @enumerator ||= "Hiccup::Enumerable::#{kind.to_s.classify}Enumerator".constantize
+    end
+    
+    def kind=(value)
+      super
+      @enumerator = nil
+    end
     
     
     
     def occurrences_during_month(year, month)
       date1 = Date.new(year, month, 1)
-      date2 = date1.at_end_of_month
+      date2 = Date.new(year, month, -1)
       occurrences_between(date1, date2)
     end
     
     
     
     def occurrences_between(earlier_date, later_date)
-      [].tap do |occurrences|
-        if (!ends? || earlier_date <= end_date) && (later_date >= start_date)
-          earlier_date = start_date if (earlier_date < start_date)
-          later_date = end_date if ends? && (later_date > end_date)
-          occurrence = first_occurrence_on_or_after(earlier_date)
-          while occurrence && (occurrence <= later_date)
-            occurrences << occurrence
-            occurrence = next_occurrence_after(occurrence)
-          end
-        end
+      earlier_date = start_date if earlier_date < start_date
+      
+      occurrences = []
+      enum = enumerator.new(self, earlier_date)
+      while (occurrence = enum.next) && (occurrence <= later_date)
+        occurrences << occurrence
       end
+      occurrences
     end
     
     
     
     def first_occurrence_on_or_after(date)
-      date = date.to_date unless date.is_a?(Date) || !date.respond_to?(:to_date)
-      date = self.start_date if (date < self.start_date)
-      
-      result = nil
-      case kind
-      when :never
-        result = date if date == self.start_date # (date > self.start_date) ? nil : self.start_date
-      
-      when :weekly
-        wday = date.wday
-        weekly_pattern.each do |weekday|
-          wd = Date::DAYNAMES.index(weekday)
-          wd = wd + 7 if wd < wday
-          days_in_the_future = wd - wday
-          temp = days_in_the_future.days.after(date)
-          
-          remainder = ((temp - start_date) / 7).to_i % skip
-          temp = (skip - remainder).weeks.after(temp) if (remainder > 0)
-          
-          result = temp if !result || (temp < result)
-        end
-      
-      when :monthly
-        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, i.months.after(date))
-            break if temp && (temp >= date)
-          end
-          next unless temp
-          
-          remainder = months_between(temp, start_date) % skip
-          temp = monthly_occurrence_to_date(occurrence, (skip - remainder).months.after(temp)) if (remainder > 0)
-          next unless temp
-          
-          result = temp if !result || (temp < result)
-        end
-      
-      when :annually
-        result, try_to_use_2_29 = if((start_date.month == 2) && (start_date.day == 29))
-          [Date.new(date.year, 2, 28), true]
-        else
-          [Date.new(date.year, start_date.month, start_date.day), false]
-        end
-        result = 1.year.after(result) if (result < date)
-        
-        remainder = years_between(result, start_date) % skip
-        result = (skip - remainder).years.after(result) if (remainder > 0)
-        
-        if try_to_use_2_29
-          begin
-            date = Date.new(result.year, 2, 29)
-          rescue
-          end
-        end
-      end
-      
-      result = nil if (self.ends? && result && result > self.end_date)
-      result
+      date = start_date if (date < start_date)
+      enumerator.new(self, date).next
     end
     
-    
-    
     def next_occurrence_after(date)
-      first_occurrence_on_or_after(1.day.after(date))
+      first_occurrence_on_or_after(date + 1)
     end
     
     
     
     def first_occurrence_on_or_before(date)
-      date = date.to_date unless date.is_a?(Date) || !date.respond_to?(:to_date)
-      date = self.end_date if (self.ends? && date > self.end_date)
-      
-      result = nil
-      case kind
-      when :never
-        result = date # (date > self.start_date) ? nil : self.start_date
-      
-      when :weekly
-        wday = date.wday
-        weekly_pattern.each do |weekday|
-          wd = Date::DAYNAMES.index(weekday)
-          wd = wd - 7 if wd > wday
-          days_in_the_past = wday - wd
-          temp = days_in_the_past.days.before(date)
-          
-          remainder = ((temp - start_date) / 7).to_i % skip
-          temp = remainder.weeks.before(temp) if (remainder > 0)
-          
-          result = temp if !result || (temp > result)
-        end
-      
-      when :monthly
-        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, i.months.before(date))
-            break if temp && (temp <= date)
-          end
-          next unless temp
-          
-          remainder = months_between(temp, start_date) % skip
-          temp = monthly_occurrence_to_date(occurrence, remainder.months.before(temp)) if (remainder > 0)
-          next unless temp
-          
-          result = temp if !result || (temp > result)
-        end
-      
-      when :annually
-        result, try_to_use_2_29 = if((start_date.month == 2) && (start_date.day == 29))
-          [Date.new(date.year, 2, 28), true]
-        else
-          [Date.new(date.year, start_date.month, start_date.day), false]
-        end
-        result = 1.year.before(result) if (result < date)
-
-        remainder = years_between(result, start_date) % skip
-        result = remainder.years.before(result) if (remainder > 0)
-        if try_to_use_2_29
-          begin
-            date = Date.new(result.year, 2, 29)
-          rescue
-          end
-        end
-      end
-      
-      result = nil if (result && result < self.start_date)
-      result
+      date = end_date if (ends? && date > end_date)
+      enumerator.new(self, date).prev
     end
     
-    
-    
     def first_occurrence_before(date)
-      first_occurrence_on_or_before(1.day.before(date))
+      first_occurrence_on_or_before(date - 1)
     end
     
     
@@ -181,68 +73,21 @@ module Hiccup
     
     
     def n_occurrences_before(limit, date)
-      n_occurrences_on_or_before(limit, 1.day.before(date))
+      n_occurrences_on_or_before(limit, date - 1)
     end
     
     def n_occurrences_on_or_before(limit, date)
+      date = end_date if (ends? && date > end_date)
+      
       occurrences = []
-      occurrence = first_occurrence_on_or_before(date)
-      while occurrence && occurrences.length < limit
+      enum = enumerator.new(self, date)
+      while (occurrence = enum.prev) && occurrences.length < limit
         occurrences << occurrence
-        occurrence = first_occurrence_before(occurrence)
       end
       occurrences
     end
     
     
     
-    def monthly_occurrence_to_date(occurrence, date)
-      year, month = date.year, date.month
-      
-      day = begin
-        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
-        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
-    
-    
-    
-  private
-    
-    
-    
-    def months_between(date1, date2)
-      later_date, earlier_date = sort_dates(date1, date2)
-      later_date.get_months_since(earlier_date)
-    end
-    
-    def weeks_between(date1, date2)
-      later_date, earlier_date = sort_dates(date1, date2)
-      later_date.get_weeks_since(earlier_date)
-    end
-    
-    def years_between(date1, date2)
-      later_date, earlier_date = sort_dates(date1, date2)
-      later_date.get_years_since(earlier_date)
-    end
-    
-    def sort_dates(date1, date2)
-      (date1 > date2) ? [date1, date2] : [date2, date1]
-    end
-    
-    
-    
   end
 end

data/lib/hiccup/{inferrable.rb → inferable.rb}

@@ -2,29 +2,138 @@ require 'active_support/concern'
 require 'active_support/core_ext/date/conversions'
 require 'hiccup/core_ext/enumerable'
 require 'hiccup/core_ext/hash'
+require "hiccup/core_ext/date"
 
 
 module Hiccup
-  module Inferrable
+  module Inferable
     extend ActiveSupport::Concern
     
     module ClassMethods
       
+      def infer(dates, options={})
+        dates = extract_array_of_dates!(dates)
+        
+        enumerator = DatesEnumerator.new(dates)
+        guesser = Guesser.new(self, options)
+        confidences = []
+        confidence_threshold = 0.6
+        rewind_by = 0
+        
+        until enumerator.done?
+          date = enumerator.next
+          guesser << date
+          confidences << guesser.confidence.to_f
+          
+          if guesser.predicted?(date)
+            rewind_by = 0
+          else
+            rewind_by += 1
+          end
+          
+          # puts "date: #{date}, confidences: #{confidences}, rewind_by: #{rewind_by}" if options[:verbose]
+          
+          # if the last two confidences are both below a certain
+          # threshhold and both declining, back up to where we
+          # started to go wrong and start a new schedule.
+          
+          if confidences.length >= 3 &&
+             confidences[-1] < confidence_threshold &&
+             confidences[-2] < confidence_threshold &&
+             confidences[-1] < confidences[-2] &&
+             confidences[-2] < confidences[-3]
+            
+            rewind_by -= 1 if rewind_by == guesser.count
+            enumerator.rewind_by(rewind_by)
+            guesser.restart!
+            confidences = []
+            rewind_by = 0
+          end
+        end
+        
+        guesser.stop!
+        
+        guesser.guesses
+      end
       
       
-      def infer(dates, options={})
+      
+      def extract_array_of_dates!(dates)
+        raise_invalid_dates_error! unless dates.respond_to?(:each)
+        dates.map { |date| assert_date!(date) }.sort
+      end
+      
+      def assert_date!(date)
+        return date if date.is_a?(Date)
+        date.to_date rescue raise_invalid_dates_error!
+      end
+      
+      def raise_invalid_dates_error!
+        raise ArgumentError.new("Inferable.infer expects to receive a collection of dates")
+      end
+      
+      
+      
+    end
+    
+    
+    
+    class Guesser
+      
+      def initialize(klass, options={})
+        @klass = klass
         @verbose = options.fetch(:verbose, false)
-        dates = extract_array_of_dates!(dates)
-        guesses = generate_guesses(dates)
-        guess, score = pick_best_guess(guesses, dates)
-        guess
+        @guesses = []
+        start!
       end
       
+      attr_reader :guesses, :confidence
+      
+      def start!
+        save_current_guess!
+        reset_growing_understanding!
+      end
+      alias :restart! :start!
       
+      def stop!
+        start!
+      end
+      
+      def save_current_guess!
+        @guesses << @schedule if @schedule
+      end
+      
+      def reset_growing_understanding!
+        @dates = []
+        @schedule = nil
+        @confidence = 0
+      end
+      
+      
+      
+      def <<(date)
+        @dates << date
+        @schedule, @confidence = best_schedule_for(@dates)
+      end
+      
+      def count
+        @dates.length
+      end
+      
+      def predicted?(date)
+        @schedule && @schedule.contains?(date)
+      end
+      
+      
+      
+      def best_schedule_for(dates)
+        guesses = generate_guesses(dates)
+        pick_best_guess(guesses, dates)
+      end
       
       def generate_guesses(dates)
-        @start_date = dates.min
-        @end_date = dates.max
+        @start_date = dates.first
+        @end_date = dates.last
         [].tap do |guesses|
           guesses.concat generate_yearly_guesses(dates)
           guesses.concat generate_monthly_guesses(dates)
@@ -43,7 +152,7 @@ module Hiccup
 
         [].tap do |guesses|
           (1...5).each do |skip|
-            guesses << self.new.tap do |schedule|
+            guesses << @klass.new.tap do |schedule|
               schedule.kind = :annually
               schedule.start_date = start_date
               schedule.end_date = @end_date
@@ -75,7 +184,7 @@ module Hiccup
         [].tap do |guesses|
           (1...5).each do |skip|
             enumerate_by_popularity(days_by_popularity) do |days|
-              guesses << self.new.tap do |schedule|
+              guesses << @klass.new.tap do |schedule|
                 schedule.kind = :monthly
                 schedule.start_date = @start_date
                 schedule.end_date = @end_date
@@ -85,7 +194,7 @@ module Hiccup
             end
             
             enumerate_by_popularity(patterns_by_popularity) do |patterns|
-              guesses << self.new.tap do |schedule|
+              guesses << @klass.new.tap do |schedule|
                 schedule.kind = :monthly
                 schedule.start_date = @start_date
                 schedule.end_date = @end_date
@@ -114,7 +223,7 @@ module Hiccup
           
           (1...5).each do |skip|
             enumerate_by_popularity(wdays_by_popularity) do |wdays|
-              guesses << self.new.tap do |schedule|
+              guesses << @klass.new.tap do |schedule|
                 schedule.kind = :weekly
                 schedule.start_date = @start_date
                 schedule.end_date = @end_date
@@ -158,8 +267,7 @@ module Hiccup
           puts ""
         end
         
-        best_guess = scored_guesses.reject { |(guess, score)| score.to_f < 0.333 }.first
-        best_guess || Schedule.new(kind: :never)
+        scored_guesses.reject { |(guess, score)| score.to_f < 0.333 }.first
       end
       
       def score_guess(guess, input_dates)
@@ -194,22 +302,6 @@ module Hiccup
       
       
       
-      def extract_array_of_dates!(dates)
-        raise_invalid_dates_error! unless dates.respond_to?(:each)
-        dates.map { |date| assert_date!(date) }.sort
-      end
-      
-      def assert_date!(date)
-        return date if date.is_a?(Date)
-        date.to_date rescue raise_invalid_dates_error!
-      end
-      
-      def raise_invalid_dates_error!
-        raise ArgumentError.new("Inferrable.infer expects to receive a collection of dates")
-      end
-      
-      
-      
       class Score < Struct.new(:prediction_rate, :brick_rate, :complexity_rate)
         
         # as brick rate rises, our confidence in this guess drops
@@ -244,6 +336,37 @@ module Hiccup
       end
       
       
+      
+    end
+    
+    
+    
+    class DatesEnumerator
+      
+      def initialize(dates)
+        @dates = dates
+        @last_index = @dates.length - 1
+        @index = -1
+      end
+      
+      def done?
+        @index == @last_index
+      end
+      
+      def next
+        @index += 1
+        raise OutOfRangeException if @index > @last_index
+        @dates[@index]
+      end
+      
+      def rewind_by(n)
+        @index -= n
+        @index = -1 if @index < -1
+      end
+      
     end
+    
+    
+    
   end
 end

data/lib/hiccup/schedule.rb

@@ -11,7 +11,7 @@ module Hiccup
     hiccup :enumerable,
            :validatable,
            :humanizable,
-           :inferrable,
+           :inferable,
            :serializable => [:ical]
     
     

data/lib/hiccup/version.rb

@@ -1,3 +1,3 @@
 module Hiccup
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/test/duration_ext_test.rb

@@ -1,4 +1,5 @@
 require "test_helper"
+require "hiccup/core_ext/duration"
 
 
 class DurationExtTest < ActiveSupport::TestCase

data/test/enumerable_test.rb

@@ -3,6 +3,7 @@ require "test_helper"
 
 class EnumerableTest < ActiveSupport::TestCase
   include Hiccup
+  PERFORMANCE_TEST = false
   
   
   
@@ -18,6 +19,18 @@ class EnumerableTest < ActiveSupport::TestCase
   
   
   
+  test "annual recurrence with a skip" do
+    schedule = Schedule.new({
+      :kind => :annually,
+      :skip => 2,
+      :start_date => Date.new(2009,3,4)})
+    expected_dates = %w{2009-03-04 2011-03-04 2013-03-04}
+    actual_dates = schedule.occurrences_between(Date.new(2009, 01, 01), Date.new(2013, 12, 31)).map(&:to_s)
+    assert_equal expected_dates, actual_dates
+  end
+  
+  
+  
   def test_occurs_on_weekly
     schedule = Schedule.new({
       :kind => :weekly,
@@ -277,6 +290,7 @@ class EnumerableTest < ActiveSupport::TestCase
     });
     
     assert_equal [Date.new(2010, 2, 28)], schedule.occurrences_during_month(2010, 2)
+    assert_equal [Date.new(2012, 2, 29)], schedule.occurrences_during_month(2012, 2)
   end
   
   
@@ -286,7 +300,7 @@ class EnumerableTest < ActiveSupport::TestCase
       :kind => :monthly,
       :monthly_pattern => [31],
       :start_date => Date.new(2008, 2, 29)
-    });
+    })
     
     assert_equal [Date.new(2010, 1, 31)], schedule.occurrences_during_month(2010, 1)
     assert_equal [], schedule.occurrences_during_month(2010, 2)
@@ -294,38 +308,69 @@ class EnumerableTest < ActiveSupport::TestCase
   
   
   
-  # def test_monthly_occurrence_to_date
-  #   occurrence = MonthlyOccurrence.new(:ordinal => 3, :kind => "Thursday")
-  #   assert_equal 21, occurrence.to_date(2009, 5).day,   "The third Thursday in May 2009 should be the 21st"
-  #   assert_equal 16, occurrence.to_date(2009, 4).day,   "The third Thursday in April 2009 should be the 16th"
-  #   assert_equal 15, occurrence.to_date(2012, 11).day,  "The third Thursday in November 2012 should be the 15th"
-  #   
-  #   occurrence = MonthlyOccurrence.new(:ordinal => 1, :kind => "Tuesday")
-  #   assert_equal 5, occurrence.to_date(2009, 5).day,    "The first Tuesday in May 2009 should be the 5th"
-  #   assert_equal 2, occurrence.to_date(2008, 12).day,   "The first Tuesday in December 2008 should be the 2nd"
-  #   assert_equal 1, occurrence.to_date(2009, 9).day,    "The first Tuesday in September 2009 should be the 1st"
-  #   
-  #   occurrence = MonthlyOccurrence.new(:ordinal => 1, :kind => "Sunday")
-  #   assert_equal 3, occurrence.to_date(2009, 5).day,    "The first Sunday in May 2009 should be the 3rd"
-  #   assert_equal 1, occurrence.to_date(2010, 8).day,    "The first Sunday in August 2010 should be the 1st"
-  #   assert_equal 7, occurrence.to_date(2009, 6).day,    "The first Sunday in June 2009 should be the 7th"
-  #   
-  #   occurrence = MonthlyOccurrence.new(:ordinal => 1, :kind => "day")
-  #   assert_equal 1, occurrence.to_date(2009, 5).day,    "The first of May 2009 should be 1"
-  #   
-  #   occurrence = MonthlyOccurrence.new(:ordinal => 22, :kind => "day")
-  #   assert_equal 22, occurrence.to_date(2009, 5).day,   "The twenty-second of May 2009 should be 22"
-  #   
-  #   #occurrence = MonthlyOccurrence.new(:ordinal => -1, :kind => "Sunday")
-  #   #assert_equal 31, occurrence.to_date(2009, 5),       "The last Sunday in May 2009 should be the 31st"
-  # end
-  #
-  #
-  # test "to_date should return nil if there is no occurrence with the specified parameters" do
-  #   mo = MonthlyOccurrence.new(:ordinal => 5, :kind => "Monday")
-  #   assert_equal "fifth Monday", mo.to_s
-  #   assert_nil mo.to_date(2010, 6)
-  # end
+  if PERFORMANCE_TEST
+    test "performance test" do
+      n = 100
+      
+      # Each of these schedules should describe 52 events
+      
+      Benchmark.bm(20) do |x|
+        x.report("weekly (simple):") do
+          n.times do 
+            Schedule.new(
+              :kind => :weekly,
+              :weekly_pattern => ["Friday"],
+              :start_date => Date.new(2009, 1, 1)) \
+              .occurrences_between(Date.new(2009, 1, 1), Date.new(2009, 12, 31))
+          end
+        end
+        x.report("weekly (complex):") do
+          n.times do 
+            Schedule.new(
+              :kind => :weekly,
+              :weekly_pattern => ["Monday", "Wednesday", "Friday"],
+              :start_date => Date.new(2009, 1, 1)) \
+              .occurrences_between(Date.new(2009, 1, 1), Date.new(2009, 5, 2))
+          end
+        end
+        x.report("monthly (simple):") do
+          n.times do
+            Schedule.new(
+              :kind => :monthly,
+              :monthly_pattern => [[2, "Monday"]],
+              :start_date => Date.new(2009, 1, 1)) \
+              .occurrences_between(Date.new(2009, 1, 1), Date.new(2013, 4, 30))
+          end
+        end
+        x.report("monthly (complex):") do
+          n.times do
+            Schedule.new(
+              :kind => :monthly,
+              :monthly_pattern => [[2, "Monday"], [4, "Monday"]],
+              :start_date => Date.new(2009, 1, 1)) \
+              .occurrences_between(Date.new(2009, 1, 1), Date.new(2011, 3, 1))
+          end
+        end
+        x.report("yearly:") do
+          n.times do
+            Schedule.new(
+              :kind => :annually,
+              :start_date => Date.new(1960, 3, 15)) \
+              .occurrences_between(Date.new(1960, 1, 1), Date.new(2011, 12, 31))
+          end
+        end
+        x.report("yearly (2/29):") do
+          n.times do
+            Schedule.new(
+              :kind => :annually,
+              :start_date => Date.new(1960, 2, 29)) \
+              .occurrences_between(Date.new(1960, 1, 1), Date.new(2011, 12, 31))
+          end
+        end
+      end
+      
+    end
+  end
   
   
   

data/test/inferrable_test.rb

@@ -3,7 +3,7 @@ require "test_helper"
 # Ideas: see 3/4/10, 3/5/11, 3/4/12 as closer to
 #        a pattern than 3/4/10, 9/15/11, 3/4/12.
 
-class InferrableTest < ActiveSupport::TestCase
+class InferableTest < ActiveSupport::TestCase
   include Hiccup
   
   
@@ -46,7 +46,7 @@ class InferrableTest < ActiveSupport::TestCase
     # If bricks and fails were equal, the annual recurrence would be the
     # preferred guess, but the monthly one makes more sense.
     # It is better to brick than to fail.
-    schedule = Schedule.infer(dates)
+    schedule = Schedule.infer(dates).first
     assert_equal :monthly, schedule.kind
   end
   
@@ -58,8 +58,8 @@ class InferrableTest < ActiveSupport::TestCase
   
   test "should infer an annual" do
     dates = %w{2010-3-4 2011-3-4 2012-3-4}
-    schedule = Schedule.infer(dates)
-    assert_equal "Every year on March 4", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["Every year on March 4"], schedules.map(&:humanize)
   end
   
   
@@ -67,22 +67,22 @@ class InferrableTest < ActiveSupport::TestCase
   
   test "should infer a schedule that occurs every other year" do
     dates = %w{2010-3-4 2012-3-4 2014-3-4}
-    schedule = Schedule.infer(dates)
-    assert_equal "Every other year on March 4", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["Every other year on March 4"], schedules.map(&:humanize)
   end
   
   # ... where some of the input is wrong
   
   test "should infer a yearly schedule when one of the dates was rescheduled" do
     dates = %w{2010-3-4 2011-9-15 2012-3-4 2013-3-4}
-    schedule = Schedule.infer(dates)
-    assert_equal "Every year on March 4", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["Every year on March 4"], schedules.map(&:humanize)
   end
   
   test "should infer a yearly schedule when the first date was rescheduled" do
     dates = %w{2010-3-6 2011-3-4 2012-3-4 2013-3-4}
-    schedule = Schedule.infer(dates)
-    assert_equal "Every year on March 4", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["Every year on March 4"], schedules.map(&:humanize)
   end
   
   
@@ -93,24 +93,24 @@ class InferrableTest < ActiveSupport::TestCase
   
   test "should infer a monthly schedule that occurs on a date" do
     dates = %w{2012-2-4 2012-3-4 2012-4-4}
-    schedule = Schedule.infer(dates)
-    assert_equal "The 4th of every month", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["The 4th of every month"], schedules.map(&:humanize)
     
     dates = %w{2012-2-17 2012-3-17 2012-4-17}
-    schedule = Schedule.infer(dates)
-    assert_equal "The 17th of every month", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["The 17th of every month"], schedules.map(&:humanize)
   end
   
   test "should infer a monthly schedule that occurs on a weekday" do
     dates = %w{2012-7-9 2012-8-13 2012-9-10}
-    schedule = Schedule.infer(dates)
-    assert_equal "The second Monday of every month", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["The second Monday of every month"], schedules.map(&:humanize)
   end
   
   test "should infer a schedule that occurs several times a month" do
     dates = %w{2012-7-9 2012-7-23 2012-8-13 2012-8-27 2012-9-10 2012-9-24}
-    schedule = Schedule.infer(dates)
-    assert_equal "The second Monday and fourth Monday of every month", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["The second Monday and fourth Monday of every month"], schedules.map(&:humanize)
   end
   
   
@@ -118,8 +118,8 @@ class InferrableTest < ActiveSupport::TestCase
   
   test "should infer a schedule that occurs every third month" do
     dates = %w{2012-2-4 2012-5-4 2012-8-4}
-    schedule = Schedule.infer(dates)
-    assert_equal "The 4th of every third month", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["The 4th of every third month"], schedules.map(&:humanize)
   end
   
   
@@ -127,33 +127,33 @@ class InferrableTest < ActiveSupport::TestCase
   
   test "should infer a monthly (by day) schedule when one day was rescheduled" do
     dates = %w{2012-10-02 2012-11-02 2012-12-03}
-    schedule = Schedule.infer(dates)
-    assert_equal "The 2nd of every month", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["The 2nd of every month"], schedules.map(&:humanize)
   end
   
   test "should infer a monthly (by day) schedule when the first day was rescheduled" do
     dates = %w{2012-10-03 2012-11-02 2012-12-02}
-    schedule = Schedule.infer(dates)
-    assert_equal "The 2nd of every month", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["The 2nd of every month"], schedules.map(&:humanize)
   end
   
   
   test "should infer a monthly (by weekday) schedule when one day was rescheduled" do
     dates = %w{2012-10-02 2012-11-06 2012-12-05} # 1st Tuesday, 1st Tuesday, 1st Wednesday
-    schedule = Schedule.infer(dates)
-    assert_equal "The first Tuesday of every month", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["The first Tuesday of every month"], schedules.map(&:humanize)
   end
   
   test "should infer a monthly (by weekday) schedule when the first day was rescheduled" do
     dates = %w{2012-10-03 2012-11-01 2012-12-06} # 1st Wednesday, 1st Thursday, 1st Thursday
-    schedule = Schedule.infer(dates)
-    assert_equal "The first Thursday of every month", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["The first Thursday of every month"], schedules.map(&:humanize)
   end
   
   test "should infer a monthly (by weekday) schedule when the first day was rescheduled 2" do
     dates = %w{2012-10-11 2012-11-01 2012-12-06} # 2nd Thursday, 1st Thursday, 1st Thursday
-    schedule = Schedule.infer(dates)
-    assert_equal "The first Thursday of every month", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["The first Thursday of every month"], schedules.map(&:humanize)
   end
   
   
@@ -164,14 +164,14 @@ class InferrableTest < ActiveSupport::TestCase
   
   test "should infer a weekly schedule" do
     dates = %w{2012-3-4 2012-3-11 2012-3-18}
-    schedule = Schedule.infer(dates)
-    assert_equal "Every Sunday", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["Every Sunday"], schedules.map(&:humanize)
   end
   
   test "should infer a schedule that occurs several times a week" do
     dates = %w{2012-3-6 2012-3-8 2012-3-13 2012-3-15 2012-3-20 2012-3-22}
-    schedule = Schedule.infer(dates)
-    assert_equal "Every Tuesday and Thursday", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["Every Tuesday and Thursday"], schedules.map(&:humanize)
   end
   
   
@@ -179,8 +179,8 @@ class InferrableTest < ActiveSupport::TestCase
   
   test "should infer weekly recurrence for something that occurs every other week" do
     dates = %w{2012-3-6 2012-3-8 2012-3-20 2012-3-22}
-    schedule = Schedule.infer(dates)
-    assert_equal "Tuesday and Thursday of every other week", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["Tuesday and Thursday of every other week"], schedules.map(&:humanize)
   end
   
   
@@ -188,14 +188,14 @@ class InferrableTest < ActiveSupport::TestCase
   
   test "should infer a weekly schedule (missing dates)" do
     dates = %w{2012-3-4 2012-3-11 2012-3-25}
-    schedule = Schedule.infer(dates)
-    assert_equal "Every Sunday", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["Every Sunday"], schedules.map(&:humanize)
   end
   
   test "should infer a schedule that occurs several times a week (missing dates)" do
     dates = %w{2012-3-6 2012-3-8 2012-3-15 2012-3-20 2012-3-27 2012-3-29}
-    schedule = Schedule.infer(dates)
-    assert_equal "Every Tuesday and Thursday", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["Every Tuesday and Thursday"], schedules.map(&:humanize)
   end
   
   
@@ -203,14 +203,14 @@ class InferrableTest < ActiveSupport::TestCase
   
   test "should infer a weekly schedule when one day was rescheduled" do
     dates = %w{2012-10-02 2012-10-09 2012-10-15} # a Tuesday, a Tuesday, and a Monday
-    schedule = Schedule.infer(dates)
-    assert_equal "Every Tuesday", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["Every Tuesday"], schedules.map(&:humanize)
   end
   
   test "should infer a weekly schedule when the first day was rescheduled" do
     dates = %w{2012-10-07 2012-10-10 2012-10-17} # a Sunday, a Wednesday, and a Wednesday
-    schedule = Schedule.infer(dates)
-    assert_equal "Every Wednesday", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["Every Wednesday"], schedules.map(&:humanize)
   end
   
   
@@ -225,20 +225,28 @@ class InferrableTest < ActiveSupport::TestCase
     ]
     
     arbitrary_date_ranges.each do |dates|
-      schedule = Schedule.infer(dates)
-      fail "There should be no pattern to the dates #{dates}, but Hiccup guessed \"#{schedule.humanize}\"" unless schedule.never?
+      schedules = Schedule.infer(dates)
+      fail "There should be no pattern to the dates #{dates}, but Hiccup guessed \"#{schedules.map(&:humanize)}\"" if schedules.any?
     end
   end
   
   
   
+  test "should infer multiple schedules from mixed input" do
+    dates = %w{2012-11-05 2012-11-12 2012-11-19 2012-11-28 2012-12-05 2012-12-12} # three Mondays then three Wednesdays
+    schedules = Schedule.infer(dates)
+    assert_equal ["Every Monday", "Every Wednesday"],
+      schedules.map(&:humanize)
+  end
+  
+  
+  
   test "should diabolically complex schedules" do
     dates = %w{2012-11-06 2012-11-08 2012-11-15 2012-11-20 2012-11-27 2012-11-29 2013-02-05 2013-02-14 2013-02-21 2013-02-19 2013-02-26 2013-05-07 2013-05-09 2013-05-16 2013-05-28 2013-05-21 2013-05-30}
-    schedule = Schedule.infer(dates)
-    assert_equal "The first Tuesday, second Thursday, third Thursday, third Tuesday, fourth Tuesday, and fifth Thursday of every third month", schedule.humanize
+    schedules = Schedule.infer(dates)
+    assert_equal ["The first Tuesday, second Thursday, third Thursday, third Tuesday, fourth Tuesday, and fifth Thursday of every third month"], schedules.map(&:humanize)
   end
   
   
   
-  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hiccup
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-06 00:00:00.000000000 Z
+date: 2012-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -145,8 +145,13 @@ files:
 - lib/hiccup/core_ext/fixnum.rb
 - lib/hiccup/core_ext/hash.rb
 - lib/hiccup/enumerable.rb
+- lib/hiccup/enumerable/annually_enumerator.rb
+- lib/hiccup/enumerable/monthly_enumerator.rb
+- lib/hiccup/enumerable/never_enumerator.rb
+- lib/hiccup/enumerable/schedule_enumerator.rb
+- lib/hiccup/enumerable/weekly_enumerator.rb
 - lib/hiccup/humanizable.rb
-- lib/hiccup/inferrable.rb
+- lib/hiccup/inferable.rb
 - lib/hiccup/schedule.rb
 - lib/hiccup/serializable/ical.rb
 - lib/hiccup/serializers/ical.rb
@@ -174,7 +179,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -955647137280487206
+      hash: -1083227062532008741
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -183,10 +188,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -955647137280487206
+      hash: -1083227062532008741
 requirements: []
 rubyforge_project: hiccup
-rubygems_version: 1.8.23
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: A library for working with things that recur