cyclical 0.1.0

data/spec/filters/months_filter_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe MonthsFilter do
+  before do
+    @filter = MonthsFilter.new(:january, :feb, 3)
+  end
+
+  it "should accept months as constructor arguments" do
+    @filter.months.should == [1, 2, 3]
+  end
+
+  it "should provide next valid date" do
+    @filter.next(Time.utc(2009, 5, 10, 21, 13, 11)).should == Time.utc(2010, 1, 1, 21, 13, 11)
+    @filter.next(Time.utc(2009, 12, 10, 21, 13, 11)).should == Time.utc(2010, 1, 1, 21, 13, 11)
+    @filter.next(Time.utc(2010, 1, 10, 21, 13, 11)).should == Time.utc(2010, 1, 10, 21, 13, 11)
+    @filter.next(Time.utc(2010, 2, 14, 21, 13, 11)).should == Time.utc(2010, 2, 14, 21, 13, 11)
+    @filter.next(Time.utc(2010, 3, 14, 21, 13, 11)).should == Time.utc(2010, 3, 14, 21, 13, 11)
+  end
+end

data/spec/filters/weekdays_filter_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe WeekdaysFilter do
+  before do
+    @filter = WeekdaysFilter.new(:monday, :tue, 5)
+  end
+
+  it "should accept weekdays as constructor arguments" do
+    @filter.weekdays.should == [1, 2, 5]
+  end
+
+  it "should accept weekdays with order as well" do
+    rule = MonthlyRule.new
+    filter = WeekdaysFilter.new(rule, :tue, :monday => 1, :tuesday => [1, -1])
+
+    filter.weekdays.should == [2]
+    filter.ordered_weekdays.should == {:mo => [1], :tu => [-1, 1]}
+  end
+
+  it "should match only the selected weekdays" do
+    filter = WeekdaysFilter.new(:mon, :fri)
+
+    filter.match?(Time.utc(2000, 1, 3)).should be_true
+    filter.match?(Time.utc(2000, 1, 7)).should be_true
+    filter.match?(Time.utc(2000, 1, 10)).should be_true
+
+    filter.match?(Time.utc(2000, 1, 2)).should be_false
+    filter.match?(Time.utc(2000, 1, 4)).should be_false
+    filter.match?(Time.utc(2000, 1, 5)).should be_false
+    filter.match?(Time.utc(2000, 1, 6)).should be_false
+    filter.match?(Time.utc(2000, 1, 8)).should be_false
+    filter.match?(Time.utc(2000, 1, 9)).should be_false
+  end
+
+  it "should provide next valid date" do
+    @filter.next(Time.utc(2010, 1, 1, 21, 13, 11)).should == Time.utc(2010, 1, 1, 21, 13, 11)
+    @filter.next(Time.utc(2010, 1, 2, 21, 13, 11)).should == Time.utc(2010, 1, 4, 21, 13, 11)
+    @filter.next(Time.utc(2010, 1, 4, 21, 13, 11)).should == Time.utc(2010, 1, 4, 21, 13, 11)
+    @filter.next(Time.utc(2010, 1, 5, 21, 13, 11)).should == Time.utc(2010, 1, 5, 21, 13, 11)
+    @filter.next(Time.utc(2010, 1, 6, 21, 13, 11)).should == Time.utc(2010, 1, 8, 21, 13, 11)
+  end
+
+  describe "with MonthlyRule" do
+    before do
+      rule = MonthlyRule.new
+      @filter = WeekdaysFilter.new(rule, :mon => [-1, 1])
+    end
+
+    it "should store the rule" do
+      @filter.rule.should be_a(MonthlyRule)
+    end
+
+    it "should match ordered weekdays" do
+      # January
+      # wrong weekday
+      @filter.match?(Time.utc(2000, 1, 1)).should be_false
+      @filter.match?(Time.utc(2000, 1, 2)).should be_false
+
+      # right day right order
+      @filter.match?(Time.utc(2000, 1, 3)).should be_true
+      @filter.match?(Time.utc(2000, 1, 31)).should be_true
+
+      # right day wrong order
+      @filter.match?(Time.utc(2000, 1, 10)).should be_false
+      @filter.match?(Time.utc(2000, 1, 17)).should be_false
+      @filter.match?(Time.utc(2000, 1, 24)).should be_false
+
+      # February
+      # wrong weekday
+      @filter.match?(Time.utc(2000, 2, 1)).should be_false
+      @filter.match?(Time.utc(2000, 2, 2)).should be_false
+
+      # right day right order
+      @filter.match?(Time.utc(2000, 2, 7)).should be_true
+      @filter.match?(Time.utc(2000, 2, 28)).should be_true
+
+      # right day wrong order
+      @filter.match?(Time.utc(2000, 2, 14)).should be_false
+      @filter.match?(Time.utc(2000, 2, 21)).should be_false
+    end
+  end
+
+  describe "with YearlyRule" do
+    before do
+      rule = YearlyRule.new
+      @filter = WeekdaysFilter.new(rule, :mon => [-1, 1])
+    end
+
+    it "should store the rule" do
+      @filter.rule.should be_a(YearlyRule)
+    end
+
+    it "should match ordered weekdays" do
+      # wrong weekday
+      @filter.match?(Time.utc(2000, 1, 1)).should be_false
+      @filter.match?(Time.utc(2000, 1, 2)).should be_false
+
+      # right day right order
+      @filter.match?(Time.utc(2000, 1, 3)).should be_true
+      @filter.match?(Time.utc(2000, 12, 25)).should be_true
+
+      # right day wrong order
+      @filter.match?(Time.utc(2000, 1, 10)).should be_false
+      @filter.match?(Time.utc(2000, 1, 17)).should be_false
+      @filter.match?(Time.utc(2000, 1, 24)).should be_false
+    end
+  end
+end

