ice_cube 0.3.9 → 0.4

data/lib/ice_cube.rb

@@ -30,6 +30,9 @@ module IceCube
   autoload :MonthOfYearValidation, 'ice_cube/validations/month_of_year'
   autoload :SecondOfMinuteValidation, 'ice_cube/validations/second_of_minute'
 
+  # if you're reading this code, you've just been iced
+  # http://brosicingbros.com/
+  
   VERSION = '0.2.3'
 
   IceCube::ONE_DAY = 24 * 60 * 60
@@ -44,4 +47,4 @@ module IceCube
   
   include TimeUtil
 
-end
+end

data/lib/ice_cube/rule_occurrence.rb

@@ -14,7 +14,7 @@ module IceCube
     end
        
     def all_occurrences
-      raise ArgumentError.new("Rule must specify either an until date or a count to use 'all_occurrences'") unless @rule.occurrence_count || @rule.until_date
+      raise ArgumentError.new("Rule must specify either an until date or a count to use 'all_occurrences'") unless @rule.occurrence_count || @rule.until_date || @end_time
       find_occurrences { |roc| false }
     end
    
@@ -47,15 +47,16 @@ module IceCube
       end
       #walk through all of the successive dates, looking for the next occurrence (interval-valid), then return it.
       begin
+        return nil if @end_time && date > @end_time
         return nil if @rule.until_date && date > @rule.until_date # until check
-        return RuleOccurrence.new(@rule, @start_date, date, @index + 1) if @rule.in_interval?(date, @start_date)
+        return RuleOccurrence.new(@rule, @start_date, @end_time, date, @index + 1) if @rule.in_interval?(date, @start_date)
       end while date = @rule.next_suggestion(date)
     end
     
     attr_reader :rule
    
     private
-    
+
     def find_occurrences
       include_dates = []
       roc = self
@@ -68,11 +69,12 @@ module IceCube
       include_dates
     end
       
-    def initialize(rule, start_date, date = nil, index = 0)
+    def initialize(rule, start_date, end_time, date = nil, index = 0)
       #set some variables
       @rule = rule
-      @date = date
       @start_date = start_date
+      @end_time = end_time
+      @date = date
       @index = index
     end
       

data/lib/ice_cube/rules/daily_rule.rb

@@ -2,11 +2,13 @@ module IceCube
 
   class DailyRule < Rule
 
+    # TODO repair
     # Determine whether this rule occurs on a give date.
     def in_interval?(date, start_date)
       #make sure we're in a proper interval
       day_count = ((date - start_date) / IceCube::ONE_DAY).to_i
       day_count % @interval == 0
+      true
     end
 
     def to_ical 

data/lib/ice_cube/rules/weekly_rule.rb

@@ -7,6 +7,7 @@ module IceCube
     # and we're in a valid day of the week.
     def in_interval?(date, start_date)
       #make sure we're in the right interval
+      date = adjust(date, start_date)
       week_of_year = Date.civil(date.year, date.month, date.day).cweek
       week_of_year % @interval == 0
     end

data/lib/ice_cube/schedule.rb

@@ -2,7 +2,8 @@ module IceCube
 
   class Schedule
 
-    attr_reader :rdates, :exdates, :start_date, :duration
+    attr_reader :rdates, :exdates, :start_date, :duration, :end_time
+    alias :start_time :start_date
     
     def initialize(start_date, options = {})
       @rrule_occurrence_heads = []
@@ -12,6 +13,8 @@ module IceCube
       @start_date = start_date
       raise ArgumentError.new('Duration cannot be negative') if options[:duration] && options[:duration] < 0
       @duration = options[:duration]
+      raise ArgumentError.new('Start time must be before end time') if options[:end_time] && options[:end_time] < @start_date
+      @end_time = options[:end_time]
     end
 
     # Convert the schedule to a hash, reverse of Schedule.from_hash
@@ -23,6 +26,7 @@ module IceCube
       hash[:rdates] = @rdates
       hash[:exdates] = @exdates
       hash[:duration] = @duration
+      hash[:end_time] = @end_time
       hash
     end
 
@@ -32,6 +36,7 @@ module IceCube
       hash[:start_date] = TimeUtil.serializable_time(hash[:start_date])
       hash[:rdates] = hash[:rdates].map { |t| TimeUtil.serializable_time(t) }
       hash[:exdates] = hash[:exdates].map { |t| TimeUtil.serializable_time(t) }
