ice_cube 0.6.14 → 0.7.0

data/lib/ice_cube/rules/daily_rule.rb

@@ -1,34 +1,12 @@
 module IceCube
 
-  class DailyRule < Rule
+  class DailyRule < ValidatedRule
 
-    # 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.to_date - start_date.to_date      
-      day_count % @interval == 0
-    end
-
-    def to_ical
-      'FREQ=DAILY' << to_ical_base
-    end
-
-    def to_s
-      to_s_base 'Daily', "Every #{@interval} days"
-    end
-
-    protected
-
-    def default_jump(date, attempt_count = nil)
-      goal = date + IceCube::ONE_DAY * @interval
-      adjust(goal, date)
-    end
-
-    private
+    include Validations::DailyInterval
 
-    def initialize(interval)
-      super(interval)
+    def initialize(interval = 1)
+      interval(interval)
+      schedule_lock(:hour, :min, :sec)
     end
 
   end

data/lib/ice_cube/rules/hourly_rule.rb

@@ -1,34 +1,14 @@
 module IceCube
 
-  class HourlyRule < Rule
+  class HourlyRule < ValidatedRule
 
-    # 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_HOUR).to_i
-      day_count % @interval == 0
-    end
+    include Validations::HourlyInterval
 
-    def to_ical 
-      'FREQ=HOURLY' << to_ical_base
-    end
-        
-    def to_s
-      to_s_base 'Hourly', "Every #{@interval} hours"
+    def initialize(interval = 1)
+      interval(interval)
+      schedule_lock(:min, :sec)
     end
-        
-    protected
-    
-    def default_jump(date, attempt_count = nil)
-      date + IceCube::ONE_HOUR * @interval
-    end
-        
-    private
-    
-    def initialize(interval)
-      super(interval)
-    end  
-      
+
   end
 
 end

data/lib/ice_cube/rules/minutely_rule.rb

@@ -1,34 +1,14 @@
 module IceCube
 
-  class MinutelyRule < Rule
+  class MinutelyRule < ValidatedRule
 
-    # 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_MINUTE).to_i
-      day_count % @interval == 0
-    end
+    include Validations::MinutelyInterval
 
-    def to_ical 
-      'FREQ=MINUTELY' << to_ical_base
-    end
-        
-    def to_s
-      to_s_base 'Minutely', "Every #{@interval} minutes"
-    end
-        
-    protected
-    
-    def default_jump(date, attempt_count = nil)
-      date + IceCube::ONE_MINUTE
+    def initialize(interval = 1)
+      interval(interval)
+      schedule_lock(:sec)
     end
 
-    private
-
-    def initialize(interval)
-      super(interval)
-    end
-        
   end
 
 end

data/lib/ice_cube/rules/monthly_rule.rb

@@ -1,38 +1,14 @@
 module IceCube
 
-  class MonthlyRule < Rule
+  class MonthlyRule < ValidatedRule
 
-    # Determine for a given date/start_date if this rule occurs or not.
-    # Month rules occur if we're in a valid interval
-    # and either (1) we're on a valid day of the week (ie: first sunday of the month)
-    # or we're on a valid day of the month (1, 15, -1)
-    # Note: Rollover is not implemented, so the 35th day of the month is invalid.
-    def in_interval?(date, start_date)
-      # make sure we're in the proper interval
-      months_to_start_date = (date.month - start_date.month) + (date.year - start_date.year) * 12
-      months_to_start_date % @interval == 0
-    end
-    
-    def to_ical 
-      'FREQ=MONTHLY' << to_ical_base
-    end
-    
-    def to_s
-      to_s_base 'Monthly', "Every #{@interval} months"
-    end
-    
-    protected
-    
-    def default_jump(date, attempt_count = 1)
-      TimeUtil.date_in_n_months(date, attempt_count * @interval)
-    end
- 
-    private
+    include Validations::MonthlyInterval
 
