dgp-schedule_attributes 0.4.0

data/spec/schedule_attributes/rule_parser/month_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'ice_cube'
+require 'schedule_attributes/rule_parser'
+require 'schedule_attributes/input'
+
+describe ScheduleAttributes::RuleParser::Month do
+
+  describe "#rule" do
+    let(:input)  { ScheduleAttributes::Input.new(RSpec.current_example.metadata[:args]) }
+    let(:parser) { described_class.new(input) }
+    subject      { parser.rule }
+
+    let(:t) { Date.current }
+    let(:n) { (t-14 >> 1).change(day: 14) }
+
+    let(:monthly)    { [t, t >> 1, t >> 2, t >> 3].map(&:to_time) }
+    let(:bimonthly)  { [t, t >> 2, t >> 4, t >> 6].map(&:to_time) }
+    let(:every_14th) { [n, n >> 1, n >> 2, n >> 3].map(&:to_time) }
+
+    context 'no arguments', args: {} do
+      it { should == IceCube::Rule.monthly }
+      its_occurrences_until(3.months.from_now) { should == monthly }
+    end
+
+    context 'start_date and interval arguments', args: {"start_date" => "2000-03-14", "interval" => "2"} do
+      it { should == IceCube::Rule.monthly(2) }
+      its_occurrences_until(6.months.from_now) { should == bimonthly }
+    end
+
+    context 'ordinal_unit and ordinal_day arguments', args: {"ordinal_unit" => "day", "ordinal_day" => "14"} do
+      it { should == IceCube::Rule.monthly.day_of_month(14) }
+      its_occurrences_until(4.months.from_now) { should == every_14th }
+    end
+
+    context 'ordinal_unit, ordinal_week and tuesday arguments', args: {"ordinal_unit" => "week", "ordinal_week" => "2", "tuesday" => "1"} do
+      it { should == IceCube::Rule.monthly.day_of_week(:tuesday => [2]) }
+    end
+
+    context 'ordinal_unit and ordinal_week arguments', args: {"ordinal_unit" => "week", "ordinal_week" => "2"} do
+      it { should == IceCube::Rule.monthly.day_of_week(0=>(w=[2]), 1=>w, 2=>w, 3=>w, 4=>w, 5=>w, 6=>w) }
+    end
+
+    context 'start_date and end_date arguments', args: {"start_date" => "2000-03-14", "end_date" => "2000-06-14"} do
+      it { should == IceCube::Rule.monthly.until(Time.new(2000,6,14)) }
+    end
+  end
+end

data/spec/schedule_attributes/rule_parser/week_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'ice_cube'
+require 'schedule_attributes/rule_parser'
+require 'schedule_attributes/input'
+
+describe ScheduleAttributes::RuleParser::Week do
+  let(:t)   { Date.current.to_time }
+  let(:sun) { (Date.current - Date.current.cwday.days).to_time + 1.week }
+  let(:mon) { sun + 1.day }
+  let(:sat) { sun - 1.day }
+
+  let(:weekly)        { [t, t+1.week, t+2.weeks, t+3.weeks, t+4.weeks, t+5.weeks] }
+  let(:every_2_weeks) { [t, t+2.week, t+4.weeks]}
+  let(:weekends)      { [sat, sun, sat+1.week, sun+1.week, sat+2.weeks, sun+2.weeks] }
+
+  describe "#rule" do
+    let(:input)  { ScheduleAttributes::Input.new(RSpec.current_example.metadata[:args]) }
+    let(:parser) { described_class.new(input) }
+    subject      { parser.rule }
+
+    context 'no arguments', args: {} do
+      it { should == IceCube::Rule.weekly }
+      its_occurrences_until(5.weeks.from_now) { should == weekly }
+    end
+
+    context 'interval argument', args: {"interval" => "2"} do
+      it { should == IceCube::Rule.weekly(2) }
+      its_occurrences_until(5.weeks.from_now) { should == every_2_weeks }
+    end
+
+    context 'several day name arguments', args: {"monday" => "0", "saturday" => "1", "sunday" => "1"} do
+      it { should == IceCube::Rule.weekly.day(0,6) }
+      its_occurrences_until(Date.today.beginning_of_week+3.weeks) { subject[-4..-1].should == weekends[-4..-1] }
+    end
+  end
+end