data/spec/filters/yeardays_filter_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe  do
+  before do
+    @filter = YeardaysFilter.new(1, 50, -50)
+  end
+
+  it "should accept weekdays as constructor arguments" do
+    @filter.yeardays.should == [-50, 1, 50]
+  end
+
+
+  it "should match only the selected monthdays" do
+    filter = YeardaysFilter.new(1, 100, 200, -10)
+
+    filter.match?(Time.utc(2000, 1, 1)).should be_true
+    filter.match?(Time.utc(2000, 4, 9)).should be_true
+    filter.match?(Time.utc(2000, 7, 18)).should be_true
+    filter.match?(Time.utc(2000, 12, 22)).should be_true
+
+    filter.match?(Time.utc(2000, 2, 26)).should be_false
+
+    filter.match?(Time.utc(2000, 1, 2)).should be_false
+    filter.match?(Time.utc(2000, 4, 4)).should be_false
+    filter.match?(Time.utc(2000, 8, 5)).should be_false
+    filter.match?(Time.utc(2000, 11, 6)).should be_false
+    filter.match?(Time.utc(2000, 11, 8)).should be_false
+    filter.match?(Time.utc(2000, 12, 27)).should be_false
+  end
+
+  it "should provide next valid date" do
+    @filter.next(Time.utc(2010, 1, 1, 21, 13, 11)).should == Time.utc(2010, 1, 1, 21, 13, 11)
+    @filter.next(Time.utc(2010, 1, 2, 21, 13, 11)).should == Time.utc(2010, 2, 19, 21, 13, 11)
+    @filter.next(Time.utc(2010, 2, 30, 21, 13, 11)).should == Time.utc(2010, 11, 12, 21, 13, 11)
+  end
+end