-    def initialize(interval)
-      super(interval)
+    def initialize(interval = 1)
+      interval(interval)
+      schedule_lock(:day, :hour, :min, :sec)
     end
-       
+
   end
 
 end

data/lib/ice_cube/rules/secondly_rule.rb

@@ -1,34 +1,13 @@
 module IceCube
 
-  class SecondlyRule < Rule
+  class SecondlyRule < ValidatedRule
+    
+    include Validations::SecondlyInterval
 
-    # 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
-      day_count % @interval == 0
+    def initialize(interval = 1)
+      interval(interval)
     end
 
-    def to_ical 
-      'FREQ=SECONDLY' << to_ical_base
-    end
-        
-    def to_s
-      to_s_base 'Secondly', "Every #{@interval} seconds"
-    end
-        
-    protected
-           
-    def default_jump(date, attempt_count = nil)
-      date + 1
-    end
-
-    private
-
-    def initialize(interval)
-      super(interval)
-    end
-             
   end
 
 end

data/lib/ice_cube/rules/weekly_rule.rb

@@ -1,45 +1,14 @@
 module IceCube
 
-  class WeeklyRule < Rule
-    
-    # Determine whether or not this rule occurs on a given date.
-    # Weekly rules occurs if we're in one of the interval weeks,
-    # 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)
+  class WeeklyRule < ValidatedRule
 
-      date = Date.civil(date.year, date.month, date.day)
-      start_date = Date.civil(start_date.year, start_date.month, start_date.day)
+    include Validations::WeeklyInterval
 
-      #Move both to the start of their respective weeks,
-      #and find the number of full weeks between them
-      no_weeks = ((date - date.wday) - (start_date - start_date.wday)) / 7
-
-      no_weeks % @interval == 0
-    end
-    
-    def to_ical 
-      'FREQ=WEEKLY' << to_ical_base
-    end
-    
-    def to_s
-      to_s_base 'Weekly', "Every #{@interval} weeks"
+    def initialize(interval = 1)
+      interval(interval)
+      schedule_lock(:wday, :hour, :min, :sec)
     end
-    
-    protected
-    
-    def default_jump(date, attempt_count = nil)
-      goal = date + 7 * IceCube::ONE_DAY * @interval
-      adjust(goal, date)
-    end
-
-    private
 
-    def initialize(interval)
-      super(interval)
-    end
-     
   end
 
 end

data/lib/ice_cube/rules/yearly_rule.rb

@@ -1,40 +1,14 @@
 module IceCube
 
-  class YearlyRule < Rule
-    
-    # Determine whether or not the rule, given a start_date,
-    # occurs on a given date.
-    # Yearly occurs if we're in a proper interval
-    # and either (1) we're on a day of the year, or (2) we're on a month of the year as specified
-    # Note: rollover dates don't work, so you can't ask for the 400th day of a year
-    # and expect to roll into the next year (this might be a possible direction in the future)
-    def in_interval?(date, start_date)
-      #make sure we're in the proper interval
-      (date.year - start_date.year) % @interval == 0
-    end
-    
-    def to_ical 
-      'FREQ=YEARLY' << to_ical_base
-    end
-    
-    def to_s
-      to_s_base 'Yearly', "Every #{@interval} years"
-    end
-    
-    protected
-    
-    # one year from now, the same month and day of the year
-    def default_jump(date, attempt_count = 1)
-      # jump by months since there's no reliable way to jump by year
-      TimeUtil.date_in_n_months(date, attempt_count * @interval * 12)
-    end
-    
-    private
+  class YearlyRule < ValidatedRule
 
-    def initialize(interval)
-      super(interval)
+    include Validations::YearlyInterval
+
+    def initialize(interval = 1)
+      interval(interval)
+      schedule_lock(:month, :day, :hour, :min, :sec)
     end
-    
+
   end
-    
+
 end

data/lib/ice_cube/schedule.rb