data/spec/schedule_attributes/rule_parser/year_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'ice_cube'
+require 'schedule_attributes/rule_parser'
+require 'schedule_attributes/input'
+
+describe ScheduleAttributes::RuleParser::Year do
+  let(:t) { Date.today }
+  let(:n) { Date.new(Date.current.year,3,14) }
+
+  let(:every_year)     { [t, t>>12, t>>24, t>>36, t>>48].map(&:to_time) }
+  let(:every_2nd_year) { [t, t>>24, t>>48].map(&:to_time) }
+  let(:every_pi_day)   { [n, n>>12, n>>24, n>>36, n>>48].tap{ |a| a.shift if t.yday > n.yday }.map(&:to_time) }
+
+  describe "#rule" do
+    let(:input)  { ScheduleAttributes::Input.new(RSpec.current_example.metadata[:args]) }
+    let(:parser) { described_class.new(input) }
+    subject      { parser.rule }
+
+    context 'no arguments', args: {} do
+      it { should == IceCube::Rule.yearly }
+      its_occurrences_until(4.years.from_now) { should == every_year }
+    end
+
+    context 'interval argument', args: {"interval" => "2"} do
+      it { should == IceCube::Rule.yearly(2) }
+      its_occurrences_until(4.years.from_now) { should == every_2nd_year }
+    end
+
+    context 'start_date argument', args: {"start_date" => "2000-03-14"} do
+      it { should == IceCube::Rule.yearly.month_of_year(3).day_of_month(14) }
+    end
+
+    context 'start_date argument alt', args: {"start_date" => "2000-01-30"} do
+      it { should == IceCube::Rule.yearly.month_of_year(1).day_of_month(30) }
+    end
+
+    context 'start_date and end_date arguments', args: {"start_date" => "2000-03-14", "end_date" => "#{Date.current.year+4}-03-14"} do
+      it { should == IceCube::Rule.yearly.month_of_year(3).day_of_month(14).until(Date.new(Date.current.year+4,3,14).to_time) }
+      its_occurrences_until(10.years.from_now) { should == every_pi_day }
+    end
+
+    context "ignoring yearly_start and end limits", args: {
+      "start_date"             => "2000-03-14",
+      "yearly_start_month"     => "4",
+      "yearly_start_month_day" => "15",
+      "yearly_end_month"       => "5",
+      "yearly_end_month_day"   => "20"
+    } do
+      it { should == IceCube::Rule.yearly.month_of_year(3).day_of_month(14) }
+      its_occurrences_until(Date.new(Date.current.year+4,12,31)) { should == every_pi_day }
+    end
+  end
+end

data/spec/schedule_attributes/rule_parser_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'schedule_attributes/rule_parser'
+
+describe ScheduleAttributes::RuleParser do
+  describe "class methods" do
+    {
+      "day" => ScheduleAttributes::RuleParser::Day,
+      "week" => ScheduleAttributes::RuleParser::Week,
+      "month" => ScheduleAttributes::RuleParser::Month,
+      "year" => ScheduleAttributes::RuleParser::Year
+    }. each do |key,parser_class|
+
+      it "returns parser for #{key} interval units" do
+        ScheduleAttributes::RuleParser[key].should == parser_class
+      end
+    end
+  end
+end

data/spec/schedule_attributes/time_helpers_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'schedule_attributes/time_helpers'
+require 'active_support/time_with_zone'
+
+describe ScheduleAttributes::TimeHelpers do
+  describe '.parse_in_zone' do
+
+    context "with time zone" do
+      before { Time.zone = 'UTC' }
+
+      it "returns a time from a date string" do
+        subject.parse_in_zone("2000-12-31").should == Time.zone.parse("2000-12-31")
+      end
+
+      it "returns a time from a time" do
+        local_offset = "-08:00"
+        local_time = Time.new(2000,12,31,0,0,0,local_offset)
+        subject.parse_in_zone(local_time).should == Time.zone.parse("2000-12-31 08:00:00")
+      end
+
+      it "returns a time from a date" do
+        subject.parse_in_zone(Date.new(2000,12,31)).should == Time.zone.parse("2000-12-31")
+      end
+    end
+
+    context "without ActiveSupport" do
+      before { Time.zone = nil }
+
+      it "returns a time from a date string" do
+        subject.parse_in_zone("2000-12-31").should == Time.parse("2000-12-31")
+      end
+
+      it "returns a time from a time" do
+        subject.parse_in_zone(Time.new(2000,12,31)).should == Time.parse("2000-12-31")
+      end
+    end
+
+  end
+end