data/spec/occurrence_spec.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+
+describe Occurrence do
+  before do
+    @start_time = Time.utc(2000, 1, 1, 9, 30)
+    @occurrence = Occurrence.new(Rule.daily, @start_time)
+  end
+
+  it "should have read only rule attribute" do
+    @occurrence.rule.should be_a(Rule)
+  end
+
+  it "should find next occurrence" do
+    # simple cases
+    @occurrence.next_occurrence(Time.utc(2010, 1, 1)).should == Time.utc(2010, 1, 1, 9, 30)
+    @occurrence.next_occurrence(Time.utc(2010, 1, 1, 10)).should == Time.utc(2010, 1, 2, 9, 30)
+
+    # boundary cases
+    @occurrence.next_occurrence(Time.utc(2010, 1, 1, 9, 30)).should == Time.utc(2010, 1, 1, 9, 30)
+    @occurrence.next_occurrence(@start_time).should == @start_time
+
+    # limit case
+    @occurrence.next_occurrence(@start_time).should == @start_time
+    @occurrence.next_occurrence(Time.utc(1990, 1, 1)).should == @start_time
+  end
+
+  it "should find next n occurrences" do
+    # simple cases
+    expected = [Time.utc(2010, 1, 1, 9, 30), Time.utc(2010, 1, 2, 9, 30), Time.utc(2010, 1, 3, 9, 30), Time.utc(2010, 1, 4, 9, 30)]
+    first_three = [@start_time, @start_time + 1.day, @start_time + 2.days]
+
+    @occurrence.next_occurrences(3, Time.utc(2010, 1, 1)).should == expected[0..2]
+    @occurrence.next_occurrences(3, Time.utc(2010, 1, 1, 10)).should == expected[1..3]
+
+    # boundary cases
+    @occurrence.next_occurrences(3, Time.utc(2010, 1, 1, 9, 30)).should == expected[0..2]
+    @occurrence.next_occurrences(3, @start_time).should == first_three
+
+    # limit case
+    @occurrence.next_occurrences(3, @start_time).should == first_three
+    @occurrence.next_occurrences(3, Time.utc(1990, 1, 1)).should == first_three
+
+    # other lengths
+    @occurrence.next_occurrences(5, Time.utc(2010, 1, 1)).length.should == 5
+    @occurrence.next_occurrences(15, Time.utc(2010, 1, 1)).length.should == 15
+  end
+
+  it "should find previous occurrence" do
+    base = Time.utc(2000, 1, 1, 9, 30)
+
+    # simple cases
+    @occurrence.previous_occurrence(Time.utc(2010, 1, 1)).should == Time.utc(2009, 12, 31, 9, 30)
+    @occurrence.previous_occurrence(Time.utc(2010, 1, 1, 10)).should == Time.utc(2010, 1, 1, 9, 30)
+
+    # boundary cases
+    @occurrence.previous_occurrence(Time.utc(2010, 1, 1, 9, 30)).should == Time.utc(2009, 12, 31, 9, 30)
+
+    # limit cases
+    @occurrence.previous_occurrence(@start_time).should == nil
+    @occurrence.previous_occurrence(Time.utc(1990, 1, 1)).should == nil
+  end
+
+  it "should find previous n occurrences" do
+    # simple cases
+    expected = [Time.utc(2009, 12, 29, 9, 30), Time.utc(2009, 12, 30, 9, 30), Time.utc(2009, 12, 31, 9, 30), Time.utc(2010, 1, 1, 9, 30)]
+
+    # simple cases
+    @occurrence.previous_occurrences(3, Time.utc(2010, 1, 1)).should == expected[0..2]
+    @occurrence.previous_occurrences(3, Time.utc(2010, 1, 1, 10)).should == expected[1..3]
+
+    # boundary cases
+    @occurrence.previous_occurrences(3, Time.utc(2010, 1, 1, 9, 30)).should == expected[0..2]
+
+    # limit case
+    @occurrence.previous_occurrences(3, @start_time).should be_empty
+    @occurrence.previous_occurrences(3, Time.utc(1990, 1, 1)).should be_empty
+
+    # other lengths
+    @occurrence.previous_occurrences(5, Time.utc(2010, 1, 1)).length.should == 5
+    @occurrence.previous_occurrences(15, Time.utc(2010, 1, 1)).length.should == 15
+  end
+
+  it "should find occurrences between dates" do
+    expected = [Time.utc(2010, 1, 1, 9, 30), Time.utc(2010, 1, 2, 9, 30), Time.utc(2010, 1, 3, 9, 30), Time.utc(2010, 1, 4, 9, 30)]
+
+    # simple cases
+    @occurrence.occurrences_between(Time.utc(2010, 1, 1), Time.utc(2010, 1, 4, 10)).should == expected
+    @occurrence.occurrences_between(Time.utc(2010, 1, 1, 10), Time.utc(2010, 1, 4, 10)).should == expected[1..3]
+    @occurrence.occurrences_between(Time.utc(2010, 1, 1), Time.utc(2010, 1, 4, 0)).should == expected[0..2]
+
+    # boundary cases
+    @occurrence.occurrences_between(Time.utc(2010, 1, 1, 9, 30), Time.utc(2010, 1, 4, 9, 30)).should == expected[0..2]
+
+    # limit cases
+    @occurrence.occurrences_between(@start_time, Time.utc(2000, 1, 2, 9, 30)).first.should == @start_time
+    @occurrence.occurrences_between(Time.utc(1990, 1, 1), Time.utc(2000, 1, 2, 9, 30)).first.should == @start_time
+  end
+
+  describe "finite rules" do
+    before do
+      @start_time = Time.utc(2000, 1, 1, 9, 30)
+      @count_occurrence = Occurrence.new(Rule.daily.count(10), @start_time)
+      @stop_occurrence = Occurrence.new(Rule.daily.stop(Time.utc(2000, 1, 15, 10)), @start_time)
+    end
+
+    it "should find all occurrences" do
+      @count_occurrence.all.length.should == 10
+      @stop_occurrence.all.length.should == 15
+    end
+
+    it "should limit occurrences between" do
+      # whole interval
+      @count_occurrence.occurrences_between(Time.utc(1990, 1, 1), Time.utc(2001, 1, 1)).length.should == 10
+      @stop_occurrence.occurrences_between(Time.utc(1990, 1, 1), Time.utc(2001, 1, 1)).length.should == 15
+
+      # stop in interval
+      @count_occurrence.occurrences_between(Time.utc(1990, 1, 1), Time.utc(2000, 1, 5)).length.should == 4
+      @stop_occurrence.occurrences_between(Time.utc(1990, 1, 1), Time.utc(2000, 1, 5)).length.should == 4
+
+      # start in interval
+      @count_occurrence.occurrences_between(Time.utc(2000, 1, 5), Time.utc(2001, 1, 1)).length.should == 6
+      @stop_occurrence.occurrences_between(Time.utc(2000, 1, 5), Time.utc(2001, 1, 1)).length.should == 11
+    end
+
+    it "should limit next occurrences" do
+      # before interval
+      @count_occurrence.next_occurrences(5, Time.utc(1990, 1, 1)).length.should == 5
+      @stop_occurrence.next_occurrences(5, Time.utc(1990, 1, 1)).length.should == 5
+
+      # inside interval
+      @count_occurrence.next_occurrences(5, Time.utc(2000, 1, 8)).length.should == 3
+      @stop_occurrence.next_occurrences(5, Time.utc(2000, 1, 12)).length.should == 4
+    end
+
+    it "should limit previous occurrences" do
+      # inside interval
+      @count_occurrence.previous_occurrences(5, Time.utc(2000, 1, 4)).length.should == 3
+      @stop_occurrence.previous_occurrences(5, Time.utc(2000, 1, 4)).length.should == 3
+
+      # after interval
+      occ = @count_occurrence.previous_occurrences(5, Time.utc(2001, 1, 1))
+      occ.length.should == 5
+      occ.last.should == Time.utc(2000, 1, 10, 9, 30)
+
+      occ = @stop_occurrence.previous_occurrences(5, Time.utc(2001, 1, 1))
+      occ.length.should == 5
+      occ.last.should == Time.utc(2000, 1, 15, 9, 30)
+    end
+  end
+
+  describe "filtered rules" do
+    before do
+      @start_time = Time.utc(2000, 1, 1, 9, 30)
+      @weekday_filtered_occurrence = Occurrence.new(Rule.daily.weekdays(:sat, :mon), @start_time)
+      @month_filtered_occurrence = Occurrence.new(Rule.daily.months(:january, :sept), @start_time)
+    end
+
+    it "should filter next occurrences" do
+      expected = [1, 3, 8, 10, 15, 17, 22].map { |i| Time.utc(2000, 1, i, 9, 30) }
+      @weekday_filtered_occurrence.next_occurrences(7, Time.utc(2000, 1, 1, 2)).should == expected
+
+      expected = [30, 31].map { |i| Time.utc(2000, 1, i, 9, 30) } +
+                 (1..5).map { |i| Time.utc(2000, 9, i, 9, 30) }
+      @month_filtered_occurrence.next_occurrences(7, Time.utc(2000, 1, 30)).should == expected
+    end
+
+    it "should filter previous occurrences" do
+      expected = [1, 3, 8, 10, 15, 17, 22].map { |i| Time.utc(2000, 1, i, 9, 30) }
+      @weekday_filtered_occurrence.previous_occurrences(7, Time.utc(2000, 1, 22, 10)).should == expected
+
+      expected = [30, 31].map { |i| Time.utc(2000, 1, i, 9, 30) } +
+                 (1..5).map { |i| Time.utc(2000, 9, i, 9, 30) }
+      @month_filtered_occurrence.previous_occurrences(7, Time.utc(2000, 9, 6)).should == expected
+    end
+
+    it "should shift bad start time forward" do
+      start_time = Time.utc(2000, 1, 1, 10, 0, 0)
+      occurrence = Occurrence.new(Rule.yearly.months(3, 5).weekday(:monday), start_time)
+
+      occurrence.start_time.should_not == start_time
+      occurrence.start_time.should == Time.utc(2000, 3, 6, 10)
+    end
+  end
+
+  describe "suboccurrences" do
+    before do
+      @start_time = Time.utc(2000, 1, 1, 9, 30)
+      @occurrence = Occurrence.new(Rule.daily(3).count(10), @start_time)
+      @occurrence.duration = 24.hours
+    end
+
+    it "should report duration" do
+      @occurrence.duration.should == 24.hours
+    end
+
+    it "should find subooccurrences between dates" do
+      s = @occurrence.suboccurrences_between(Time.utc(2000, 1, 1, 12), Time.utc(2000, 1, 5, 6))
+
+      s.length.should == 2
+      s.first.start.should == Time.utc(2000, 1, 1, 12)
+      s.first.end.should == Time.utc(2000, 1, 2, 9, 30)
+
+      s[1].start.should == Time.utc(2000, 1, 4, 9, 30)
+      s[1].end.should == Time.utc(2000, 1, 5, 6)
+    end
+  end
+end

