rrule 0.4.1 → 0.4.2

data/spec/filters/by_week_day_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-describe RRule::ByWeekDay do
-  let(:context) do
-    RRule::Context.new(
-        { freq: 'WEEKLY', count: 4 },
-        Time.parse('Wed Jan  1 00:00:00 PST 1997'),
-        'America/Los_Angeles'
-    )
-  end
-
-  subject { described_class.new([RRule::Weekday.parse('TU'), RRule::Weekday.parse('FR')], context).reject?(date.yday - 1) }
-
-  before(:each) { context.rebuild(1997, 1) }
-
-  describe '#reject?' do
-    context 'for the Friday of the week' do
-      let(:date) { Date.new(1997, 1, 3) }
-
-      it { is_expected.to be false }
-    end
-
-    context 'for the Saturday of the week' do
-      let(:date) { Date.new(1997, 1, 4) }
-
-      it { is_expected.to be true }
-    end
-
-    context 'for the Tuesday of the next week' do
-      let(:date) { Date.new(1997, 1, 7) }
-
-      it { is_expected.to be false }
-    end
-  end
-end

data/spec/filters/by_week_number_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe RRule::ByWeekNumber do
-  let(:context) do
-    RRule::Context.new(
-        { freq: 'YEARLY', wkst: 1 },
-        Time.parse('Wed Jan  1 00:00:00 PST 1997'),
-        'America/Los_Angeles'
-    )
-  end
-
-  subject { described_class.new([2, -3], context).reject?(date.yday - 1) }
-
-  before(:each) { context.rebuild(1997, 1) }
-
-  describe '#reject?' do
-    context 'for the first week of the year' do
-      let(:date) { Date.new(1997, 1, 2) }
-
-      it { is_expected.to be true }
-    end
-
-    context 'for the second week of the year' do
-      let(:date) { Date.new(1997, 1, 8) }
-
-      it { is_expected.to be false }
-    end
-
-    context 'for the fourth week of the year' do
-      let(:date) { Date.new(1997, 1, 22) }
-
-      it { is_expected.to be true }
-    end
-
-    context 'for the third-to-last week of the year' do
-      let(:date) { Date.new(1997, 12, 9) }
-
-      it { is_expected.to be false }
-    end
-  end
-end

data/spec/filters/by_year_day_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-describe RRule::ByYearDay do
-  let(:context) do
-    RRule::Context.new(
-        { freq: 'YEARLY', count: 4 },
-        Time.parse('Wed Jan  1 00:00:00 PST 1997'),
-        'America/Los_Angeles'
-    )
-  end
-
-  subject { described_class.new([45, -45], context).reject?(date.yday - 1) }
-
-  before(:each) { context.rebuild(1997, 1) }
-
-  describe '#reject?' do
-    context 'for the 45th day of the year' do
-      let(:date) { Date.new(1997, 2, 14) }
-
-      it { is_expected.to be false }
-    end
-
-    context 'for the 60th day of the year' do
-      let(:date) { Date.new(1997, 3, 1) }
-
-      it { is_expected.to be true }
-    end
-
-    context 'for the 45th-from-last day of the month' do
-      let(:date) { Date.new(1997, 11, 17) }
-
-      it { is_expected.to be false }
-    end
-  end
-end

