rrule 0.0.0 → 0.1.0

data/lib/rrule/filters/by_month.rb

@@ -0,0 +1,16 @@
+module RRule
+  class ByMonth
+    def initialize(by_months, context)
+      @by_months = by_months
+      @context = context
+    end
+
+    def reject?(i)
+      !by_months.include?(context.month_by_day_of_year[i])
+    end
+
+    private
+
+    attr_reader :by_months, :context
+  end
+end

data/lib/rrule/filters/by_month_day.rb

@@ -0,0 +1,16 @@
+module RRule
+  class ByMonthDay
+    def initialize(by_month_days, context)
+      @context = context
+      @positive_month_days, @negative_month_days = by_month_days.partition { |mday| mday > 0 }
+    end
+
+    def reject?(i)
+      !positive_month_days.include?(context.month_day_by_day_of_year[i]) && !negative_month_days.include?(context.negative_month_day_by_day_of_year[i])
+    end
+
+    private
+
+    attr_reader :context, :positive_month_days, :negative_month_days
+  end
+end

data/lib/rrule/filters/by_week_day.rb

@@ -0,0 +1,24 @@
+module RRule
+  class ByWeekDay
+    def initialize(weekdays, context)
+      @by_week_days = weekdays.map(&:index)
+      @context = context
+    end
+
+    def reject?(i)
+      masked?(i) || !matches_by_week_days?(i)
+    end
+
+    private
+
+    def masked?(i)
+      context.day_of_year_mask && !context.day_of_year_mask[i]
+    end
+
+    def matches_by_week_days?(i)
+      by_week_days.empty? || by_week_days.include?(context.weekday_by_day_of_year[i])
+    end
+
+    attr_reader :by_week_days, :context
+  end
+end

data/lib/rrule/filters/by_week_number.rb

@@ -0,0 +1,16 @@
+module RRule
+  class ByWeekNumber
+    def initialize(by_week_numbers, context)
+      @by_week_numbers = by_week_numbers
+      @context = context
+    end
+
+    def reject?(i)
+      !by_week_numbers.include?(context.week_number_by_day_of_year[i]) && !by_week_numbers.include?(context.negative_week_number_by_day_of_year[i])
+    end
+
+    private
+
+    attr_reader :by_week_numbers, :context
+  end
+end

data/lib/rrule/filters/by_year_day.rb

@@ -0,0 +1,18 @@
+module RRule
+  class ByYearDay
+    def initialize(by_year_days, context)
+      @by_year_days = by_year_days
+      @context = context
+    end
+
+    def reject?(i)
+      !by_year_days.empty? && 
+        ((i < context.year_length_in_days && !by_year_days.include?(i + 1) && !by_year_days.include?(i - context.year_length_in_days)) ||
+          (i >= context.year_length_in_days && !by_year_days.include?(i + 1 - context.year_length_in_days) && !by_year_days.include?(i - context.year_length_in_days - context.next_year_length_in_days)))
+    end
+
+    private
+
+    attr_reader :by_year_days, :context
+  end
+end

data/lib/rrule/frequencies/daily.rb

@@ -0,0 +1,13 @@
+module RRule
+  class Daily < Frequency
+    def possible_days
+      [current_date.yday - 1] # convert to 0-indexed
+    end
+
+    private
+
+    def advance_by
+      { days: context.options[:interval] }
+    end
+  end
+end

data/lib/rrule/frequencies/frequency.rb

@@ -0,0 +1,34 @@
+module RRule
+  class Frequency
+    attr_reader :current_date
+
+    def initialize(context)
+      @context = context
+      @current_date = context.dtstart
+    end
+
+    def advance
+      @current_date = current_date.advance(advance_by).tap do |new_date|
+        unless same_month(current_date, new_date)
+          context.rebuild(new_date.year, new_date.month)
+        end
+      end
+    end
+
+    def possible_days
+      fail NotImplementedError
+    end
+
+    private
+
+    attr_reader :context
+
+    def same_month(first_date, second_date)
+      first_date.month == second_date.month && first_date.year == second_date.year
+    end
+
+    def advance_by
+      fail NotImplementedError
+    end
+  end
+end

data/lib/rrule/frequencies/monthly.rb