+      hash[:end_time] = TimeUtil.serializable_time(hash[:end_time])
       hash.to_yaml
     end
 
@@ -39,7 +44,7 @@ module IceCube
     def self.from_hash(hash)
       options = {}
       options[:duration] = hash[:duration] if hash.has_key?(:duration)
-      
+      options[:end_time] = hash[:end_time] if hash.has_key?(:end_time)
       schedule = Schedule.new(hash[:start_date], options)
       hash[:rrules].each { |rr| schedule.add_recurrence_rule Rule.from_hash(rr) }
       hash[:exrules].each { |ex| schedule.add_exception_rule Rule.from_hash(ex) }
@@ -77,6 +82,9 @@ module IceCube
         representation << SEPARATOR unless representation.empty?
         representation << @exdates.uniq.sort.map { |d| 'not on ' << d.strftime(TIME_FORMAT) }.join(SEPARATOR)
       end
+      if @end_time
+        representation << "until #{end_time.strftime(TIME_FORMAT)}"
+      end
       representation
     end
 
@@ -89,14 +97,16 @@ module IceCube
 
     # Determine whether a given time adheres to the ruleset of this schedule.
     def occurs_at?(date)
+      return false if @end_time && date > @end_time
       dates = occurrences(date)
       dates.last == date
     end
     
     # Determine whether a given date appears in the times returned by the schedule
     # Required activeSupport
-    def occurs_on?(date)
+    def occurs_on?(date)      
       time = date.to_time
+      return false if @end_time && time > @end_time
       occurrences_between(time.beginning_of_day, time.end_of_day).any?
     end
         
@@ -109,6 +119,7 @@ module IceCube
     
     # Find all occurrences until a certain date
     def occurrences(end_date)
+      end_date = @end_time if @end_time && @end_time < end_date
       find_occurrences { |head| head.upto(end_date) }
     end
 
@@ -122,7 +133,7 @@ module IceCube
     # Add a rule of any type as an recurrence in this schedule
     def add_recurrence_rule(rule)
       raise ArgumentError.new('Argument must be a valid rule') unless rule.class < Rule
-      @rrule_occurrence_heads << RuleOccurrence.new(rule, @start_date)
+      @rrule_occurrence_heads << RuleOccurrence.new(rule, @start_date, @end_time)
     end
 
     def rrules
@@ -132,7 +143,7 @@ module IceCube
     # Add a rule of any type as an exception to this schedule
     def add_exception_rule(rule)
       raise ArgumentError.new('Argument must be a valid rule') unless rule.class < Rule
-      @exrule_occurrence_heads << RuleOccurrence.new(rule, @start_date)
+      @exrule_occurrence_heads << RuleOccurrence.new(rule, @start_date, @end_time)
     end
 
     def exrules 
@@ -150,6 +161,9 @@ module IceCube
     end   
 
     def occurrences_between(begin_time, end_time)
+      # adjust to the propert end date
+      end_time = @end_time if @end_time && @end_time < end_time
+      # collect the occurrences
       exclude_dates, include_dates = Set.new(@exdates), SortedSet.new(@rdates)
       @rrule_occurrence_heads.each do |rrule_occurrence_head|
         include_dates.merge(rrule_occurrence_head.between(begin_time, end_time))
@@ -166,7 +180,7 @@ module IceCube
 
     # tell if, from a list of rule_occurrence heads, a certain time is occurring
     def any_occurring_at?(what, time)
-      return false if @start_time && itime < @start_time
+      return false if @start_time && time < @start_time
       what.any? do |occurrence_head|
         # time is less than now and duration is less than that distance
         possibilities = occurrence_head.between(@start_date, time)

data/lib/ice_cube/version.rb

@@ -1,5 +1,5 @@
 module IceCube
   
-  VERSION = "0.3.9"
+  VERSION = "0.4"
 
 end

metadata

@@ -4,9 +4,8 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 9
-  version: 0.3.9
+  - 4
+  version: "0.4"
 platform: ruby
 authors: 
 - John Crepezzi
@@ -14,7 +13,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-01 00:00:00 -04:00
+date: 2010-06-25 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency