rrule 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f4e67330d4bebaf8408d3125386565754c269ef
-  data.tar.gz: e1bfbeadff4cd2cf622360d38357d954bd9f5984
+  metadata.gz: c26a3dfb1d12c01d066b7c664e6ea0da8fb5ead0
+  data.tar.gz: 1975eaa5dacd0363518d155f994a9966b837f682
 SHA512:
-  metadata.gz: 55b57448971a919141f491bc141d017eb2bd98421ed0f7cf6bf79d51859fb5cf5e6647d1c28b9738e4465258108fa436be006466b25428823a49b6220808216f
-  data.tar.gz: 72792b23c6a0e483a37d16501d1a79a2efc2303e1e0113bf03dc83bcd6775933f0a946bbf7c3f52be211d17a5e87560977874f57b90223af567a2f2a302a8bc0
+  metadata.gz: a9f362bd929a06f539e69df842cebb0052f3f841b624d36e01edb9dca64e4c5f472da54b3d671df6089a991b6b4bd1b0bbe39502409274d5636ab68a81e6ed22
+  data.tar.gz: 70400ae4f025bcee80979056cfec688a16e5be6fd948a07d905fa9f5e48ec7d8f62df31d84f8d0181e001aa6ee27e89fb3c39250b6df85195eb91739876cc14a

data/README.md

@@ -64,7 +64,7 @@ rrule.all
 
 ## License
 
-Copyright 2015 Square Inc.
+Copyright 2018 Square Inc.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/lib/rrule.rb

@@ -8,6 +8,7 @@ module RRule
   autoload :Frequency, 'rrule/frequencies/frequency'
   autoload :Daily, 'rrule/frequencies/daily'
   autoload :Weekly, 'rrule/frequencies/weekly'
+  autoload :SimpleWeekly, 'rrule/frequencies/simple_weekly'
   autoload :Monthly, 'rrule/frequencies/monthly'
   autoload :Yearly, 'rrule/frequencies/yearly'
 

data/lib/rrule/frequencies/frequency.rb

@@ -1,10 +1,13 @@
 module RRule
   class Frequency
-    attr_reader :current_date
+    attr_reader :current_date, :filters, :generator, :timeset
 
-    def initialize(context)
+    def initialize(context, filters, generator, timeset)
       @context = context
       @current_date = context.dtstart
+      @filters = filters
+      @generator = generator
+      @timeset = timeset
     end
 
     def advance
@@ -15,10 +18,41 @@ module RRule
       end
     end
 
+    def next_occurrences
+      possible_days_of_year = possible_days
+
+      if filters.present?
+        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
+      end
+
+      generator.combine_dates_and_times(possible_days_of_year, timeset).tap do
+        advance
+      end
+    end
+
     def possible_days
       fail NotImplementedError
     end
 
+    def self.for_options(options)
+      case options[:freq]
+      when 'DAILY'
+        Daily
+      when 'WEEKLY'
+        if options[:simple_weekly] && !options[:bymonth]
+          SimpleWeekly # simplified and faster version if we don't need to deal with filtering
+        else
+          Weekly
+        end
+      when 'MONTHLY'
+        Monthly
+      when 'YEARLY'
+        Yearly
+      end
+    end
+
     private
 
     attr_reader :context

data/lib/rrule/frequencies/simple_weekly.rb

@@ -0,0 +1,9 @@
+module RRule
+  class SimpleWeekly < Frequency
+    def next_occurrences
+      this_occurrence = current_date
+      @current_date += context.options[:interval].weeks
+      [this_occurrence]
+    end
+  end
+end

data/lib/rrule/rule.rb

@@ -31,18 +31,6 @@ module RRule
       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
@@ -69,24 +57,17 @@ module RRule
         generator = AllOccurrences.new(context)
       end
 
+      frequency = Frequency.for_options(options).new(context, filters, generator, timeset)
+
       loop do
         return 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.each do |this_result|
+        frequency.next_occurrences.each do |this_result|
           next if this_result < dtstart
           return if options[:until] && this_result > options[:until]
           return if count && (count -= 1) < 0
           yield this_result unless exdate.include?(this_result)
         end
-
-        frequency.advance
       end
     end
 
@@ -99,7 +80,6 @@ module RRule
     attr_reader :options
 
     def floor_to_seconds(date)
-      return 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.
@@ -165,6 +145,7 @@ module RRule
         when 'MONTHLY'
           options[:bymonthday] = [dtstart.day]
         when 'WEEKLY'
+          options[:simple_weekly] = true
           options[:byweekday] = [Weekday.new(dtstart.wday)]
         end
       end

data/rrule.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name = 'rrule'
-  s.version = '0.2.1'
-  s.date = '2016-06-06'
+  s.version = '0.3.0'
+  s.date = '2018-04-23'
   s.summary = 'RRule expansion'
   s.description = 'A gem for expanding dates according to the RRule specification'
   s.authors = ['Ryan Mitchell']

data/scripts/benchmark.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '../lib/'))
+require 'rrule'
+include Benchmark
+
+rules_to_benchmark = ['FREQ=WEEKLY', 'FREQ=WEEKLY;BYDAY=WE']
+rrule_version = '0.3.0'
+
+puts "Benchmarking rules in version #{rrule_version}: 1000 expansions over one month\n"
+Benchmark.benchmark(CAPTION, rules_to_benchmark.map(&:size).max, FORMAT) do |bm|
+  rules_to_benchmark.each do |rule|
+    rrule = RRule.parse(rule, dtstart: Time.parse('Wed Jan 30 09:00:00 PST 2013'), tzid: 'America/Chicago')
+    bm.report(rule) do
+      1000.times { rrule.between(Time.parse('Sun Jul 31 22:00:00 PDT 2016'), Time.parse('Wed Aug 31 21:59:59 PDT 2016')) }
+    end
+  end
+end
+puts "\n"

data/scripts/history.txt

@@ -0,0 +1,5 @@
+Benchmarking rules in version 0.3.0
+                           user     system      total        real
+FREQ=WEEKLY            7.190000   0.040000   7.230000 (  7.242336)
+FREQ=WEEKLY;BYDAY=WE  12.770000   0.070000  12.840000 ( 12.857210)
+

data/spec/frequencies/daily_spec.rb

@@ -1,55 +1,62 @@
 require 'spec_helper'
 
 describe RRule::Daily do
+  let(:interval) { 1 }
   let(:context) do
     RRule::Context.new(
-        { interval: 1 },
+        { interval: interval },
         date,
         'America/Los_Angeles'
     )
   end
+  let(:filters) { [] }
+  let(:generator) { RRule::AllOccurrences.new(context) }
+  let(:timeset) { [{ hour: date.hour, minute: date.min, second: date.sec }] }
 
-  describe '#possible_days' do
-    subject { described_class.new(context).possible_days }
+  before { context.rebuild(date.year, date.month) }
 
-    context 'on the first day of the year' do
-      let(:date) { Date.new(1997, 1, 1)}
+  describe '#next_occurrences' do
+    subject(:frequency) { described_class.new(context, filters, generator, timeset) }
 
-      it { is_expected.to eql [0] }
-    end
-
-    context 'on a day in the first month' do
-      let(:date) { Date.new(1997, 1, 25)}
+    context 'with an interval of one' do
+      let(:date) { Time.zone.local(1997, 1, 1) }
 
-      it { is_expected.to eql [24] }
+      it 'returns sequential days' do
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 1, 1)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 1, 2)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 1, 3)]
+      end
     end
 
-    context 'on a day in the next month' do
-      let(:date) { Date.new(1997, 2, 25)}
-
-      it { is_expected.to eql [55] }
-    end
-  end
-
-  describe '#advance' do
-    subject { described_class.new(context).advance }
-
-    context 'on the first day of the year' do
-      let(:date) { Date.new(1997, 1, 1)}
+    context 'with an interval of two' do
+      let(:interval) { 2 }
+      let(:date) { Time.zone.local(1997, 1, 1) }
 
-      it { is_expected.to eql date + 1.day }
+      it 'returns every other day' do
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 1, 1)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 1, 3)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 1, 5)]
+      end
     end
 
     context 'on the last day of February' do
-      let(:date) { Date.new(1997, 2, 28)}
+      let(:date) { Time.zone.local(1997, 2, 28) }
 
-      it { is_expected.to eql date + 1.day }
+      it 'goes into the next month' do
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 2, 28)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 3, 1)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 3, 2)]
+      end
     end
 
     context 'on the last day of the year' do
-      let(:date) { Date.new(1997, 12, 31)}
+      let(:date) { Time.zone.local(1997, 12, 31) }
 
-      it { is_expected.to eql date + 1.day }
+      it 'goes into the next year' do
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 12, 31)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1998, 1, 1)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1998, 1, 2)]
+      end
     end
   end
 end

data/spec/frequencies/monthly_spec.rb

@@ -1,57 +1,63 @@
 require 'spec_helper'
 
 describe RRule::Monthly do
+  let(:interval) { 1 }
   let(:context) do
     RRule::Context.new(
-        { interval: 1 },
+        { interval: interval },
         date,
         'America/Los_Angeles'
     )
   end
+  let(:filters) { [RRule::ByMonthDay.new([date.day], context)] }
+  let(:generator) { RRule::AllOccurrences.new(context) }
+  let(:timeset) { [{ hour: date.hour, minute: date.min, second: date.sec }] }
 
-  before(:each) { context.rebuild(1997, 1) }
+  before { context.rebuild(date.year, date.month) }
 
-  describe '#possible_days' do
-    subject { described_class.new(context).possible_days }
+  describe '#next_occurrences' do
+    subject(:frequency) { described_class.new(context, filters, generator, timeset) }
 
-    context 'on the first day of the year' do
-      let(:date) { Date.new(1997, 1, 1)}
+    context 'with an interval of one' do
+      let(:date) { Time.zone.local(1997, 1, 1) }
 
-      it { is_expected.to eql (0..30).to_a }
+      it 'returns sequential months' do
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 1, 1)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 2, 1)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 3, 1)]
+      end
     end
 
-    context 'on a day in the first month' do
-      let(:date) { Date.new(1997, 1, 25)}
+    context 'with an interval of two' do
+      let(:interval) { 2 }
+      let(:date) { Time.zone.local(1997, 1, 1) }
 
-      it { is_expected.to eql (0..30).to_a }
-    end
-
-    context 'on a day in the next month' do
-      let(:date) { Date.new(1997, 2, 25)}
-
-      it { is_expected.to eql (31..58).to_a }
-    end
-  end
-
-  describe '#advance' do
-    subject { described_class.new(context).advance }
-
-    context 'on the first day of the year' do
-      let(:date) { Date.new(1997, 1, 1)}
-
-      it { is_expected.to eql date + 1.month }
+      it 'returns every other month' do
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 1, 1)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 3, 1)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 5, 1)]
+      end
     end
 
     context 'on the last day of February' do
-      let(:date) { Date.new(1997, 2, 28)}
+      let(:date) { Time.zone.local(1997, 2, 28) }
 
-      it { is_expected.to eql date + 1.month }
+      it 'returns the next three months' do
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 2, 28)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 3, 28)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 4, 28)]
+      end
     end
 
     context 'on the last day of the year' do
-      let(:date) { Date.new(1997, 12, 31)}
-
-      it { is_expected.to eql date + 1.month }
+      let(:date) { Time.zone.local(1997, 12, 31) }
+
+      it 'returns empty arrays for periods with no matching occurrences' do
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 12, 31)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1998, 1, 31)]
+        expect(frequency.next_occurrences).to eql []
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1998, 3, 31)]
+      end
     end
   end
 end

data/spec/frequencies/simple_weekly_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe RRule::SimpleWeekly do
+  let(:context) { RRule::Context.new({ interval: interval }, date, nil) }
+  let(:frequency) { described_class.new(context, nil, nil, nil) }
+
+  describe '#next_occurrences' do
+    let(:date) { Date.new(1997, 1, 1) }
+
+    context 'with an interval of 1' do
+      let(:interval) { 1 }
+
+      it 'returns occurrences every week' do
+        expect(frequency.next_occurrences).to eql [Date.new(1997, 1, 1)]
+        expect(frequency.next_occurrences).to eql [Date.new(1997, 1, 8)]
+        expect(frequency.next_occurrences).to eql [Date.new(1997, 1, 15)]
+      end
+    end
+
+    context 'with an interval of 2' do
+      let(:interval) { 2 }
+
+      it 'returns occurrences every other week' do
+        expect(frequency.next_occurrences).to eql [Date.new(1997, 1, 1)]
+        expect(frequency.next_occurrences).to eql [Date.new(1997, 1, 15)]
+        expect(frequency.next_occurrences).to eql [Date.new(1997, 1, 29)]
+      end
+    end
+  end
+end

data/spec/frequencies/weekly_spec.rb

@@ -1,57 +1,92 @@
 require 'spec_helper'
 
 describe RRule::Weekly do
+  let(:interval) { 1 }
   let(:context) do
     RRule::Context.new(
-        { interval: 1, wkst: 1 },
+        { interval: interval, wkst: 1 },
         date,
         'America/Los_Angeles'
     )
   end
+  let(:filters) { [RRule::ByWeekDay.new([RRule::Weekday.new(date.wday)], context)] }
+  let(:generator) { RRule::AllOccurrences.new(context) }
+  let(:timeset) { [{ hour: date.hour, minute: date.min, second: date.sec }] }
 
-  before(:each) { context.rebuild(1997, 1) }
+  before { context.rebuild(date.year, date.month) }
 
-  describe '#possible_days' do
-    subject { described_class.new(context).possible_days }
+  describe '#next_occurrences' do
+    subject(:frequency) { described_class.new(context, filters, generator, timeset) }
 
-    context 'on the first day of the year with five days left in the week' do
-      let(:date) { Date.new(1997, 1, 1)}
+    context 'with an interval of one' do
+      let(:date) { Time.zone.local(1997, 1, 1) }
 
-      it { is_expected.to eql (0..4).to_a }
+      it 'returns sequential weeks' do
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 1, 1)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 1, 8)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 1, 15)]
+      end
     end
 
-    context 'on a day in the first month with two days left in the week' do
-      let(:date) { Date.new(1997, 1, 25)}
+    context 'with an interval of two' do
+      let(:interval) { 2 }
+      let(:date) { Time.zone.local(1997, 1, 1) }
 
-      it { is_expected.to eql (24..25).to_a }
+      it 'returns every other week' do
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 1, 1)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 1, 15)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 1, 29)]
+      end
     end
 
-    context 'on a day in the next month with six days left in the week' do
-      let(:date) { Date.new(1997, 2, 25)}
+    context 'on the first day of the year with five days left in the week' do
+      let(:date) { Time.zone.local(1997, 1, 1) }
 
-      it { is_expected.to eql (55..60).to_a }
+      it 'returns the next three weeks' do
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 1, 1)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 1, 8)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 1, 15)]
+      end
     end
-  end
 
-  describe '#advance' do
-    subject { described_class.new(context).advance }
+    context 'on a day in the first month with two days left in the week' do
+      let(:date) { Time.zone.local(1997, 1, 25) }
+
+      it 'returns the next three weeks' do
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 1, 25)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 2, 1)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 2, 8)]
+      end
+    end
 
-    context 'on the first day of the year' do
-      let(:date) { Date.new(1997, 1, 1)}
+    context 'on a day in the next month with six days left in the week' do
+      let(:date) { Time.zone.local(1997, 2, 25) }
 
-      it { is_expected.to eql date.next_week }
+      it 'returns the next three weeks' do
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 2, 25)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 3, 4)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 3, 11)]
+      end
     end
 
     context 'on the last day of February' do
-      let(:date) { Date.new(1997, 2, 28)}
+      let(:date) { Time.zone.local(1997, 2, 28) }
 
-      it { is_expected.to eql date.next_week }
+      it 'returns the next three weeks' do
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 2, 28)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 3, 7)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 3, 14)]
+      end
     end
 
     context 'on the last day of the year' do
-      let(:date) { Date.new(1997, 12, 31)}
+      let(:date) { Time.zone.local(1997, 12, 31) }
 
-      it { is_expected.to eql date.next_week }
+      it 'returns the next three weeks' do
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 12, 31)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1998, 1, 7)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1998, 1, 14)]
+      end
     end
   end
 end

data/spec/frequencies/yearly_spec.rb

@@ -1,52 +1,54 @@
 require 'spec_helper'
 
 describe RRule::Yearly do
-  let(:date) { Date.new(1997, 1, 1) }
+  let(:interval) { 1 }
   let(:context) do
     RRule::Context.new(
-        { interval: 1, wkst: 1 },
+        { interval: interval, wkst: 1 },
         date,
         'America/Los_Angeles'
     )
   end