@@ -1,307 +1,335 @@
+require 'yaml'
+
 module IceCube
 
   class Schedule
 
-    attr_reader :rdates, :exdates, :start_date
-    attr_accessor :duration, :end_time
+    # Get the start time
+    attr_accessor :start_time
+    alias :start_date :start_time
+    alias :start_date= :start_time=
+    
+    # Get the duration
+    attr_accessor :duration
 
+    # Get the end time
+    attr_accessor :end_time
     alias :end_date :end_time
-    alias :start_time :start_date
-
-    def initialize(start_date, options = {})
-      @rrule_occurrence_heads = []
-      @exrule_occurrence_heads = []
-      @rdates = []
-      @exdates = []
-      @start_date = start_date || Time.now
-      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
+
+    # Create a new schedule
+    def initialize(start_time = nil, options = {})
+      @start_time = start_time || Time.now
       @end_time = options[:end_time]
+      @duration = options[:duration]
+      @all_recurrence_rules = []
+      @all_exception_rules = []
     end
 
-    # Change the current start date
-    def start_date=(start_date)
-      @start_date = start_date
-      @rrule_occurrence_heads.each { |ro| ro.start_date = start_date }
-      @exrule_occurrence_heads.each { |ro| ro.start_date = start_date }
-      start_date
+    # Add a recurrence time to the schedule
+    def add_recurrence_time(time)
+      return nil if time.nil?
+      rule = SingleOccurrenceRule.new(time)
+      add_recurrence_rule rule
+      time
     end
-    alias :start_time= :start_date=
+    alias :rdate :add_recurrence_time
+    alias :add_recurrence_date :add_recurrence_time
 
-    # Convert the schedule to a hash, reverse of Schedule.from_hash
-    def to_hash
-      hash = Hash.new
-      hash[:start_date] = @start_date
-      hash[:rrules] = @rrule_occurrence_heads.map { |rr| rr.rule.to_hash }
-      hash[:exrules] = @exrule_occurrence_heads.map { |ex| ex.rule.to_hash }
-      hash[:rdates] = @rdates
-      hash[:exdates] = @exdates
-      hash[:duration] = @duration
-      hash[:end_time] = @end_time
-      hash
-    end
-
-    # Convert the schedule to yaml, reverse of Schedule.from_yaml
-    def to_yaml(options = {})
-      hash = to_hash
-      hash[:start_date] = TimeUtil.serialize_time(hash[:start_date])
-      hash[:rdates] = hash[:rdates].map { |t| TimeUtil.serialize_time(t) }
-      hash[:exdates] = hash[:exdates].map { |t| TimeUtil.serialize_time(t) }
-      hash[:end_time] = TimeUtil.serialize_time(hash[:end_time])
-      hash.to_yaml(options)
-    end
-
-    # Create a schedule from a hash created by instance.to_hash
-    def self.from_hash(hash, hash_options = {})
-      options = {}
-      options[:duration] = hash[:duration] if hash.has_key?(:duration)
-      options[:end_time] = TimeUtil.deserialize_time(hash[:end_time]) if hash.has_key?(:end_time)
-      start_date = hash_options[:start_date_override] || TimeUtil.deserialize_time(hash[:start_date])
-      schedule = Schedule.new(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) }
-      hash[:rdates].each { |rd| schedule.add_recurrence_date TimeUtil.deserialize_time(rd) }
-      hash[:exdates].each { |ed| schedule.add_exception_date TimeUtil.deserialize_time(ed) }
-      schedule
+    # Add an exception time to the schedule
+    def add_exception_time(time)
+      return nil if time.nil?
+      rule = SingleOccurrenceRule.new(time)
+      add_exception_rule rule
+      time
     end
+    alias :exdate :add_exception_time
+    alias :add_exception_date :add_exception_time
 
-    # Create a schedule from a yaml string created by instance.to_yaml
-    def self.from_yaml(str, hash_options = {})
-      from_hash(YAML::load(str), hash_options)
+    # Add a recurrence rule to the schedule
+    def add_recurrence_rule(rule)
+      @all_recurrence_rules << rule unless @all_recurrence_rules.include?(rule)
     end
+    alias :rrule :add_recurrence_rule
 
-    TIME_FORMAT = '%B %e, %Y'
-    SEPARATOR = ' / '
-    NEWLINE = "\n"
+    # Remove a recurrence rule
+    def remove_recurrence_rule(rule)
+      res = @all_recurrence_rules.delete(rule)
+      res.nil? ? [] : [res]
+    end
 
-    # use with caution
-    # incomplete and not entirely tested - no time representation in dates
-    # there's a lot that can happen here
-    def to_s
-      representation_pieces = []
-      inc_dates = (@rdates - @exdates).uniq
-      representation_pieces.concat inc_dates.sort.map { |d| d.strftime(TIME_FORMAT) } unless inc_dates.empty?
-      representation_pieces.concat @rrule_occurrence_heads.map{ |r| r.rule.to_s } if @rrule_occurrence_heads
-      representation_pieces.concat @exrule_occurrence_heads.map { |r| 'not ' << r.rule.to_s } if @exrule_occurrence_heads
-      representation_pieces.concat @exdates.uniq.sort.map { |d| 'not on ' << d.strftime(TIME_FORMAT) } if @exdates
-      representation_pieces << "until #{end_time.strftime(TIME_FORMAT)}" if @end_time
-      representation_pieces.join(SEPARATOR)
+    # Add an exception rule to the schedule
+    def add_exception_rule(rule)
+      @all_exception_rules << rule unless @all_exception_rules.include?(rule)
     end
+    alias :exrule :add_exception_rule
 
-    def to_ical(force_utc = false)
-      representation_pieces = ["DTSTART#{TimeUtil.ical_format(@start_date, force_utc)}"]
-      representation_pieces << "DURATION:#{TimeUtil.ical_duration(@duration)}" if @duration
-      inc_dates = (@rdates - @exdates).uniq
-      representation_pieces.concat inc_dates.sort.map { |d| "RDATE#{TimeUtil.ical_format(d, force_utc)}" } if inc_dates.any?
-      representation_pieces.concat @exdates.uniq.sort.map { |d| "EXDATE#{TimeUtil.ical_format(d, force_utc)}" } if @exdates
-      representation_pieces.concat @rrule_occurrence_heads.map { |r| "RRULE:#{r.rule.to_ical}" } if @rrule_occurrence_heads
-      representation_pieces.concat @exrule_occurrence_heads.map { |r| "EXRULE:#{r.rule.to_ical}" } if @exrule_occurrence_heads
-      representation_pieces << "DTEND#{TimeUtil.ical_format(@end_time, force_utc)}" if @end_time
-      representation_pieces.join(NEWLINE)
+    # Remove an exception rule
+    def remove_exception_rule(rule)
+      res = @all_exception_rules.delete(rule)
+      res.nil? ? [] : [res]
     end
 
-    def occurring_at?(time)
-      return false if @exdates.include?(time)
-      return true if @rdates.include?(time)
-      return false if any_occurring_at?(@exrule_occurrence_heads, time)
-      any_occurring_at?(@rrule_occurrence_heads, time)
+    # Get the recurrence rules
+    def recurrence_rules
+      @all_recurrence_rules.reject { |r| r.is_a?(SingleOccurrenceRule) }
     end
+    alias :rrules :recurrence_rules
 
-    # 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
+    # Get the exception rules
+    def exception_rules
+      @all_exception_rules.reject { |r| r.is_a?(SingleOccurrenceRule) }
     end
+    alias :exrules :exception_rules
 
-    # Determine whether a given date appears in the times returned by the schedule
-    def occurs_on?(date)
-      if defined?(ActiveSupport::TimeWithZone) && @start_date.is_a?(ActiveSupport::TimeWithZone)
-        return active_support_occurs_on?(date)
+    # Get the recurrence times that are on the schedule
+    def recurrence_times
+      @all_recurrence_rules.select { |r| r.is_a?(SingleOccurrenceRule) }.map(&:time)
+    end
+    alias :rdates :recurrence_times
+    alias :recurrence_dates :recurrence_times
+
+    # Remove a recurrence time
+    def remove_recurrence_time(time)
+      found = false
+      @all_recurrence_rules.delete_if do |rule|
+        found = true if rule.is_a?(SingleOccurrenceRule) && rule.time == time
       end
-      # fall back to our own way of doing things
-      time_format = @start_date.utc? ? :utc : :local
-      self.occurrences_between(Time.send(time_format, date.year, date.month, date.day, 0, 0, 0), Time.send(time_format, date.year, date.month, date.day, 23, 59, 59)).any?
+      time if found
+    end
+    alias :remove_recurrence_date :remove_recurrence_time
+    alias :remove_rdate :remove_recurrence_time
+
+    # Get the exception times that are on the schedule
+    def exception_times
+      @all_exception_rules.select { |r| r.is_a?(SingleOccurrenceRule) }.map(&:time)
     end
+    alias :exdates :exception_times
+    alias :exception_dates :exception_times
 
-    def occurs_between?(begin_time, end_time)
-      if defined?(ActiveSupport::TimeWithZone) && @start_date.is_a?(ActiveSupport::TimeWithZone)
-        return active_support_occurs_between?(begin_time, end_time)
+    # Remove an exception time
+    def remove_exception_time(time)
+      found = false
+      @all_exception_rules.delete_if do |rule|
+        found = true if rule.is_a?(SingleOccurrenceRule) && rule.time == time
       end
-      # fall back to our own way of doing things
-      time_format = @start_date.utc? ? :utc : :local
-      self.occurrences_between(Time.send(time_format, begin_time.year, begin_time.month, begin_time.day, 0, 0, 0), Time.send(time_format, end_time.year, end_time.month, end_time.day, 23, 59, 59)).any?
+      time if found
     end
+    alias :remove_exception_date :remove_exception_time
+    alias :remove_exdate :remove_exception_time
 
-    # Return all possible occurrences
-    # In order to make this call, all rules in the schedule must have
-    # either an until date or an occurrence count
-    def all_occurrences
-      find_occurrences { |head| head.all_occurrences }
+    # Get all of the occurrences from the start_time up until a
+    # given Time
+    def occurrences(closing_time)
+      find_occurrences(start_time, closing_time)
     end
 
-    # 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) }
+    # All of the occurrences
+    def all_occurrences
+      unless end_time || recurrence_rules.all?(&:terminating?)
+        raise ArgumentError.new('Rule must specify either an until date or a count to use #all_occurrences')
+      end
+      find_occurrences(start_time)
     end
 
-    # Find remaining occurrences
-    def remaining_occurrences(from = Time.now)
-      raise ArgumentError.new('Schedule must have an end_time to use remaining_occurrences') unless @end_time
-      occurrences_between(from, @end_time)
+    # Iterate forever
+    def each_occurrence(&block)
+      find_occurrences(start_time, &block)
+      self
     end
 
-    # Find next scheduled occurrence
-    def next_occurrence(from = Time.now)
-      next_occurrences(1, from).first
+    # The next n occurrences after now
+    def next_occurrences(num, from = Time.now)
+      find_occurrences(from + 1, nil, num)
     end
 
-    def next_occurrences(n, from = Time.now)
-      nexts = find_occurrences do |head, exclude_dates|
-        head.next_occurrences(n, from, exclude_dates)
-      end
-      #Grabs the first n occurrences after the from date, remembering that there is still a
-      #possibility that recurrence dates before the from time could be in the array
-      nexts.select{|occurrence| occurrence > from}.first(n)
+    # The next occurrence after now (overridable)
+    def next_occurrence(from = Time.now)
+      find_occurrences(from + 1, nil, 1).first
     end
 
-    # Retrieve the first (n) occurrences of the schedule.  May return less than
-    # n results, if the rules end before n results are reached.
-    def first(n = nil)
-      dates = find_occurrences { |head| head.first(n || 1) }
-      n.nil? ? dates.first : dates.slice(0, n)
+    # The remaining occurrences (same requirements as all_occurrences)
+    def remaining_occurrences(from = Time.now)
+      find_occurrences(from)
     end
 
-    # 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, @end_time)
+    # Occurrences between two times
+    def occurrences_between(begin_time, closing_time)
+      find_occurrences(begin_time, closing_time)
     end
 
-    # Remove a recurrence rule, returns the removed rules, or nil
-    def remove_recurrence_rule(rule)
-      raise ArgumentError.new('Argument must be a valid rule') unless rule.class < Rule
-      deletions = []
-      @rrule_occurrence_heads.delete_if { |h| deletions << h.rule if h.rule == rule }
-      deletions
+    # Return a boolean indicating if an occurrence falls between
+    # two times
+    def occurs_between?(begin_time, closing_time)
+      !find_occurrences(begin_time, closing_time, 1).empty?
     end
 
-    def rrules
-      @rrule_occurrence_heads.map { |h| h.rule }
+    # Return a boolean indicating if an occurrence falls on a certain date
+    def occurs_on?(date)
+      begin_time = TimeUtil.beginning_of_date(date)
+      closing_time = TimeUtil.end_of_date(date)
+      occurs_between?(begin_time, closing_time)
     end
 
-    # 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, @end_time)
+    # Determine if the schedule is occurring at a given time
+    def occurring_at?(time)
+      if duration
+        return false if exception_time?(time)
+        occurs_between?(time - duration + 1, time)
+      else
+        occurs_at?(time)
+      end
     end
 
-    # Remove an exception rule, returns the removed rule, or nil
-    def remove_exception_rule(rule)
-      raise ArgumentError.new('Argument must be a valid rule') unless rule.class < Rule
-      deletions = []
-      @exrule_occurrence_heads.delete_if { |h| deletions << h.rule if h.rule == rule }
-      deletions
+    # Determine if the schedule occurs at a specific time
+    def occurs_at?(time)
+      occurs_between?(time, time)
     end
 
-    def exrules
-      @exrule_occurrence_heads.map { |h| h.rule }
+    # Get the first n occurrences, or the first occurrence if n is skipped
+    def first(n = nil)
+      occurrences = find_occurrences start_time, nil, n || 1
+      n.nil? ? occurrences.first : occurrences
     end
 
-    # Add an individual date to this schedule
-    def add_recurrence_date(date)
-      @rdates << date unless date.nil?
+    # String serialization
+    def to_s
+      pieces = []
+      ed = exdates; rd = rdates - ed
+      pieces.concat rd.sort.map { |t| t.strftime(TO_S_TIME_FORMAT) }
+      pieces.concat rrules.map { |t| t.to_s }
+      pieces.concat exrules.map { |t| "not #{t.to_s}" }
+      pieces.concat ed.sort.map { |t| "not on #{t.strftime(TO_S_TIME_FORMAT)}" }
+      pieces << "until #{end_time.strftime(TIME_FORMAT)}" if end_time
+      pieces.join(' / ')
     end
 