data/spec/rule_dsl_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Rule do
+  describe "rule factories" do
+    it "should create daily rule" do
+      Rule.daily.should be_a(DailyRule)
+
+      rule = Rule.daily(5)
+      rule.should be_a(DailyRule)
+      rule.interval.should == 5
+    end
+
+    it "should create yearly dule" do
+      Rule.yearly.should be_a(YearlyRule)
+
+      rule = Rule.yearly(5)
+      rule.should be_a(YearlyRule)
+      rule.interval.should == 5
+    end
+
+    it "should create weekly rule" do
+      Rule.weekly.should be_a(WeeklyRule)
+
+      rule = Rule.weekly(5)
+      rule.should be_a(WeeklyRule)
+      rule.interval.should == 5
+    end
+
+    it "should create monthly rule" do
+      Rule.monthly.should be_a(MonthlyRule)
+
+      rule = Rule.monthly(5)
+      rule.should be_a(MonthlyRule)
+      rule.interval.should == 5
+    end
+  end
+
+  describe "filters" do
+    before :each do
+      @rule = Rule.daily
+    end
+
+    it "should add single month filter and allow chaining" do
+      @rule.month(:january).should be_a(DailyRule)
+      @rule.filters.first.should be_a(MonthsFilter)
+
+      @rule.filters(:months).should_not be_nil
+      @rule.filters(:months).months.should == [1]
+    end
+
+    it "should add multiple months filter and allow chaining" do
+      @rule.months(:january, :march, 5).should be_a(DailyRule)
+      @rule.filters.first.should be_a(MonthsFilter)
+
+      @rule.filters(:months).should_not be_nil
+      @rule.filters(:months).months.should == [1, 3, 5]
+    end
+
+    it "should add single weekday filter and allow chaining" do
+      @rule.weekday(:mon).should be_a(DailyRule)
+      @rule.filters.first.should be_a(WeekdaysFilter)
+
+      @rule.filters(:weekdays).should_not be_nil
+      @rule.filters(:weekdays).weekdays.should == [1]
+    end
+
+    it "should add multiple weekdays filter and allow chaining" do
+      @rule.weekdays(:monday, :tue, 3).should be_a(DailyRule)
+      @rule.filters.first.should be_a(WeekdaysFilter)
+
+      @rule.filters(:weekdays).should_not be_nil
+      @rule.filters(:weekdays).weekdays.should == [1, 2, 3]
+    end
+
+    it "should pass rules into weekdays filter" do
+      @rule.weekdays(:monday, :tue, 3).should be_a(DailyRule)
+
+      @rule.filters(:weekdays).rule.should be_a(DailyRule)
+    end
+
+    it "should add monthday filter and allow chaining" do
+      @rule.monthday(28).should be_a(DailyRule)
+      @rule.filters.first.should be_a(MonthdaysFilter)
+
+      @rule.filters(:monthdays).should_not be_nil
+      @rule.filters(:monthdays).monthdays.should == [28]
+    end
+
+    it "should add monthday filter and allow chaining" do
+      @rule.monthday(-20, 13, 25).should be_a(DailyRule)
+      @rule.filters.first.should be_a(MonthdaysFilter)
+
+      @rule.filters(:monthdays).should_not be_nil
+      @rule.filters(:monthdays).monthdays.should == [-20, 13, 25]
+    end
+
+    it "should add multiple yeardays filter and allow chaining" do
+      @rule.yeardays(-30, 100, 250).should be_a(DailyRule)
+      @rule.filters.first.should be_a(YeardaysFilter)
+
+      @rule.filters(:yeardays).should_not be_nil
+      @rule.filters(:yeardays).yeardays.should == [-30, 100, 250]
+    end
+  end
+end

