icalendar-recurrence 0.0.1

data/lib/icalendar/recurrence/version.rb

@@ -0,0 +1,5 @@
+module Icalendar
+  module Recurrence
+    VERSION = "0.0.1"
+  end
+end

data/lib/icalendar/recurrence/weekday_extensions.rb

@@ -0,0 +1,13 @@
+module Icalendar
+  module Recurrence
+    module WeekdayExtensions
+      attr_accessor :day, :position
+    end
+  end
+
+  class RRule
+    class Weekday
+      include Icalendar::Recurrence::WeekdayExtensions
+    end
+  end
+end

data/spec/lib/recurrence_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+describe "Event#occurrences_between" do
+  let(:start_time) { event.start_time }
+
+  context "event repeating daily" do
+    let(:event) { example_event :daily } # has exclusion on Jan 28th
+    it "properly calculates recurrence, including exclusion date" do
+      occurrences = event.occurrences_between(start_time, start_time + 2.days)
+
+      expect(occurrences.length).to eq(2)
+      expect(occurrences.first.start_time).to eq(Time.parse("2014-01-27"))
+      expect(occurrences.last.start_time).to eq(Time.parse("2014-01-29"))
+    end
+  end
+
+  context "event repeating every other day" do
+    let(:event) { example_event :every_other_day }
+
+    it "occurs 3 times over 6 days" do
+      occurrences = event.occurrences_between(start_time, start_time + 5.days)
+
+      expect(occurrences.length).to eq(3)
+      expect(occurrences[0].start_time).to eq(Time.parse("2014-01-27"))
+      expect(occurrences[1].start_time).to eq(Time.parse("2014-01-29"))
+      expect(occurrences[2].start_time).to eq(Time.parse("2014-01-31"))
+    end
+  end
+
+  context "event repeating every monday" do
+    let(:event) { example_event :every_monday }
+
+    it "occurs twice over 8 days" do
+      occurrences = event.occurrences_between(start_time, start_time + 8.days)
+
+      expect(occurrences.length).to eq(2)
+      expect(occurrences[0].start_time).to eq(Time.parse("2014-02-03 16:00:00 -0800"))
+      expect(occurrences[1].start_time).to eq(Time.parse("2014-02-10 16:00:00 -0800"))
+    end
+  end
+
+  context "event repeating on Mon, Wed, Fri" do
+    let(:event) { example_event :multi_day_weekly }
+
+    it "occurs 3 times over 7 days" do
+      occurrences = event.occurrences_between(start_time, start_time + 7.days)
+
+      expect(occurrences.length).to eq(3)
+      expect(occurrences[0].start_time).to eq(Time.parse("2014-02-03 16:00:00 -0800"))
+      expect(occurrences[1].start_time).to eq(Time.parse("2014-02-05 16:00:00 -0800"))
+      expect(occurrences[2].start_time).to eq(Time.parse("2014-02-07 16:00:00 -0800"))
+    end
+  end
+
+  context "event repeating bimonthly (DST example)" do
+    let(:event) { example_event :on_third_every_two_months }
+    
+    it "occurs twice over 60 days" do
+      occurrences = event.occurrences_between(start_time, start_time + 60.days)
+
+      expect(occurrences.length).to eq(2)
+      expect(occurrences[0].start_time).to eq(Time.parse("2014-02-03 16:00:00 -0800"))
+      expect(occurrences[1].start_time).to eq(Time.parse("2014-04-03 16:00:00 -0700"))
+    end
+  end
+
+  context "event repeating yearly" do
+    let(:event) { example_event :first_of_every_year }
+
+    it "occurs twice over 366 days" do
+      occurrences = event.occurrences_between(start_time, start_time + 365.days)
+
+      expect(occurrences.length).to eq(2)
+      expect(occurrences[0].start_time).to eq(Time.parse("2014-01-01"))
+      expect(occurrences[1].start_time).to eq(Time.parse("2015-01-01"))
+    end
+  end
+
+  context "event repeating Mon-Fri" do
+    let(:event) { example_event :every_weekday_daily }
+
+    it "occurrs 10 times over two weeks" do
+      occurrences = event.occurrences_between(start_time, start_time + 13.days)
+      
+      expect(occurrences.length).to eq(10)
+      expect(occurrences.map(&:start_time)).to include(Time.parse("2014-01-10"))
+      expect(occurrences.map(&:start_time)).to_not include(Time.parse("2014-01-11"))
+    end
+  end
+
+  context "event repeating daily until January 18th" do
+    let(:event) { example_event :monday_until_friday }
+
+    it "occurs from start date until specified 'until' date" do
+      occurrences = event.occurrences_between(start_time, start_time + 30.days)
+
+      expected_start_times = [
+        Time.parse("2014-01-15 at 12pm").force_zone("America/Los_Angeles").utc,
+        Time.parse("2014-01-18 at 12pm").force_zone("America/Los_Angeles").utc
+      ]
+
+      expect(occurrences.length).to eq(5)
+      expect(occurrences.map(&:start_time)).to include(expected_start_times[0])
+      expect(occurrences.map(&:start_time)).to_not include(expected_start_times[1])
+    end
+  end
+
+  context "event repeating daily with occurrence count of 4" do
+    let(:event) { example_event :everyday_for_four_days }
+
+    it "occurs 4 times then stops" do
+      occurrences = event.occurrences_between(start_time, start_time + 365.days)
+      expect(occurrences.length).to eq(4)
+      expect(occurrences.map(&:start_time)).to include(Time.parse("2014-01-15 at 12pm").force_zone("America/Los_Angeles").utc)
+      expect(occurrences.map(&:start_time)).to_not include(Time.parse("2014-01-17 at 12pm").force_zone("America/Los_Angeles").utc)
+    end
+  end
+
+  context "event repeating on first saturday of month event" do
+    let(:event) { example_event :first_saturday_of_month }
+    
+    it "occurs twice over two months" do
+      occurrences = event.occurrences_between(start_time, start_time + 55.days)
+
+      expected_start_times = [
+        Time.parse("2014-01-04 at 12am").force_zone("America/Los_Angeles"),
+        Time.parse("2014-02-01 at 12am").force_zone("America/Los_Angeles"),
+      ]
+
+      expect(occurrences.length).to eq(2)
+      expect(occurrences[0].start_time).to eq(expected_start_times[0])
+      expect(occurrences[1].start_time).to eq(expected_start_times[1])
+    end
+  end
+
+  context "event repeating once a month for three months" do
+    let(:event) { example_event :one_day_a_month_for_three_months }
+
+    it "only occurs twice when we look for occurrences after the first one" do
+      occurrences = event.occurrences_between(start_time + 30.days, start_time + 90.days)
+
+      expect(occurrences.length).to eq(2)
+    end
+  end
+
+  context "event in UTC time" do
+    let(:event) { example_event :utc }
+
+    it "occurs at the correct time" do
+      occurrences = event.occurrences_between(Time.parse("2014-01-01"), Time.parse("2014-02-01"))
+      expect(occurrences.first.start_time).to eq(Time.parse("20140114T180000Z"))
+    end
+  end
+end

data/spec/lib/schedule_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Icalendar::Recurrence::Schedule do
+  describe "#transform_byday_to_hash" do
+    it "returns an array of days when no monthly interval is set" do
+      byday = ["MO", "WE", "FR"]
+      schedule = Schedule.new(nil)
+      expect(schedule.transform_byday_to_hash(byday)).to eq([:monday, :wednesday, :friday])
+    end
+
+    it "returns hash with day of week and interval" do
+      byday = ["1SA"]
+      schedule = Schedule.new(nil);
+      expect(schedule.transform_byday_to_hash(byday)).to eq({saturday: [1]})
+    end
+  end
+
+  describe "#occurrences_between" do
+    let(:example_occurrence) do
+      daily_event = example_event :daily
+      schedule = Schedule.new(daily_event)
+      schedule.occurrences_between(Date.parse("2014-02-01"), Date.parse("2014-03-01")).first
+    end
+
+    it "returns object that responds to start_time and end_time" do
+      expect(example_occurrence).to respond_to :start_time
+      expect(example_occurrence).to respond_to :end_time
+    end
+
+    context "timezoned event" do
+      let(:example_occurrence) do
+        timezoned_event = example_event :first_saturday_of_month
+        schedule = Schedule.new(timezoned_event)
+        example_occurrence = schedule.occurrences_between(Date.parse("2014-02-01"), Date.parse("2014-03-01")).first
+      end
+
+      it "#occurrences_between return object that responds to #start_time and #end_time (timezoned example)" do
+        expect(example_occurrence).to respond_to :start_time
+        expect(example_occurrence).to respond_to :end_time
+      end
+    end
+  end
+
+  describe "#parse_ical_byday" do
+    let(:schedule) { Schedule.new(nil) }
+
+    it "returns a hash of data" do
+      expect(schedule.parse_ical_byday("1SA")).to eq({day_code: "SA", position: 1})
+      expect(schedule.parse_ical_byday("MO")).to eq({day_code: "MO", position: 0})
+    end
+  end
+end

