texel-recurrence-rule-parser 0.0.4 → 0.0.5

data/README.txt

@@ -1,6 +1,6 @@
 = RruleParser
 
-* FIX (url)
+http://www.github.com/texel/recurrence-rule-parser
 
 == DESCRIPTION:
 
@@ -10,18 +10,35 @@ and handles translating recurrence rules into temporal expressions.
 == FEATURES/PROBLEMS:
 
 Current list of supported expressions:
-FREQ
-INTERVAL
-BYDAY
+FREQ, INTERVAL, BYDAY, BYMONTHDAY, UNTIL
+
+Many values are still unimplemented.
 
 == SYNOPSIS:
 
-  code samples forthcoming.
+RruleParser should be able to consume any object acting like Icalendar::Event, containing
+recurrence rules as specified by the iCalendar (RFC 2445) specification. For more information
+on formatting of recurrence rules, visit http://www.kanzaki.com/docs/ical/rrule.html
+
+== EXAMPLES:
+
+  event       = Icalendar::Event.new
+  event.start = Time.parse('12/1/2008 3pm')
+  event.end   = Time.parse('12/1/2008 6pm')
+  
+  event.recurrence_rules = ["FREQ=WEEKLY;INTERVAL=1;COUNT=10"] 
+  
+  parser      = RruleParser.new(event)
+  date_range  = Date.parse('11/30/2008')..Date.parse('1/1/2009')
+  
+  parser.dates(date_range)
+  
+  #=> [Mon, 01 Dec 2008, Mon, 08 Dec 2008, Mon, 15 Dec 2008, Mon, 22 Dec 2008, Mon, 29 Dec 2008]
 
 == REQUIREMENTS:
 
-requires Runt and Icalendar.
-requires RSpec if you wish to run the specs.
+requires Runt.
+requires Icalendar and RSpec if you wish to run the specs.
 
 == INSTALL:
 

data/lib/rrule_parser.rb

@@ -1,5 +1,5 @@
+require 'rubygems'
 require 'runt'
-require 'icalendar'
 
 class RruleParser
   VERSION = '1.0.0'
@@ -38,7 +38,7 @@ class RruleParser
   def expressions        
     @expressions = []
     @expressions << parse_frequency_and_interval
-    @expressions << parse_byday
+    @expressions << send(:"parse_#{self.rules[:freq].downcase}")
     @expressions << parse_start
     @expressions << parse_until
     @expressions.compact!
@@ -51,15 +51,22 @@ class RruleParser
   
   # Accepts a range of dates and outputs an array of dates matching the temporal expression.
   def dates(range)
+    dates = []
+    
     if @count <= 0
-      self.expression.dates(range)
+      dates << self.expression.dates(range)
     else
-      temp_range = self.event.start.to_date..(range.last)
+      temp_range = (self.event.start.send :to_date)..(range.last)
       temp_dates = self.expression.dates(temp_range, @count)
-      temp_dates.select do |date|
+      dates << temp_dates.select do |date|
         range.include?(date)
       end
     end
+  
+    # TODO put original date back in if recurrence rule doesn't define it.
+    start_date = self.event.start.send(:to_date)
+    dates << start_date if range.include?(start_date)
+    dates.flatten.uniq
   end
   
   protected
@@ -83,7 +90,7 @@ class RruleParser
   end
   
   def parse_start
-    start_date = Date.civil(self.event.start.year, self.event.start.month, self.event.start.day - 1)
+    start_date = Date.civil(self.event.start.year, self.event.start.month, self.event.start.day) - 1
     Runt::AfterTE.new(start_date)
   end
   
@@ -95,13 +102,53 @@ class RruleParser
     end
   end
   
-  # Currently only supports days of the week (MO, TU, WED, etc.) 
-  def parse_byday
+  def parse_daily
+    return
+  end
+  
+  def parse_weekly
+    if self.rules[:byday]
+      self.rules[:byday].map { |day| parse_byday(day) }.inject do |m, expr|
+        m | expr
+      end
+    else
+      # Make the event recur on the day of the original event.
+      Runt::DIWeek.new(self.event.start.wday)
+    end
+  end
+  
+  def parse_monthly
     if self.rules[:byday]