+  let(:filters) { [RRule::ByMonth.new([date.month], context), RRule::ByMonthDay.new([date.day], context)] }
+  let(:generator) { RRule::AllOccurrences.new(context) }
+  let(:timeset) { [{ hour: date.hour, minute: date.min, second: date.sec }] }
 
-  before(:each) { context.rebuild(1997, 1) }
+  before(:each) { context.rebuild(date.year, date.month) }
 
-  describe '#possible_days' do
-    subject { described_class.new(context).possible_days }
-
-    context 'in a non leap year' do
-      before(:each) { context.rebuild(1997, 1) }
-
-      it { is_expected.to eql (0..364).to_a }
-    end
-
-    context 'in a leap year' do
-      before(:each) { context.rebuild(2000, 1) }
-
-      it { is_expected.to eql (0..365).to_a }
-    end
-  end
-
-  describe '#advance' do
-    subject { described_class.new(context).advance }
+  describe '#next_occurrences' do
+    subject(:frequency) { described_class.new(context, filters, generator, timeset) }
 
     context 'on the first day of the year' do
-      let(:date) { Date.new(1997, 1, 1)}
+      let(:date) { Time.zone.local(1997, 1, 1) }
 
-      it { is_expected.to eql date + 1.year }
+      it 'returns the next three years' do
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 1, 1)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1998, 1, 1)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1999, 1, 1)]
+      end
     end
 
-    context 'on the last day of February' do
-      let(:date) { Date.new(1997, 2, 28)}
+    context 'on the last day of February in a leap year' do
+      let(:date) { Time.zone.local(2000, 2, 29) }
 
-      it { is_expected.to eql date + 1.year }
+      it 'skips non-leap years' do
+        expect(frequency.next_occurrences).to eql [Time.zone.local(2000, 2, 29)]
+        expect(frequency.next_occurrences).to eql []
+        expect(frequency.next_occurrences).to eql []
+        expect(frequency.next_occurrences).to eql []
+        expect(frequency.next_occurrences).to eql [Time.zone.local(2004, 2, 29)]
+      end
     end
 
-    context 'on the last day of the year' do
-      let(:date) { Date.new(1997, 12, 31)}
+    context 'with an interval of two' do
+      let(:interval) { 2 }
+      let(:date) { Time.zone.local(1997, 1, 1) }
 
-      it { is_expected.to eql date + 1.year }
+      it 'returns every other year' do
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1997, 1, 1)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(1999, 1, 1)]
+        expect(frequency.next_occurrences).to eql [Time.zone.local(2001, 1, 1)]
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -19,3 +19,5 @@ RSpec.configure do |config|
     mocks.verify_partial_doubles = true
   end
 end
+
+Time.zone = 'America/Los_Angeles'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rrule
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Ryan Mitchell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-06 00:00:00.000000000 Z
+date: 2018-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -62,6 +62,7 @@ files:
 - lib/rrule/frequencies/daily.rb
 - lib/rrule/frequencies/frequency.rb
 - lib/rrule/frequencies/monthly.rb
+- lib/rrule/frequencies/simple_weekly.rb
 - lib/rrule/frequencies/weekly.rb
 - lib/rrule/frequencies/yearly.rb
 - lib/rrule/generators/all_occurrences.rb
@@ -69,6 +70,8 @@ files:
 - lib/rrule/rule.rb
 - lib/rrule/weekday.rb
 - rrule.gemspec
+- scripts/benchmark.rb
+- scripts/history.txt
 - spec/context_spec.rb
 - spec/filters/by_month_day_spec.rb
 - spec/filters/by_month_spec.rb
@@ -77,6 +80,7 @@ files:
 - spec/filters/by_year_day_spec.rb
 - spec/frequencies/daily_spec.rb
 - spec/frequencies/monthly_spec.rb
+- spec/frequencies/simple_weekly_spec.rb
 - spec/frequencies/weekly_spec.rb
 - spec/frequencies/yearly_spec.rb
 - spec/generators/all_occurrences_spec.rb
@@ -116,6 +120,7 @@ test_files:
 - spec/filters/by_year_day_spec.rb
 - spec/frequencies/daily_spec.rb
 - spec/frequencies/monthly_spec.rb
+- spec/frequencies/simple_weekly_spec.rb
 - spec/frequencies/weekly_spec.rb
 - spec/frequencies/yearly_spec.rb
 - spec/generators/all_occurrences_spec.rb