@@ -0,0 +1,14 @@
+module RRule
+  class Monthly < Frequency
+    def possible_days
+      # yday is 1-indexed, need results 0-indexed
+      (current_date.beginning_of_month.yday - 1..current_date.end_of_month.yday - 1).to_a
+    end
+
+    private
+
+    def advance_by
+      { months: context.options[:interval] }
+    end
+  end
+end

data/lib/rrule/frequencies/weekly.rb

@@ -0,0 +1,29 @@
+module RRule
+  class Weekly < Frequency
+    def possible_days
+      i = current_date.yday - 1
+      possible_days = []
+      7.times do
+        possible_days.push(i)
+        i += 1
+        break if context.weekday_by_day_of_year[i] == context.options[:wkst]
+      end
+      possible_days
+    end
+
+    private
+
+    def advance_by
+      { days: days_to_advance(current_date) }
+    end
+
+    def days_to_advance(date)
+      if context.options[:wkst] > date.wday
+        -(date.wday + 1 + (6 - context.options[:wkst])) + context.options[:interval] * 7
+      else
+        -(date.wday - context.options[:wkst]) + context.options[:interval] * 7
+      end
+    end
+  end
+end
+

data/lib/rrule/frequencies/yearly.rb

@@ -0,0 +1,14 @@
+module RRule
+  class Yearly < Frequency
+    def possible_days
+      (0...context.year_length_in_days).to_a
+    end
+
+    private
+
+    def advance_by
+      { years: context.options[:interval] }
+    end
+  end
+end
+

data/lib/rrule/generators/all_occurrences.rb

