rrule 0.4.1 → 0.4.4

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

data/spec/generators/by_set_position_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe RRule::BySetPosition 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(positions, context).combine_dates_and_times(dates, times)}
-
-    context 'with a single set position' do
-      let(:positions) { [0] }
-      let(:dates) { [0, 1, 2, 3, 4] }
-      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 set positions' do
-      let(:positions) { [1, 3] }
-      let(:dates) { [0, 1, 2, 3, 4] }
-      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('Fri Jan  3 12:30:15 PST 1997')] }
-    end
-  end
-end

data/spec/generators/generator_spec.rb

@@ -1,110 +0,0 @@
-require 'spec_helper'
-
-describe RRule::Generator 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 '#process_timeset' do
-    describe "single timeset" do
-      subject { described_class.new(context).process_timeset(date, timeset)}
-
-      context 'with a timeset with only 1 set' do
-        let(:date) { Time.parse('Wed Jan  1 00:11:22 PST 1997') }
-        let(:timeset) { [{ 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 hours in the timeset' do
-        let(:date) { Time.parse('Wed Jan  1 00:11:22 PST 1997') }
-        let(:timeset) { [{ hour: [12, 15], minute: 30, second: 15 }] }
-
-        it { is_expected.to match_array [Time.parse('Wed Jan  1 12:30:15 PST 1997'), Time.parse('Wed Jan  1 15:30:15 PST 1997')] }
-      end
-
-      context 'with multiple minutes in the timeset' do
-        let(:date) { Time.parse('Wed Jan  1 00:11:22 PST 1997') }
-        let(:timeset) { [{ hour: [12], minute: [15, 30], second: 15 }] }
-
-        it { is_expected.to match_array [Time.parse('Wed Jan  1 12:15:15 PST 1997'), Time.parse('Wed Jan  1 12:30:15 PST 1997')] }
-      end
-
-      context 'with multiple seconds in the timeset' do
-        let(:date) { Time.parse('Wed Jan  1 00:11:22 PST 1997') }
-        let(:timeset) { [{ hour: [12], minute: [30], second: [15, 59] }] }
-
-        it { is_expected.to match_array [Time.parse('Wed Jan  1 12:30:15 PST 1997'), Time.parse('Wed Jan  1 12:30:59 PST 1997')] }
-      end
-
-      context 'with multiple hours, minutes, and seconds in the timeset' do
-        let(:date) { Time.parse('Wed Jan  1 00:11:22 PST 1997') }
-        let(:timeset) { [{ hour: [12, 20], minute: [30, 55], second: [15, 59] }] }
-
-        it { is_expected.to eq [
-          Time.parse('Wed Jan  1 12:30:15 PST 1997'),
-          Time.parse('Wed Jan  1 12:30:59 PST 1997'),
-          Time.parse('Wed Jan  1 12:55:15 PST 1997'),
-          Time.parse('Wed Jan  1 12:55:59 PST 1997'),
-          Time.parse('Wed Jan  1 20:30:15 PST 1997'),
-          Time.parse('Wed Jan  1 20:30:59 PST 1997'),
-          Time.parse('Wed Jan  1 20:55:15 PST 1997'),
-          Time.parse('Wed Jan  1 20:55:59 PST 1997'),
-        ] }
-      end
-
-      context 'with multiple hours, minutes, and seconds in the timeset, unsorted' do
-        let(:date) { Time.parse('Wed Jan  1 00:11:22 PST 1997') }
-        let(:timeset) { [{ hour: [20, 12], minute: [55, 30], second: [59, 15] }] }
-
-        it { is_expected.to eq [
-          Time.parse('Wed Jan  1 12:30:15 PST 1997'),
-          Time.parse('Wed Jan  1 12:30:59 PST 1997'),
-          Time.parse('Wed Jan  1 12:55:15 PST 1997'),
-          Time.parse('Wed Jan  1 12:55:59 PST 1997'),
-          Time.parse('Wed Jan  1 20:30:15 PST 1997'),
-          Time.parse('Wed Jan  1 20:30:59 PST 1997'),
-          Time.parse('Wed Jan  1 20:55:15 PST 1997'),
-          Time.parse('Wed Jan  1 20:55:59 PST 1997'),
-        ] }
-      end
-    end
-  end
-
-  describe "multiple timesets" do
-    subject { described_class.new(context).process_timeset(date, timeset)}
-
-      context 'with multiple timsets' do
-        let(:date) { Time.parse('Wed Jan  1 00:11:22 PST 1997') }
-        let(:timeset) { [{ hour: 12, minute: 30, second: 15 }, { hour: 18, minute: 45, second: 20 }] }
-
-        it { is_expected.to eq [Time.parse('Wed Jan  1 12:30:15 PST 1997'), Time.parse('Wed Jan  1 18:45:20 PST 1997')] }
-      end
-
-      context 'with multiple timsets with multiple hour sets' do
-        let(:date) { Time.parse('Wed Jan  1 00:11:22 PST 1997') }
-        let(:timeset) { [{ hour: [12, 20], minute: 30, second: [15, 45] }, { hour: 18, minute: [22, 45], second: 20 }] }
-
-        it { is_expected.to eq [
-          Time.parse('Wed Jan  1 12:30:15 PST 1997'),
-          Time.parse('Wed Jan  1 12:30:45 PST 1997'),
-          Time.parse('Wed Jan  1 20:30:15 PST 1997'),
-          Time.parse('Wed Jan  1 20:30:45 PST 1997'),
-          Time.parse('Wed Jan  1 18:22:20 PST 1997'),
-          Time.parse('Wed Jan  1 18:45:20 PST 1997')
-        ] }
-      end
-  end
-end