data/spec/schedule_attributes_spec.rb

@@ -0,0 +1,226 @@
+require 'spec_helper'
+require 'support/scheduled_model'
+
+describe ScheduledModel do
+
+  describe "#schedule" do
+    subject(:schedule) { ScheduledModel.new.schedule }
+
+    it "should default to a daily schedule" do
+      schedule.should be_a(IceCube::Schedule)
+      schedule.rtimes.should == []
+      schedule.start_time.should == Date.today.to_time
+      schedule.end_time.should be nil
+      schedule.rrules.should == [IceCube::Rule.daily]
+    end
+  end
+
+  describe "#schedule_attributes=" do
+    describe "setting the correct schedule" do
+      let(:scheduled_model) { ScheduledModel.new.tap { |m| m.schedule_attributes = RSpec.current_example.metadata[:args] } }
+      subject(:schedule)    { scheduled_model.schedule }
+
+      context args: {repeat: '0', date: '1-1-1985', interval: '5 (ignore this)'} do
+        it { subject.start_time.should == Time.new(1985,1,1) }
+        it { subject.all_occurrences.should == [Time.new(1985,1,1)] }
+        it { subject.rrules.should be_blank }
+      end
+
+      context args: {repeat: '0', dates: ['1-1-1985', '31-12-1985'], interval: '5 (ignore this)'} do
+        it { subject.start_time.should == Time.new(1985,1,1) }
+        it { subject.all_occurrences.should == [Time.new(1985,1,1), Time.new(1985,12,31)] }
+        it { subject.rrules.should be_blank }
+      end
+
+      context args: {repeat: '0', dates: ['1-1-1985', '31-12-1985'], start_time: '12:00', end_time: '14:00', interval: '5 (ignore this)'} do
+        it      { subject.start_time.should == Time.new(1985,1,1,12,0) }
+        it      { subject.duration.should == 7200 }
+        it      { subject.all_occurrences.should == [Time.new(1985,1,1,12,0), Time.new(1985,12,31,12,0)] }
+        it      { subject.rrules.should be_blank }
+        specify { schedule.occurring_between?(helpers.parse_in_zone('1985-1-1 12:00'), helpers.parse_in_zone('1985-6-25 14:00')).should be_truthy }
+        specify { schedule.occurs_at?(helpers.parse_in_zone('1985-1-1 12:00')).should be_truthy }
+        specify { schedule.occurs_at?(helpers.parse_in_zone('1985-6-6 15:00')).should be_falsey }
+      end
+
+      context args: {repeat: '1'} do
+        it { subject.start_time.should == Date.today.to_time }
+        it { subject.rrules.should == [IceCube::Rule.daily] }
+      end
+
+      context args: {repeat: '1', start_date: '1-1-1985', interval_unit: 'day', interval: '3'} do
+        it      { subject.start_time.should == Date.new(1985,1,1).to_time }
+        it      { subject.rrules.should == [IceCube::Rule.daily(3)] }
+        specify  { schedule.first(3).should == [Date.civil(1985,1,1), Date.civil(1985,1,4), Date.civil(1985,1,7)].map(&:to_time) }
+      end
+
+      context args: {repeat: "1", start_date: "1-1-1985", interval_unit: "day", interval: "3", end_date: "29-12-1985", ends: "eventually"} do
+        it { subject.start_time.should == Date.new(1985,1,1).to_time }
+        # Rails 4.1 removes Date.current.to_time_in_current_zone in favour of Date.in_time_zone
+        it do
+          if Date.current.respond_to?(:in_time_zone)
+            subject.rrules.should == [ IceCube::Rule.daily(3).until(Date.new(1985,12,29).in_time_zone) ]
+          else
+            subject.rrules.should == [ IceCube::Rule.daily(3).until(Date.new(1985,12,29).to_time_in_current_zone) ]
+          end
+        end
+        specify { schedule.first(3).should == [Date.civil(1985,1,1), Date.civil(1985,1,4), Date.civil(1985,1,7)].map(&:to_time) }
+      end
+
+      context args: {repeat: '1', start_date: '1-1-1985', interval_unit: 'day', interval: '3', until_date: '29-12-1985', ends: 'never'} do
+        it      { subject.start_time.should == Date.new(1985,1,1).to_time }
+        it      { subject.rrules.should == [IceCube::Rule.daily(3)] }
+        specify { schedule.first(3).should == [Date.civil(1985,1,1), Date.civil(1985,1,4), Date.civil(1985,1,7)].map(&:to_time) }
+      end
+
+      context args: {repeat: '1', start_date: '1-1-1985', interval_unit: 'week', interval: '3', monday: '1', wednesday: '1', friday: '1'} do
+        it      { subject.start_time.should == Date.new(1985,1,1).to_time }
+        it      { subject.rrules.should == [IceCube::Rule.weekly(3).day(:monday, :wednesday, :friday)] }
+        specify { schedule.occurs_at?(helpers.parse_in_zone('1985-1-2')).should be_truthy }
+        specify { schedule.occurs_at?(helpers.parse_in_zone('1985-1-4')).should be_truthy }
+        specify { schedule.occurs_at?(helpers.parse_in_zone('1985-1-7')).should be_falsey }
+        specify { schedule.occurs_at?(helpers.parse_in_zone('1985-1-21')).should be_truthy }
+      end
+
+      context args: {repeat: '1', start_date: '1-1-1985', interval_unit: 'day'} do
+        it { subject.rrules.should == [IceCube::Rule.daily(1)] }
+      end
+
+      context args: {repeat: '1', start_date: '1-1-1985', interval_unit: 'year'} do
+        it      { subject.start_time.should == Date.new(1985,1,1).to_time }
+        it      { subject.rrules.should == [IceCube::Rule.yearly.day_of_month(1).month_of_year(1)] }
+        specify { schedule.first(3).should == [Date.civil(1985,1,1), Date.civil(1986,1,1), Date.civil(1987,1,1)].map(&:to_time) }
+      end
+
+      context args: {repeat: '1', interval_unit: 'day', start_date: '2012-09-27', yearly_start_month: '12', yearly_start_month_day: '1', yearly_end_month: '4', yearly_end_month_day: '21'} do
+        it { subject.start_time.should == Time.new(2012,9,27) }
+        it { subject.rrules.should == [IceCube::Rule.daily.month_of_year(12,1,2,3,4)] }
+        it { subject.exrules.should == [IceCube::Rule.daily.month_of_year(4).day_of_month(*22..31)] }
+      end
+
+      context "all_day", pending: "Work in progress"
+    end
+
+    describe "setting the schedule field", args: {repeat: '1', start_date: '1-1-1985', interval_unit: 'day', interval: '3'} do
+      let(:scheduled_model) { ScheduledModel.new.tap { |m| m.schedule_attributes = RSpec.current_example.metadata[:args] } }
+      subject               { scheduled_model }
+
+      it { subject.schedule.should == IceCube::Schedule.new(Date.new(1985,1,1).to_time).tap { |s| s.add_recurrence_rule IceCube::Rule.daily(3) }  }
+    end
+
+  end
+
+  describe "schedule_attributes" do
+    let(:scheduled_model) { ScheduledModel.new }
+    let(:schedule)        { IceCube::Schedule.new(Date.tomorrow.to_time) }
+    subject               { scheduled_model.schedule_attributes }
+    before                { scheduled_model.stub(schedule: schedule) }
+
+    context "for a single date" do
+      before { schedule.add_recurrence_time(Date.tomorrow.to_time) }
+      it     { should == OpenStruct.new(repeat: 0, interval: 1, date: Date.tomorrow, dates: [Date.tomorrow], start_date: Date.today, all_day: true) }
+      it     { subject.date.should be_a(Date) }
+    end
+
+    context "when it repeats daily" do
+      before do
+        schedule.add_recurrence_rule(IceCube::Rule.daily(4))
+      end
+      it { should == OpenStruct.new(repeat: 1, start_date: Date.tomorrow, interval_unit: 'day', interval: 4, ends: 'never', date: Date.today, all_day: true) }
+      it { subject.start_date.should be_a(Date) }
+    end
+
+    context "when it repeats with an end date" do
+      before do
+        schedule.add_recurrence_rule(IceCube::Rule.daily(4).until((Date.today+10).to_time))
+      end
+      it { should == OpenStruct.new(repeat: 1, start_date: Date.tomorrow, interval_unit: 'day', interval: 4, ends: 'eventually', end_date: Date.today+10, date: Date.today, all_day: true) }
+      it { subject.start_date.should be_a(Date) }
+      it { subject.end_date.should be_a(Date) }
+    end
+
+    context "when it repeats weekly" do
+      before do
+        schedule.add_recurrence_time(Date.tomorrow)
+        schedule.add_recurrence_rule(IceCube::Rule.weekly(4).day(:monday, :wednesday, :friday))
+      end
+      it do
+        should == OpenStruct.new(
+          :repeat        => 1,
+          :start_date    => Date.tomorrow,
+          :interval_unit => 'week',
+          :interval      => 4,
+          :ends          => 'never',
+          :monday        => 1,
+          :wednesday     => 1,
+          :friday        => 1,
+          :all_day       => true,
+
+          :date          => Date.today #for the form
+        )
+      end
+    end
+
+    context "when it repeats yearly" do
+      before do
+        schedule.add_recurrence_time(Date.tomorrow)
+        schedule.add_recurrence_rule(IceCube::Rule.yearly)
+      end
+      it do
+        should == OpenStruct.new(
+          :repeat        => 1,
+          :start_date    => Date.tomorrow,
+          :interval_unit => 'year',
+          :interval      => 1,
+          :ends          => 'never',
+          :all_day       => true,
+
+          :date          => Date.today #for the form
+        )
+      end
+    end
+
+    context "when it has yearly date range" do
+      it "should have yearly start and end months" do
+        schedule.add_recurrence_rule(IceCube::Rule.daily.month_of_year(12,1,2))
+
+        subject.yearly_start_month.should == 12
+        subject.yearly_end_month.should == 2
+      end
+
+      it "should have a yearly start date" do
+        schedule.add_recurrence_rule(IceCube::Rule.daily.month_of_year(11,12,1,2))
+        schedule.add_exception_rule(IceCube::Rule.daily.month_of_year(11).day_of_month(*1..6))
+
+        subject.yearly_start_month.should == 11
+        subject.yearly_start_month_day.should == 7
+      end
+
+      it "should have a yearly end date" do
+        schedule.add_recurrence_rule(IceCube::Rule.daily.month_of_year(1,2,3))
+        schedule.add_exception_rule(IceCube::Rule.daily.month_of_year(3).day_of_month(*26..31))
+
+        subject.yearly_end_month.should == 3
+        subject.yearly_end_month_day.should == 25
+      end
+
+      it "should have no yearly start day for months only" do
+        schedule.add_recurrence_rule(IceCube::Rule.daily.month_of_year(1,2,3))
+
+        subject.yearly_start_month_day.should be_nil
+      end
+
+      it "should have a yearly start day on the first when end day is set" do
+        schedule.add_recurrence_rule(IceCube::Rule.daily.month_of_year(1,2,3))
+        schedule.add_exception_rule(IceCube::Rule.daily.month_of_year(3).day_of_month(*26..31))
+
+        subject.yearly_start_month_day.should == 1
+      end
+    end
+
+    context "all_day", pending: "Work in progress"
+  end
+
+  def helpers
+    ScheduleAttributes::TimeHelpers
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'active_support'
+require 'ostruct'
+require 'pry'
+require 'support/parser_macros'
+
+$: << File.expand_path('../lib')
+
+RSpec.configure do |config|
+  config.include SpecHelpers::ParserMacros
+  config.expect_with :rspec
+end

data/spec/support/parser_macros.rb

@@ -0,0 +1,31 @@
+module SpecHelpers
+  def input_for(klass, args = nil)
+    klass.new(args)
+  end
+
+  module ParserMacros
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def its_occurrences_until(date, &block)
+        describe "occurrences" do
+          shared_examples 'occurrences' do
+
+            orig_subject = subject
+
+            self.class.class_eval do
+              define_method(:subject) do
+                schedule = IceCube::Schedule.new(Date.today.to_time)
+                schedule.add_recurrence_rule(orig_subject)
+                @_subject = schedule.occurrences(date)
+              end
+            end
+
+            yield
+          end
+        end
+      end
+    end
+
+  end
+end