@@ -0,0 +1,26 @@
+module RRule
+  class AllOccurrences
+    attr_reader :context
+
+    def initialize(context)
+      @context = context
+    end
+
+    def combine_dates_and_times(dayset, timeset)
+      dayset.compact.map { |i| context.first_day_of_year + i }.flat_map do |date|
+        timeset.map do |time|
+          Time.use_zone(context.tz) do
+            Time.zone.local(
+                date.year,
+                date.month,
+                date.day,
+                time[:hour],
+                time[:minute],
+                time[:second]
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rrule/generators/by_set_position.rb

@@ -0,0 +1,35 @@
+module RRule
+  class BySetPosition
+    attr_reader :by_set_positions, :context
+
+    def initialize(by_set_positions, context)
+      @by_set_positions = by_set_positions
+      @context = context
+    end
+
+    def combine_dates_and_times(dayset, timeset)
+      valid_dates(dayset).flat_map do |date|
+        timeset.map do |time|
+          Time.use_zone(context.tz) do
+            Time.zone.local(
+                date.year,
+                date.month,
+                date.day,
+                time[:hour],
+                time[:minute],
+                time[:second]
+            )
+          end
+        end
+      end
+    end
+
+    def valid_dates(dayset)
+      dayset.compact!
+      by_set_positions.map do |position|
+        position -= 1 if position > 0
+        dayset[position]
+      end.compact.map { |i| context.first_day_of_year + i }
+    end
+  end
+end

data/lib/rrule/rule.rb

@@ -0,0 +1,181 @@
+module RRule
+  class Rule
+    attr_reader :rrule, :dtstart, :tz, :exdate
+
+    def initialize(rrule, dtstart: Time.now, tzid: 'UTC', exdate: [])
+      @rrule = rrule
+      # This removes all sub-second and floors it to the second level.
+      # Sub-second level calculations breaks a lot of assumptions in this
+      # library and rounding it may also cause unexpected inequalities.
+      @dtstart = Time.at(dtstart.to_i).in_time_zone(tzid)
+      @tz = tzid
+      @exdate = exdate
+    end
+
+    def all
+      reject_exdates(all_until(nil))
+    end
+
+    def between(start_date, end_date)
+      # This removes all sub-second and floors it to the second level.
+      # Sub-second level calculations breaks a lot of assumptions in this
+      # library and rounding it may also cause unexpected inequalities.
+      floored_start_date = Time.at(start_date.to_i)
+      floored_end_date = Time.at(end_date.to_i)
+      reject_exdates(all_until(floored_end_date).reject { |instance| instance < floored_start_date })
+    end
+
+    private
+
+    def reject_exdates(results)
+      results.reject { |date| exdate.include?(date) }
+    end
+
+    def all_until(end_date)
+      result = []
+
+      context = Context.new(options, dtstart, tz)
+      context.rebuild(dtstart.year, dtstart.month)
+
+      timeset = options[:timeset]
+      total = 0
+      count = options[:count]
+
+      filters = []
+
+      frequency = case options[:freq]
+      when 'DAILY'
+        Daily.new(context)
+      when 'WEEKLY'
+        Weekly.new(context)
+      when 'MONTHLY'
+        Monthly.new(context)
+      when 'YEARLY'
+        Yearly.new(context)
+      end
+
+      if options[:bymonth]
+        filters.push(ByMonth.new(options[:bymonth], context))
+      end
+
+      if options[:byweekno]
+        filters.push(ByWeekNumber.new(options[:byweekno], context))
+      end
+
+      if options[:byweekday]
+        filters.push(ByWeekDay.new(options[:byweekday], context))
+      end
+
+      if options[:byyearday]
+        filters.push(ByYearDay.new(options[:byyearday], context))
+      end
+
+      if options[:bymonthday]
+        filters.push(ByMonthDay.new(options[:bymonthday], context))
+      end
+
+      if options[:bysetpos]
+        generator = BySetPosition.new(options[:bysetpos], context)
+      else
+        generator = AllOccurrences.new(context)
+      end
+
+      loop do
+        return result if frequency.current_date.year > MAX_YEAR
+
+        possible_days_of_year = frequency.possible_days
+
+        possible_days_of_year.each_with_index do |day_index, i|
+          possible_days_of_year[i] = nil if filters.any? { |filter| filter.reject?(day_index) }
+        end
+
+        results_with_time = generator.combine_dates_and_times(possible_days_of_year, timeset)
+        results_with_time.sort.each do |this_result|
+          if end_date
+            if this_result > end_date
+              return result
+            end
+          end
+
+          if options[:until]
+            if this_result > options[:until]
+              return result
+            end
+            result.push(this_result)
+          elsif this_result >= dtstart
+            total += 1
+            if options[:count]
+              count -= 1
+              result.push(this_result)
+              return result if count == 0
+            else
+              result.push(this_result)
+            end
+          end
+        end
+
+        frequency.advance
+      end
+    end
+
+    def options
+      @options ||= parse_options
+    end
+
+    def parse_options
+      options = { interval: 1, wkst: 1 }
+
+      params = @rrule.split(';')
+      params.each do |param|
+        option, value = param.split('=')
+
+        case option
+        when 'FREQ'
+          options[:freq] = value
+        when 'COUNT'
+          options[:count] = value.to_i
+        when 'UNTIL'
+          options[:until] = Time.parse(value)
+        when 'INTERVAL'
+          options[:interval] = value.to_i
+        when 'BYDAY'
+          options[:byweekday] = value.split(',').map { |day| Weekday.parse(day) }
+        when 'BYSETPOS'
+          options[:bysetpos] = value.split(',').map(&:to_i)
+        when 'WKST'
+          options[:wkst] = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'].index(value)
+        when 'BYMONTH'
+          options[:bymonth] = value.split(',').compact.map(&:to_i)
+        when 'BYMONTHDAY'
+          options[:bymonthday] = value.split(',').map(&:to_i)
+        when 'BYWEEKNO'
+          options[:byweekno] = value.split(',').map(&:to_i)
+        when 'BYYEARDAY'
+          options[:byyearday] = value.split(',').map(&:to_i)
+        end
+      end
+
+      if !(options[:byweekno] || options[:byyearday] || options[:bymonthday] || options[:byweekday])
+        case options[:freq]
+        when 'YEARLY'
+          unless options[:bymonth]
+            options[:bymonth] = [dtstart.month]
+          end
+          options[:bymonthday] = [dtstart.day]
+        when 'MONTHLY'
+          options[:bymonthday] = [dtstart.day]
+        when 'WEEKLY'
+          options[:byweekday] = [Weekday.new(dtstart.wday)]
+        end
+      end
+
+      unless options[:byweekday].nil?
+        options[:byweekday], options[:bynweekday] = options[:byweekday].partition { |wday| wday.ordinal.nil? }
+      end
+
+      options[:timeset] = [{ hour: dtstart.hour, minute: dtstart.min, second: dtstart.sec }]
+
+      options
+    end
+  end
+end