-    # Remove an individual date from this schedule's recurrence dates
-    # return date that was removed, nil otherwise
-    def remove_recurrence_date(date)
-      @rdates.delete(date)
+    # Serialize this schedule to_ical
+    def to_ical(force_utc = false)
+      pieces = []
+      pieces << "DTSTART#{IcalBuilder.ical_format(start_time, force_utc)}"
+      pieces << "DURATION:#{IcalBuilder.ical_duration(duration)}" if duration
+      pieces.concat recurrence_rules.map { |r| "RRULE:#{r.to_ical}" }
+      pieces.concat exception_rules.map { |r| "EXRULE:#{r.to_ical}" }
+      pieces.concat recurrence_times.map { |t| "RDATE#{IcalBuilder.ical_format(t, force_utc)}" }
+      pieces.concat exception_times.map { |t| "EXDATE#{IcalBuilder.ical_format(t, force_utc)}" }
+      pieces << "DTEND#{IcalBuilder.ical_format(end_time, force_utc)}" if end_time
+      pieces.join("\n")
     end
 
-    # Add an individual date exception to this schedule
-    def add_exception_date(date)
-      @exdates << date unless date.nil?
+    # Convert the schedule to yaml
+    def to_yaml(*args)
+      defined?(Psych) ? Psych::dump(to_hash) : YAML::dump(to_hash, *args)
     end
 
-    # Remove an individual date exception from this schedule's exception dates
-    # return date that was removed, nil otherwise
-    def remove_exception_date(date)
-      @exdates.delete(date)
+    # Load the schedule from yaml
+    def self.from_yaml(yaml, options = {})
+      from_hash defined?(Psych) ? Psych::load(yaml) : YAML::load(yaml), options
     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
-      include_dates, exclude_dates = SortedSet.new(@rdates), Set.new(@exdates)
-      @rrule_occurrence_heads.each do |rrule_occurrence_head|
-        include_dates.merge(rrule_occurrence_head.between(begin_time, end_time))
+    # Convert the schedule to a hash
+    def to_hash
+      data = {}
+      data[:start_date] = TimeUtil.serialize_time(start_time)
+      data[:end_time] = end_time if end_time
+      data[:duration] = duration if duration
+      data[:rrules] = recurrence_rules.map(&:to_hash)
+      data[:exrules] = exception_rules.map(&:to_hash)
+      data[:rdates] = recurrence_times.map do |rt|
+        TimeUtil.serialize_time(rt)
       end
-      @exrule_occurrence_heads.each do |exrule_occurrence_head|
-        exclude_dates.merge(exrule_occurrence_head.between(begin_time, end_time))
+      data[:exdates] = exception_times.map do |et|
+        TimeUtil.serialize_time(et)
       end
-      # reject all of the ones outside of the range
-      include_dates.reject! { |date| exclude_dates.include?(date) || date < begin_time || date > end_time }
-      include_dates.to_a
+      data
+    end
+
+    # Load the schedule from a hash
+    def self.from_hash(data, options = {})
+      data[:start_date] = options[:start_date_override] if options[:start_date_override]
+      # And then deserialize
+      schedule = IceCube::Schedule.new TimeUtil.deserialize_time(data[:start_date])
+      schedule.duration = data[:duration] if data[:duration]
+      schedule.end_time = TimeUtil.deserialize_time(data[:end_time]) if data[:end_time]
+      data[:rrules] && data[:rrules].each { |h| schedule.rrule(IceCube::Rule.from_hash(h)) }  
+      data[:exrules] && data[:exrules].each { |h| schedule.exrule(IceCube::Rule.from_hash(h)) }
+      data[:rdates] && data[:rdates].each do |t|
+        schedule.add_recurrence_time TimeUtil.deserialize_time(t)
+      end
+      data[:exdates] && data[:exdates].each do |t|
+        schedule.add_exception_time TimeUtil.deserialize_time(t)
+      end
+      schedule
     end
 
-    alias :rdate :add_recurrence_date
-    alias :rrule :add_recurrence_rule
-    alias :exdate :add_exception_date
-    alias :exrule :add_exception_rule
-    alias :recurrence_dates :rdates
-    alias :exception_dates :exdates
-    alias :remove_rdate :remove_recurrence_date
-    alias :remove_exdate :remove_exception_date
-    alias :remove_rrule :remove_recurrence_rule
-    alias :remove_exrule :remove_exception_rule
-
     private
 