data/spec/lib/time_util_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe TimeUtil do
+  describe ".datetime_to_time" do
+    it "converts DateTime to Time correctly" do
+      datetime = Icalendar::Values::DateTime.new(DateTime.parse("2014-01-27T12:55:21-08:00"))
+      correct_time = Time.parse("2014-01-27T12:55:21-08:00")
+      expect(TimeUtil.datetime_to_time(datetime)).to eq(correct_time)
+    end
+
+    it "converts UTC datetime to time with no offset" do
+      utc_datetime = Icalendar::Values::DateTime.new(DateTime.parse("20140114T180000Z"))
+      expect(TimeUtil.datetime_to_time(utc_datetime).utc_offset).to eq(0)
+    end
+
+    it "converts PST datetime to time with 8 hour offset" do
+      pst_datetime = Icalendar::Values::DateTime.new(DateTime.parse("2014-01-27T12:55:21-08:00"))
+      expect(TimeUtil.datetime_to_time(pst_datetime).utc_offset).to eq(-8*60*60)
+    end
+  end
+
+  describe ".to_time" do
+    it "uses specified timezone ID offset while converting to a Time object" do
+      utc_midnight = DateTime.parse("2014-01-27T12:00:00+00:00")
+      pst_midnight =     Time.parse("2014-01-27T12:00:00-08:00")
+
+      zoned_datetime = Icalendar::Values::DateTime.new(utc_midnight, "tzid" => "America/Los_Angeles")
+      
+      expect(TimeUtil.to_time(zoned_datetime)).to eq(pst_midnight)
+    end
+
+    it "parses a string" do
+      expect(TimeUtil.to_time("20140118T075959Z")).to eq(Time.parse("20140118T075959Z"))
+    end
+  end
+
+  describe ".date_to_time" do
+    it "converts date to time object in local time" do
+      local_time = Time.parse("2014-01-01")
+      expect(TimeUtil.date_to_time(Date.parse("2014-01-01"))).to eq(local_time)
+    end
+  end
+
+  describe "timezone_offset" do
+    # Avoid DST changes by freezing time
+    before { Timecop.freeze("2014-01-01") }
+    after  { Timecop.return }
+
+    it "calculates negative offset" do
+      expect(TimeUtil.timezone_offset("America/Los_Angeles")).to eq("-08:00")
+    end
+
+    it "calculates positive offset" do
+      expect(TimeUtil.timezone_offset("Europe/Amsterdam")).to eq("+01:00")
+    end
+
+    it "handles UTC zone" do
+      expect(TimeUtil.timezone_offset("GMT")).to eq("+00:00")
+    end
+
+    it "returns nil when given an unknown timezone" do
+      expect(TimeUtil.timezone_offset("Foo/Bar")).to eq(nil)      
+    end
+
+    it "removes quotes from given TZID" do
+      expect(TimeUtil.timezone_offset("\"America/Los_Angeles\"")).to eq("-08:00")
+    end
+
+    it "uses first element from array when given" do
+      expect(TimeUtil.timezone_offset(["America/Los_Angeles"])).to eq("-08:00")
+    end
+
+    it "returns nil when given nil" do
+      expect(TimeUtil.timezone_offset(nil)).to eq(nil)
+    end
+
+    it "calculates offset at a given moment" do
+      after_daylight_savings = Date.parse("2014-05-01")
+      expect(TimeUtil.timezone_offset("America/Los_Angeles", moment: after_daylight_savings)).to eq("-07:00")
+    end
+
+    it "handles daylight savings" do
+      # FYI, clocks turn forward an hour on Nov 2 at 9:00:00 UTC
+      minute_before_clocks_change = Time.parse("Nov 2 at 08:59:00 UTC") # on west coast
+      minute_after_clocks_change = Time.parse("Nov 2 at 09:01:00 UTC") # on west coast
+
+      expect(TimeUtil.timezone_offset("America/Los_Angeles", moment: minute_before_clocks_change)).to eq("-07:00")
+      expect(TimeUtil.timezone_offset("America/Los_Angeles", moment: minute_after_clocks_change)).to eq("-08:00")
+    end
+  end
+
+  describe ".force_zone" do
+    it "replaces the exist offset with the offset from a named zone" do
+      eight_am_utc = Time.parse("20140101T0800Z")
+      forced_time = TimeUtil.force_zone(eight_am_utc, "America/Los_Angeles")
+      expect(forced_time.utc.to_s).to eq("2014-01-01 16:00:00 UTC")
+    end
+
+    context "when forced timezone is different than original" do
+      it "changes the moment in time the object refers to" do
+        eight_am_utc = Time.parse("20140101T0800Z")
+        forced_time = TimeUtil.force_zone(eight_am_utc, "America/Los_Angeles")
+        expect(forced_time.to_i).to_not eq(eight_am_utc.to_i)
+      end
+    end
+
+    it "works for non-UTC time" do
+      eight_am_local = Time.parse("2014-01-01 08:00")
+      forced_time = TimeUtil.force_zone(eight_am_local, "Asia/Hong_Kong")
+      expect(forced_time.utc.to_s).to eq("2014-01-01 00:00:00 UTC")
+    end
+
+    context "when given an unknown TZID" do
+      it "raises an error" do
+        expect {
+          TimeUtil.force_zone(Time.now, "Foo/Bar")
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    it "works with this example" do
+      forced_time = Time.parse("2014-01-04 at 4pm").force_zone("America/Los_Angeles")
+      expect(forced_time.hour).to eq(16)
+    end
+
+    it "extends Time" do
+      forced_time = Time.parse("2014-01-01 at 8am").force_zone("Asia/Hong_Kong")
+      expect(forced_time.utc.to_s).to eq("2014-01-01 00:00:00 UTC")
+    end
+
+    it "doesn't change passed in time objects to UTC" do
+      eight_am_local = Time.parse("2014-01-01 08:00")
+      TimeUtil.force_zone(eight_am_local, "Asia/Hong_Kong")
+      expect(eight_am_local.utc?).to eq(false)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'support/helpers'
+require 'timecop'
+
+require 'icalendar/recurrence'
+
+include Icalendar::Recurrence
+include Helpers
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+end

data/spec/support/fixtures/daily_event.ics

@@ -0,0 +1,30 @@
+BEGIN:VCALENDAR
+X-WR-CALNAME:Test Public
+X-WR-CALID:f512e378-050c-4366-809a-ef471ce45b09:101165
+PRODID:Zimbra-Calendar-Provider
+VERSION:2.0
+METHOD:PUBLISH
+BEGIN:VEVENT
+UID:efcb99ae-d540-419c-91fa-42cc2bd9d302
+RRULE:FREQ=DAILY;INTERVAL=1
+SUMMARY:Every day, except the 28th
+X-ALT-DESC;FMTTYPE=text/html:<html><body></body></html>
+ORGANIZER;CN=Jordan Raine:mailto:foo@sfu.ca
+DTSTART;VALUE=DATE:20140127
+DTEND;VALUE=DATE:20140128
+STATUS:CONFIRMED
+CLASS:PUBLIC
+X-MICROSOFT-CDO-ALLDAYEVENT:TRUE
+X-MICROSOFT-CDO-INTENDEDSTATUS:FREE
+TRANSP:TRANSPARENT
+LAST-MODIFIED:20140113T200625Z
+DTSTAMP:20140113T200625Z
+SEQUENCE:0
+EXDATE;VALUE=DATE:20140128
+BEGIN:VALARM
+ACTION:DISPLAY
+TRIGGER;RELATED=START:-PT5M
+DESCRIPTION:Reminder
+END:VALARM
+END:VEVENT
+END:VCALENDAR

data/spec/support/fixtures/embedded_timezone_event.ics

@@ -0,0 +1,36 @@
+BEGIN:VCALENDAR
+X-WR-CALNAME:Calendar
+X-WR-CALID:19234061-9654-4990-a740-64ad6ed79058:10
+PRODID:Zimbra-Calendar-Provider
+VERSION:2.0
+METHOD:PUBLISH
+BEGIN:VTIMEZONE
+TZID:GMT-08.00/-07.00
+BEGIN:STANDARD
+DTSTART:19710101T010000
+TZOFFSETTO:-0800
+TZOFFSETFROM:-0700
+RRULE:FREQ=YEARLY;INTERVAL=1;BYMONTH=11;BYDAY=1SU;WKST=MO
+END:STANDARD
+BEGIN:DAYLIGHT
+DTSTART:19710101T030000
+TZOFFSETTO:-0700
+TZOFFSETFROM:-0800
+RRULE:FREQ=YEARLY;INTERVAL=1;BYMONTH=3;BYDAY=2SU;WKST=MO
+END:DAYLIGHT
+END:VTIMEZONE
+BEGIN:VEVENT
+UID:7690678C7CBC43EB82AC1E63580D39A30
+SUMMARY:Event using embedded timezone
+PRIORITY:0
+DTSTART;TZID="GMT-08.00/-07.00":20131222T120000
+DTEND;TZID="GMT-08.00/-07.00":20131222T200000
+STATUS:CONFIRMED
+CLASS:PUBLIC
+X-MICROSOFT-CDO-INTENDEDSTATUS:BUSY
+TRANSP:OPAQUE
+LAST-MODIFIED:20131211T204108Z
+DTSTAMP:20131211T204108Z
+SEQUENCE:0
+END:VEVENT
+END:VCALENDAR