-      self.rules[:byday].map{ |day| Runt::DIWeek.new(RruleParser::DAYS[day]) }.inject do |m, expr|
+      self.rules[:byday].map do |day_string|
+        parse_byday(day_string)
+      end.inject {|m, expr| m | expr}
+    elsif self.rules[:bymonthday]
+      self.rules[:bymonthday].map { |day| Runt::REMonth.new(day.to_i) }.inject do |m, expr|
+        m | expr
+      end
+    else
+      Runt::REMonth.new(self.event.start.day, self.event.start.day)
+    end
+  end
+  
+  def parse_yearly
+    expressions = []
+
+    if self.rules[:bymonth]
+      expressions << self.rules[:bymonth].map { |month| Runt::REYear.new(month.to_i) }.inject do |m, expr|
         m | expr
       end
+    else
+      expressions << Runt::REYear.new(self.event.start.month)
+    end
+    
+    if self.rules[:byday]
+      expressions << self.rules[:byday].map { |day_string| parse_byday(day_string) }.inject {|m, v| m | v}
+    else
+      expressions << Runt::REMonth.new(self.event.start.day)
     end
+    
+    expressions.inject {|m, expr| m & expr}
   end
   
   def parse_until
@@ -113,4 +160,15 @@ class RruleParser
   def parse_count
     @count = self.rules[:count].to_i if self.rules[:count]
   end
+  
+  def parse_byday(day_string)
+    # BYDAY rules can be in one of two formats: 2TU (2nd Tuesday), or TU (every Tuesday)
+    if day_string =~ /\d/
+      day_index         = day_string.to_i
+      day               = DAYS[day_string.gsub(day_index.to_s, '')] # Why is abbreviation such a long word?
+      Runt::DIMonth.new(day_index, day)
+    else
+      Runt::DIWeek.new(RruleParser::DAYS[day_string])
+    end
+  end
 end

data/spec/lib/rrule_parser_spec.rb

@@ -1,5 +1,7 @@
 require 'lib/rrule_parser'
 require 'icalendar'
+require 'spec'
+require 'redgreen'
 
 module RruleParserSpecHelper
   def create_default_event
@@ -12,6 +14,12 @@ module RruleParserSpecHelper
     @event.recurrence_rules = ["FREQ=#{@frequency};INTERVAL=#{@interval};BYDAY=#{@byday};WKST=SU"]
   end
   
+  def create_event
+    @event = Icalendar::Event.new
+  end
+  
+  # TODO Make other test objects for shared specs :)
+  
   def create_parser(event)
     @parser = RruleParser.new(event)
   end
@@ -76,7 +84,7 @@ describe RruleParser do
       @result = @parser.send(:parse_frequency_and_interval)
     end
     
-    it "return a valid temporal expression" do
+    it "returns a valid temporal expression" do
       @result.should be_an_instance_of(Runt::EveryTE)
     end
     
@@ -88,4 +96,210 @@ describe RruleParser do
       @result.instance_variable_get("@precision").should == Runt::DPrecision.const_get(RruleParser::ADVERB_MAP[@frequency])
     end
   end