data/spec/rules/daily_rule_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+describe DailyRule do
+  describe "simple rule" do
+    before do
+      @rule = DailyRule.new
+    end
+
+    it "should return one day as step" do
+      @rule.step.should == 1.day
+    end
+
+    it "should find next date" do
+      base = Time.local(2010, 1, 1, 9, 30, 21)
+
+      @rule.next(Time.local(2010, 1, 1), base).should == Time.local(2010, 1, 1, 9, 30, 21)
+      @rule.next(Time.local(2010, 1, 1, 9, 30, 21), base).should == Time.local(2010, 1, 2, 9, 30, 21)
+      @rule.next(Time.local(2010, 1, 1, 10), base).should == Time.local(2010, 1, 2, 9, 30, 21)
+
+      # align forward should include base time
+      @rule.next(base, base).should == base + 1.day
+    end
+
+    it "should find previous date" do
+      base = Time.local(2010, 1, 1, 9, 30, 21)
+
+      @rule.previous(Time.local(2010, 1, 1), base).should == Time.local(2009, 12, 31, 9, 30, 21)
+      @rule.previous(Time.local(2010, 1, 1, 10), base).should == Time.local(2010, 1, 1, 9, 30, 21)
+
+      # align back should exclude base time
+      @rule.previous(base, base).should == Time.local(2009, 12, 31, 9, 30, 21)
+    end
+
+    it "should match dates" do
+      @rule.match?(Time.local(2010, 1, 1, 9, 30), Time.local(2010, 1, 12, 9, 30)).should be_true
+      @rule.match?(Time.local(2010, 1, 1, 9, 30), Time.local(2010, 1, 12, 9, 29)).should_not be_true
+    end
+  end
+
+  describe "finite rules" do
+    before do
+      @rule = DailyRule.new
+    end
+
+    it "should accept count and allow chaining" do
+      @rule.count(10).should be_a(DailyRule)
+      @rule.count.should == 10
+    end
+
+    it "should accept stop time" do
+      @rule.stop(Time.utc(2020, 1, 1)).should be_a(DailyRule)
+      @rule.stop.should == Time.utc(2020, 1, 1)
+    end
+
+    it "should report rule finiteness" do
+      DailyRule.new.count(5).should be_finite
+      DailyRule.new.stop(Time.utc(2020, 1, 1)).should be_finite
+
+      DailyRule.new.should_not be_finite
+    end
+  end
+
+  describe "rule with interval" do
+    before do
+      @every_other_day_rule = DailyRule.new(2)
+      @every_ten_days_rule = DailyRule.new(10)
+    end
+
+    it "should return corect step" do
+      @every_other_day_rule.step.should == 2.days
+      @every_ten_days_rule.step.should == 10.days
+    end
+
+    it "should find next date" do
+      base = Time.local(2010, 1, 1, 9, 30, 21)
+
+      @every_other_day_rule.next(Time.local(2010, 1, 1), base).should == Time.local(2010, 1, 1, 9, 30, 21)
+      @every_ten_days_rule.next(Time.local(2010, 1, 1), base).should == Time.local(2010, 1, 1, 9, 30, 21)
+
+      @every_other_day_rule.next(Time.local(2010, 1, 1, 10), base).should == Time.local(2010, 1, 3, 9, 30, 21)
+      @every_ten_days_rule.next(Time.local(2010, 1, 1, 10), base).should == Time.local(2010, 1, 11, 9, 30, 21)
+
+      # align forward should include base time
+      @every_other_day_rule.next(base, base).should == base + 2.days
+      @every_ten_days_rule.next(base, base).should == base + 10.days
+    end
+
+    it "should align dates back" do
+      base = Time.local(2010, 1, 1, 9, 30, 21)
+
+      @every_other_day_rule.previous(Time.local(2010, 1, 1), base).should == Time.local(2009, 12, 30, 9, 30, 21)
+      @every_ten_days_rule.previous(Time.local(2010, 1, 1), base).should == Time.local(2009, 12, 22, 9, 30, 21)
+
+      @every_other_day_rule.previous(Time.local(2010, 1, 1, 10), base).should == Time.local(2010, 1, 1, 9, 30, 21)
+      @every_ten_days_rule.previous(Time.local(2010, 1, 1, 10), base).should == Time.local(2010, 1, 1, 9, 30, 21)
+
+      # align forward should include base time
+      @every_other_day_rule.previous(base, base).should == base - 2.days
+      @every_ten_days_rule.previous(base, base).should == base - 10.days
+    end
+
+    it "should check date alignment" do
+      base = Time.local(2010, 1, 1, 9, 30)
+
+      @every_other_day_rule.match?(Time.local(2010, 1, 1, 9, 30), base).should be_true
+      @every_other_day_rule.match?(Time.local(2010, 1, 3, 9, 30), base).should be_true
+
+      @every_ten_days_rule.match?(Time.local(2010, 1, 1, 9, 30), base).should be_true
+      @every_ten_days_rule.match?(Time.local(2010, 1, 11, 9, 30), base).should be_true
+
+      @every_other_day_rule.match?(Time.local(2010, 1, 2, 9, 30), base).should_not be_true
+      @every_ten_days_rule.match?(Time.local(2010, 1, 5, 9, 30), base).should_not be_true
+    end
+  end
+
+  describe "serialization" do
+    it "should do a simple hash roundtrip" do
+      h = Rule.daily(5).to_hash
+      restore = Rule.from_hash(h)
+
+      restore.class.should == DailyRule
+      restore.interval.should == 5
+      restore.step.should == 5.days
+    end
+
+    it "should do a hash roundtrip with count" do
+      h = Rule.daily.count(10).to_hash
+      restore = Rule.from_hash(h)
+
+      restore.count.should == 10
+    end
+
+    it "should do a hash roundtrip with stop" do
+      h = Rule.daily.stop(Time.local(2020, 10, 10)).to_hash
+      restore = Rule.from_hash(h)
+
+      restore.stop.should == Time.local(2020, 10, 10)
+    end
+  end
+end