data/spec/frequencies/daily_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-describe RRule::Daily do
-  let(:interval) { 1 }
-  let(:context) do
-    RRule::Context.new(
-        { 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 }] }
-
-  before { context.rebuild(date.year, date.month) }
-
-  describe '#next_occurrences' do
-    subject(:frequency) { described_class.new(context, filters, generator, timeset) }
-
-    context 'with an interval of one' do
-      let(:date) { Time.zone.local(1997, 1, 1) }
-
-      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 'with an interval of two' do
-      let(:interval) { 2 }
-      let(:date) { Time.zone.local(1997, 1, 1) }
-
-      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) { Time.zone.local(1997, 2, 28) }
-
-      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) { Time.zone.local(1997, 12, 31) }
-
-      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,63 +0,0 @@
-require 'spec_helper'
-
-describe RRule::Monthly do
-  let(:interval) { 1 }
-  let(:context) do
-    RRule::Context.new(
-        { 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 { context.rebuild(date.year, date.month) }
-
-  describe '#next_occurrences' do
-    subject(:frequency) { described_class.new(context, filters, generator, timeset) }
-
-    context 'with an interval of one' do
-      let(:date) { Time.zone.local(1997, 1, 1) }
-
-      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 'with an interval of two' do
-      let(:interval) { 2 }
-      let(:date) { Time.zone.local(1997, 1, 1) }
-
-      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) { Time.zone.local(1997, 2, 28) }
-
-      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) { 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

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe RRule::SimpleWeekly do
-  let(:context) { RRule::Context.new({ interval: interval }, date, 'America/Los_Angeles') }
-  let(:frequency) { described_class.new(context, nil, generator, timeset) }
-  let(:generator) { RRule::AllOccurrences.new(context) }
-  let(:timeset) { [{ hour: date.hour, minute: date.min, second: date.sec }] }
-
-  describe '#next_occurrences' do
-    let(:date) { Time.zone.local(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 [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 'with an interval of 2' do
-      let(:interval) { 2 }
-
-      it 'returns occurrences 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
-  end
-end

data/spec/frequencies/weekly_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-
-describe RRule::Weekly do
-  let(:interval) { 1 }
-  let(:context) do
-    RRule::Context.new(
-        { 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 { context.rebuild(date.year, date.month) }
-
-  describe '#next_occurrences' do
-    subject(:frequency) { described_class.new(context, filters, generator, timeset) }
-
-    context 'with an interval of one' do
-      let(:date) { Time.zone.local(1997, 1, 1) }
-
-      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 'with an interval of two' do
-      let(:interval) { 2 }
-      let(:date) { Time.zone.local(1997, 1, 1) }
-
-      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 the first day of the year with five days left in the week' do
-      let(:date) { Time.zone.local(1997, 1, 1) }
-
-      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
-
-    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 a day in the next month with six days left in the week' do
-      let(:date) { Time.zone.local(1997, 2, 25) }
-
-      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) { Time.zone.local(1997, 2, 28) }
-
-      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) { Time.zone.local(1997, 12, 31) }
-
-      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,54 +0,0 @@
-require 'spec_helper'
-
-describe RRule::Yearly do
-  let(:interval) { 1 }
-  let(:context) do
-    RRule::Context.new(
-        { 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(date.year, date.month) }
-
-  describe '#next_occurrences' do
-    subject(:frequency) { described_class.new(context, filters, generator, timeset) }
-
-    context 'on the first day of the year' do
-      let(:date) { Time.zone.local(1997, 1, 1) }
-
-      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 in a leap year' do
-      let(:date) { Time.zone.local(2000, 2, 29) }
-
-      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 'with an interval of two' do
-      let(:interval) { 2 }
-      let(:date) { Time.zone.local(1997, 1, 1) }
-
-      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/generators/all_occurrences_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-describe RRule::AllOccurrences do
-  let(:context) do
-    RRule::Context.new(
-        { interval: 1, wkst: 1 },
-        Time.parse('Wed Jan  1 00:00:00 PST 1997'),
-        'America/Los_Angeles'
-    )
-  end
-
-  around(:each) do |example|
-    Time.use_zone('America/Los_Angeles') do
-      example.run
-    end
-  end
-
-  before(:each) { context.rebuild(1997, 1) }
-
-  describe '#combine_dates_and_times' do
-    subject { described_class.new(context).combine_dates_and_times(dates, times)}
-
-    context 'with a single date and time' do
-      let(:dates) { [0] }
-      let(:times) { [{ hour: 12, minute: 30, second: 15 }] }
-
-      it { is_expected.to match_array [Time.parse('Wed Jan  1 12:30:15 PST 1997')] }
-    end
-
-    context 'with multiple dates and a single time' do
-      let(:dates) { [0, 15] }
-      let(:times) { [{ hour: 12, minute: 30, second: 15 }] }
-
-      it { is_expected.to match_array [Time.parse('Wed Jan  1 12:30:15 PST 1997'), Time.parse('Thu Jan 16 12:30:15 PST 1997')] }
-    end
-
-    context 'with a single date and multiple times' do
-      let(:dates) { [0] }
-      let(:times) { [{ hour: 12, minute: 30, second: 15 }, { hour: 18, minute: 45, second: 20 }] }
-
-      it { is_expected.to match_array [Time.parse('Wed Jan  1 12:30:15 PST 1997'), Time.parse('Wed Jan  1 18:45:20 PST 1997')] }
-    end
-  end
-end