+  
+  describe "#dates" do
+    context "with an event starting on Monday, 12/1/2008" do
+      before(:each) do
+        create_event
+        @event.start = Time.parse('12/1/2008 3pm')
+        @event.end   = Time.parse('12/1/2008 5pm')
+      end
+      
+      context "with a one-month range" do
+        before(:each) do
+          @range = (Date.civil(2008, 12, 1)..(Date.civil(2009, 1, 1)))
+        end
+        
+        context "recurring every week" do
+          before(:each) do
+            @event.recurrence_rules = ['FREQ=WEEKLY;INTERVAL=1']
+            @range = (Date.civil(2008, 12, 1)..(Date.civil(2009, 1, 1)))
+            create_parser(@event)
+          end
+
+          it "should return 5 dates" do
+            @parser.dates(@range).size.should == 5
+          end
+
+          it "should return only Monday dates" do
+            @parser.dates(@range).map {|d| d.wday == Runt::Monday }.all?.should be_true
+          end
+        end
+
+        context "recurring every other week" do
+          before(:each) do
+            @event.recurrence_rules = ['FREQ=WEEKLY;INTERVAL=2']
+            @range = (Date.civil(2008, 12, 1)..(Date.civil(2008, 12, 31)))
+            create_parser(@event)
+          end
+
+          it "should return 3 dates" do
+            @parser.dates(@range).size.should == 3
+          end
+        end
+
+        context "recurring every Monday, Wednesday, and Friday" do
+          before(:each) do
+            @event.recurrence_rules = ['FREQ=WEEKLY;INTERVAL=1;BYDAY=MO,WE,FR']
+            create_parser(@event)
+          end
+
+          it "should return 14 dates" do
+            @parser.dates(@range).size.should == 14
+          end
+
+          it "should return only dates on Monday, Wednesday, and Friday" do
+            @parser.dates(@range).map {|d| [Runt::Mon, Runt::Wed, Runt::Fri].include?(d.wday) }.all?.should be_true
+          end
+        end
+        
+        context "recurring every day" do
+          before(:each) do
+            @event.recurrence_rules = ['FREQ=DAILY;INTERVAL=1']
+            create_parser(@event)
+          end
+
+          it "should return 31 dates" do
+            @parser.dates(@range).size.should == 32
+          end
+        end
+        
+        context "recurring every 2 days" do
+          before(:each) do
+            @event.recurrence_rules = ['FREQ=DAILY;INTERVAL=2']
+            create_parser(@event)
+          end
+
+          it "should return 31 dates" do
+            @parser.dates(@range).size.should == 16
+          end
+        end
+      end
+      
+      context "with a one-year range" do
+        before(:each) do
+          @range = (Date.civil(2008, 12, 1)..(Date.civil(2009, 11, 30)))
+        end
+        
+        context "recurring every month" do
+          before(:each) do
+            @event.recurrence_rules = ['FREQ=MONTHLY;INTERVAL=1']
+            create_parser(@event)
+          end
+          
+          it "should return 12 dates" do
+            @parser.dates(@range).size.should == 12
+          end
+          
+          it "should return only dates on the same day of the month" do
+            @parser.dates(@range).map {|d| d.day == @event.start.day}.all?.should be_true
+          end
+        end
+        
+        context "recurring every two months" do
+          before(:each) do
+            @event.recurrence_rules = ['FREQ=MONTHLY;INTERVAL=2']
+            create_parser(@event)
+          end
+          
+          it "should return 6 dates" do
+            @parser.dates(@range).size.should == 6
+          end
+          
+          it "should return only dates on the same day of the month" do
+            @parser.dates(@range).map {|d| d.day == @event.start.day}.all?.should be_true
+          end
+        end
+        
+        context "recurring the first and fifteenth of every month" do
+          before(:each) do
+            @event.recurrence_rules = ['FREQ=MONTHLY;INTERVAL=1;BYMONTHDAY=1,15']
+            create_parser(@event)
+          end
+          
+          it "should return 24 dates" do
+            @parser.dates(@range).size.should == 24
+          end
+          
+          it "should return dates only on the 1st and 15th of the month" do
+            @parser.dates(@range).map {|d| [1, 15].include?(d.day) }.all?.should be_true
+          end
+        end
+        
+        context "recurring the first Monday of every month" do
+          before(:each) do
+            @event.recurrence_rules = ['FREQ=MONTHLY;INTERVAL=1;BYDAY=1MO']
+            create_parser(@event)          
+          end
+          
+          it "should return 12 dates" do
+            @parser.dates(@range).size.should == 12
+          end
+          
+          it "should return only Mondays" do
+            # Garfield hates this recurrence rule.
+            @parser.dates(@range).map {|d| d.wday == Runt::Monday}.all?.should be_true
+          end
+        end
+      end
+      
+      context "with a five-year range" do
+        before(:each) do
+          @range = (Date.civil(2008, 12, 1)..(Date.civil(2013, 11, 30)))
+        end
+        
+        context "recurring every year" do
+          before do
+            @event.recurrence_rules = ['FREQ=YEARLY;INTERVAL=1']
+            create_parser(@event)
+            @dates = @parser.dates(@range)
+          end
+          
+          it "should return 5 dates" do
+            @dates.size.should == 5
+          end
+          
+          it "should return the correct date each year" do
+            @dates.map do |d| 
+              [:month, :day].map do |method|
+                d.send(method) == @event.start.send(method)
+              end.all?
+            end.all?.should be_true
+          end
+        end
+        
+        context "recurring every other year" do
+          before do
+            @event.recurrence_rules = ['FREQ=YEARLY;INTERVAL=2']
+            create_parser(@event)
+            @dates = @parser.dates(@range)
+          end
+          
+          it "should return 3 dates" do
+            @dates.size.should == 3
+          end
+          
+          it "should return the correct date each year" do
+            @dates.map do |d| 
+              [:month, :day].map do |method|
+                d.send(method) == @event.start.send(method)
+              end.all?
+            end.all?.should be_true
+          end
+        end
+        
+        context "recurring every December and June" do
+          before do
+            @event.recurrence_rules = ['FREQ=YEARLY;INTERVAL=1;BYMONTH=6,12']
+            create_parser(@event)
+            @dates = @parser.dates(@range)
+          end
+          
+          it "should return 10 dates" do
+            @dates.size.should == 10
+          end
+        end
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: texel-recurrence-rule-parser
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors: 
 - Leigh Caplan