-    # We know that start_date is a time with zone - so check referencing
-    # The date in that time zone
-    def active_support_occurs_on?(date)
-      time = Time.zone.parse(date.to_s) # date.to_time.in_time_zone(@start_date.time_zone)
-      occurrences_between(time.beginning_of_day, time.end_of_day).any?
+    # Reset all rules for another run
+    def reset
+      @all_recurrence_rules.each(&:reset)
+      @all_exception_rules.each(&:reset)
     end
 
-    def active_support_occurs_between?(start_time, end_time)
-      time_start = Time.zone.parse(start_time.to_s) # date.to_time.in_time_zone(@start_date.time_zone)
-      time_end = Time.zone.parse(end_time.to_s) # date.to_time.in_time_zone(@end_date.time_zone)
-
-      occurrences_between(time_start.beginning_of_day, time_end.end_of_day).any?
-    end
-
-    # tell if, from a list of rule_occurrence heads, a certain time is occurring
-    def any_occurring_at?(what, time)
-      return false if @start_date && time < @start_date
-      what.any? do |occurrence_head|
-        # time is less than now and duration is less than that distance
-        possibilities = occurrence_head.between(@start_date, time)
-        possibilities.any? do |possibility|
-          possibility + (@duration || 0) >= time
+    # Find all of the occurrences for the schedule between opening_time
+    # and closing_time
+    def find_occurrences(opening_time, closing_time = nil, limit = nil, &block)
+      reset
+      answers = []
+      # ensure the bounds are proper
+      if end_time
+        closing_time = end_time unless closing_time && closing_time < @end_time
+      end
+      opening_time = start_time if opening_time < start_time
+      # And off we go
+      time = opening_time
+      loop do
+        res = next_time(time, closing_time)
+        break unless res
+        break if closing_time && res > closing_time
+        block_given? ? block.call(res) : (answers << res)
+        break if limit && answers.length == limit
+        time = res + 1
+      end
+      # and return our answers
+      answers
+    end
+
+    # Get the next time after (or including) a specific time
+    def next_time(time, closing_time)
+      min_time = nil
+      loop do
+        @all_recurrence_rules.each do |rule|
+          begin
+            if res = rule.next_time(time, self, closing_time)
+              if min_time.nil? || res < min_time
+                min_time = res
+              end
+            end
+          # Certain exceptions mean this rule no longer wants to play
+          rescue CountExceeded, UntilExceeded
+            next
+          end
+        end
+        # If there is no match, return nil
+        return nil unless min_time
+        # Now make sure that its not an exception_time, and if it is
+        # then keep looking
+        if exception_time?(min_time)
+          time = min_time + 1
+          min_time = nil
+          next
         end
+        # Break, we're done
+        break
       end
+      min_time
     end
 
-    # Find all occurrences (following rules and exceptions) from the schedule's start date to end_date.
-    # Use custom methods to say when to end
-    def find_occurrences
-      exclude_dates, include_dates = Set.new(@exdates), SortedSet.new(@rdates)
-      # walk through each exrule, adding it to the exclude dates
-      @exrule_occurrence_heads.each do |exrule_occurrence_head|
-        exclude_dates.merge(yield(exrule_occurrence_head))
-      end
-       # walk through each rule, adding it to dates
-      @rrule_occurrence_heads.each do |rrule_occurrence_head|
-        include_dates.merge(yield(rrule_occurrence_head, exclude_dates))
+    # Return a boolean indicating whether or not a specific time
+    # is excluded from the schedule
+    def exception_time?(time)
+      @all_exception_rules.any? do |rule|
+        rule.on?(time, self)
       end
-      #return a unique list of dates
-      include_dates.reject! { |date| exclude_dates.include?(date) }
-      include_dates.to_a
     end
 
   end