rubyredrick-ri_cal 0.0.2

data/lib/ri_cal/property_value/recurrence_rule/recurring_day.rb

@@ -0,0 +1,132 @@
+module RiCal
+  class PropertyValue
+    class RecurrenceRule < PropertyValue
+      #- ©2009 Rick DeNatale
+      #- All rights reserved. Refer to the file README.txt for the license
+      #
+      # Instances of RecurringDay are used to represent values in BYDAY recurrence rule parts
+      #
+      class RecurringDay # :nodoc: 
+        
+        attr_reader :wday, :index, :rrule
+
+        DayNames = %w{SU MO TU WE TH FR SA} unless defined? DayNames
+        day_nums = {}
+        unless defined? DayNums
+          DayNames.each_with_index { |name, i| day_nums[name] = i }
+          DayNums = day_nums
+        end
+
+        attr_reader :source, :scope
+        def initialize(source, rrule, scope = :monthly)
+          @source = source
+          @rrule = rrule
+          @scope = scope
+          wd_match = source.match(/([+-]?\d*)(SU|MO|TU|WE|TH|FR|SA)/)
+          if wd_match
+            @day, @ordinal = wd_match[2], wd_match[1]
+            @wday = DayNums[@day]
+            @index = (@ordinal == "") ? nil : @ordinal.to_i
+          end
+        end
+
+        def valid?
+          !@day.nil?
+        end
+
+        def ==(another)
+          self.class === another && to_a = another.to_a
+        end
+
+        def to_a
+          [@day, @ordinal]
+        end
+        
+        # return a list id for a given time to allow the enumerator to cache lists
+        def list_id(time)
+          case @scope
+          when :yearly
+            time.year
+          when :monthly
+            (time.year * 100) + time.month
+          when :weekly
+            time.at_start_of_week_with_wkst(rrule.wkst_day).jd
+          end
+        end
+        
+        # return a list of times which match the time parameter within the scope of the RecurringDay
+        def matches_for(time)
+          case @scope
+          when :yearly
+            yearly_matches_for(time)
+          when :monthly
+            monthly_matches_for(time)
+          when :weekly
+            weekly_matches_for(time)
+          else
+            walkback = caller.grep(/recurrence/i)
+            raise "Logic error!#{@scope.inspect}\n  #{walkback.join("\n  ")}"
+          end         
+        end
+        
+        def yearly_matches_for(time)
+          if @ordinal == ""
+            t = time.nth_wday_in_year(1, wday)
+            result = []
+            year = time.year
+            while t.year == year
+              result << t
+              t = t.advance(:week => 1)
+            end
+            result
+          else
+            [time.nth_wday_in_year(@ordinal.to_i, wday)]
+          end
+        end
+        
+        def monthly_matches_for(time)
+          if @ordinal == ""
+            t = time.nth_wday_in_month(1, wday)
+            result = []
+            month = time.month
+            while t.month == month
+              result << t
+              t = t.advance(:days => 7)
+            end
+            result
+          else
+            result = [time.nth_wday_in_month(index, wday)]
+            result
+          end
+        end
+
+        def weekly_matches_for(time)
+          date = time.start_of_week_with_wkst(rrule.wkst_day)
+          date += 1 while date.wday != wday
+          [time.change(:year => date.year, :month => date.month, :day => date.day)]
+        end
+
+        def to_s
+          "#{@ordinal}#{@day}"
+        end
+        
+        def ordinal_match(date_or_time)
+          if @ordinal == "" || @scope == :weekly
+            true
+          else
+            if @scope == :yearly
+              date_or_time.nth_wday_in_year?(index, wday) 
+            else
+              date_or_time.nth_wday_in_month?(index, wday)
+            end
+          end
+        end
+
+        # Determine if a particular date, time, or date_time is included in the recurrence
+        def include?(date_or_time)
+          date_or_time.wday == wday && ordinal_match(date_or_time)
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/recurrence_rule/recurring_month_day.rb

@@ -0,0 +1,61 @@
+module RiCal
+  class PropertyValue
+    class RecurrenceRule < PropertyValue
+      #- ©2009 Rick DeNatale
+      #- All rights reserved. Refer to the file README.txt for the license
+      #
+      # Instances of RecurringMonthDay represent BYMONTHDAY parts in recurrence rules
+      class RecurringMonthDay < NumberedSpan # :nodoc:
+
+        def last
+          31
+        end
+        
+        # return a list id for a given time to allow the enumerator to cache lists
+        def list_id(time)
+          time.month
+        end
+ 
+        # return a list of times which match the time parameter within the scope of the RecurringDay
+        def matches_for(time)
+          [time.change(:day => 1).advance(:days => target_for(time)- 1)]
+        end
+        
+        # return a list id for a given time to allow the enumerator to cache lists
+        def list_id(time)
+          time.month
+        end
+ 
+        # return a list of times which match the time parameter within the scope of the RecurringDay
+        def matches_for(time)
+          [time.change(:day => 1).advance(:days => target_for(time)- 1)]
+        end
+        
+        def target_date_time_for(date_time)
+          matches_for(date_time)[0]
+        end
+
+        # return a list of times which match the time parameter within the scope of the RecurringDay
+        def matches_for(time)
+          [time.change(:day => 1).advance(:days => target_for(time)- 1)]
+        end
+
+        def target_date_time_for(date_time)
+          matches_for(date_time)[0]
+        end
+
+        def target_for(date_or_time)
+          if @source > 0
+            @source
+          else
+            date_or_time.days_in_month + @source + 1
+          end
+        end
+
+        def include?(date_or_time)
+          date_or_time.mday == target_for(date_or_time)
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/recurrence_rule/recurring_numbered_week.rb

@@ -0,0 +1,34 @@
+module RiCal
+  class PropertyValue
+    class RecurrenceRule < PropertyValue
+      #- ©2009 Rick DeNatale
+      #- All rights reserved. Refer to the file README.txt for the license
+      #
+      class RecurringNumberedWeek < NumberedSpan # :nodoc:
+        def last
+          53
+        end
+         
+        def rule_wkst
+          @rule && rule.wkst_day
+        end
+        
+        def default_wkst
+          rule_wkst || 1
+        end
+        
+        def adjusted_iso_weeknum(date_or_time)
+          if @source > 0
+            @source
+          else
+            date_or_time.iso_weeks_in_year(wkst) + @source + 1
+          end
+        end
+        
+        def include?(date_or_time, wkst=default_wkst)
+          date_or_time.iso_week_num(wkst) == adjusted_iso_weeknum(date_or_time)
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/recurrence_rule/recurring_year_day.rb

@@ -0,0 +1,50 @@
+module RiCal
+  class PropertyValue
+    class RecurrenceRule < PropertyValue
+      #- ©2009 Rick DeNatale
+      #- All rights reserved. Refer to the file README.txt for the license
+      #
+      class RecurringYearDay < NumberedSpan # :nodoc:
+
+        def last
+          366
+        end
+
+        def leap_year?(year)
+          year % 4 == 0 && (year % 400 == 0 || year % 100 != 0)
+        end 
+
+
+        def length_of_year(year)
+          leap_year?(year) ? 366 : 365
+        end 
+        
+        # return a list id for a given time to allow the enumerator to cache lists
+        def list_id(time)
+          time.year
+        end
+
+        # return a list of times which match the time parameter within the scope of the RecurringDay
+        def matches_for(time)
+          [time.change(:month => 1, :day => 1).advance(:days => target_for(time)- 1)]
+        end
+        
+        def target_date_time_for(date_time)
+          matches_for(date_time)[0]
+        end
+
+        def target_for(date_or_time)
+          if @source > 0
+            @source
+          else
+            length_of_year(date_or_time.year) + @source + 1
+          end
+        end
+        
+        def include?(date_or_time)
+          date_or_time.yday == target_for(date_or_time)
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/recurrence_rule/validations.rb

@@ -0,0 +1,126 @@
+module RiCal
+  class PropertyValue
+    class RecurrenceRule < PropertyValue
+      #- ©2009 Rick DeNatale
+      #- All rights reserved. Refer to the file README.txt for the license
+      #
+      module Validations #:nodoc:
+        # Validate that the parameters of the reciever conform to RFC 2445
+        # If errors are found they will be added to the receivers errors
+        #
+        # Whenever any of the parameters are set, e.g. with:
+        #    recurrence_rule.count = 2
+        # the errors will be reset
+        def valid?
+          validate if @errors.nil?
+          errors.empty?
+        end
+
+        # Return any errors found during validation
+        # See #valid?
+        def errors
+          @errors ||= []
+        end
+
+        def reset_errors # :nodoc:
+          @errors = nil
+        end
+
+        # Used by #valid? to validate that the parameters of the reciever conform to RFC 2445
+        # If errors are found they will be added to the receivers errors
+        #
+        # Whenever any of the parameters are set, e.g. with:
+        #    recurrence_rule.count = 2
+        # the errors will be reset
+        def validate
+          @errors = []
+          validate_termination
+          validate_freq
+          validate_interval
+          validate_int_by_list(:bysecond, (0..59))
+          validate_int_by_list(:byminute, (0..59))
+          validate_int_by_list(:byhour, (0..23))
+          validate_int_by_list(:bymonth, (1..12))
+          validate_bysetpos
+          validate_byday_list
+          validate_bymonthday_list
+          validate_byyearday_list
+          validate_byweekno_list
+          validate_wkst
+        end
+
+        def validate_termination
+          errors << "COUNT and UNTIL cannot both be specified" if @count && @until
+        end
+
+        def validate_freq
+          if @freq
+            unless %w{
+              SECONDLY MINUTELY HOURLY DAILY
+              WEEKLY MONTHLY YEARLY
+              }.include?(@freq.upcase)
+              errors <<  "Invalid frequency '#{@freq}'"
+            end
+          else
+            errors << "RecurrenceRule must have a value for FREQ"
+          end
+        end
+
+        def validate_interval
+          if @interval
+            errors << "interval must be a positive integer" unless @interval > 0
+          end
+        end
+
+        def validate_wkst
+          errors << "#{wkst.inspect} is invalid for wkst" unless %w{MO TU WE TH FR SA SU}.include?(wkst)
+        end
+
+        def validate_int_by_list(which, test)
+          vals = by_list[which] || []
+          vals.each do |val|
+            errors << "#{val} is invalid for #{which}" unless test === val
+          end
+        end
+
+        def validate_bysetpos
+          vals = by_list[:bysetpos] || []
+          vals.each do |val|
+            errors << "#{val} is invalid for bysetpos" unless (-366..-1) === val  || (1..366) === val
+          end
+          unless vals.empty?
+            errors << "bysetpos cannot be used without another by_xxx rule part" unless by_list.length > 1
+          end
+        end
+
+        def validate_byday_list
+          days = by_list[:byday] || []
+          days.each do |day|
+            errors << "#{day.source.inspect} is not a valid day" unless day.valid?
+          end
+        end
+
+        def validate_bymonthday_list
+          days = by_list[:bymonthday] || []
+          days.each do |day|
+            errors << "#{day.source.inspect} is not a valid month day" unless day.valid?
+          end
+        end
+
+        def validate_byyearday_list
+          days = by_list[:byyearday] || []
+          days.each do |day|
+            errors << "#{day.source.inspect} is not a valid year day" unless day.valid?
+          end
+        end
+
+        def validate_byweekno_list
+          days = by_list[:byweekno] || []
+          days.each do |day|
+            errors << "#{day.source.inspect} is not a valid week number" unless day.valid?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/recurrence_rule.rb

@@ -0,0 +1,146 @@
+Dir[File.dirname(__FILE__) + "/recurrence_rule/*.rb"].sort.each do |path|
+  require path
+end
+
+module RiCal
+  class PropertyValue
+    #- ©2009 Rick DeNatale
+    #- All rights reserved. Refer to the file README.txt for the license
+    #
+    # RiCal::PropertyValue::RecurrenceRule represents an icalendar Recurrence Rule property value
+    # which is defined in 
+    # rfc 2445 section 4.3.10 pp 40-45
+    class RecurrenceRule < PropertyValue
+      
+      def initialize(parent, value_hash) # :nodoc:
+        @by_list_hash = {}
+        super
+        init_by_lists
+        @by_list_hash = nil
+      end
+      
+      def self.convert(parent, value) #:nodoc:
+        if String === value
+          result = new(parent, :value => value)
+        else
+          result = new(parent, value)
+        end
+        result
+      end
+      
+      include Validations
+      include InitializationMethods
+      include EnumerationSupportMethods
+
+      # The integer count value of the receiver, or nil
+      attr_reader :count
+      # The DATE-TIME value of until limit of the receiver, or nil
+      attr_reader :until
+
+      def value=(string) # :nodoc:
+        if string
+          @value = string
+          dup_hash = {}
+          string.split(";").each do |value_part|
+            initialize_from_value_part(value_part, dup_hash)
+          end
+        end
+      end
+
+      # Set the frequency of the recurrence rule
+      # freq_value:: a String which should be in %w[SECONDLY MINUTELY HOURLY DAILY WEEKLY MONTHLY YEARLY]
+      # 
+      # This method resets the receivers list of errors
+      def freq=(freq_value)
+        reset_errors
+        @freq = freq_value
+      end
+
+      # return the frequency of the rule which will be a string 
+      def freq
+        @freq.upcase
+      end
+
+      # return the starting week day for the recurrence rule, which for a valid instance will be one of
+      # "SU", "MO", "TU", "WE", "TH", "FR", or "SA"
+      def wkst
+        @wkst || 'MO'
+      end
+
+      def wkst_day # :nodoc:
+        @wkst_day ||= (%w{SU MO TU WE FR SA}.index(wkst) || 1)
+      end
+
+      # Set the starting week day for the recurrence rule, which should  be one of
+      # "SU", "MO", "TU", "WE", "TH", "FR", or "SA" for the instance to be valid.
+      # The parameter is however case-insensitive.
+      # 
+      # This method resets the receivers list of errors
+      def wkst=(value)
+        reset_errors
+        @wkst = value
+        @wkst_day = nil
+      end
+
+      # Set the count parameter of the recurrence rule, the count value will be converted to an integer using to_i
+      # 
+      # This method resets the receivers list of errors
+      
+      def count=(count_value)
+        reset_errors
+        @count = count_value
+        @until = nil unless @count.nil? || @by_list_hash
+      end
+
+      # Set the until parameter of the recurrence rule
+      #
+      # until_value:: the value to be set, this may be either a string in RFC 2446 Date or DateTime value format
+      # Or a Date, Time, DateTime, RiCal::PropertyValue::Date, or RiCal::PropertyValue::DateTime
+      #
+      def until=(until_value)
+        reset_errors
+        @until = until_value && until_value.to_ri_cal_date_or_date_time_value
+        @count = nil unless @count.nil? || @by_list_hash
+      end
+
+      # return the INTERVAL parameter of the recurrence rule
+      # This returns an Integer
+      def interval
+        @interval ||= 1
+      end
+
+      # Set the INTERVAL parameter of the recurrence rule
+      #
+      # interval_value:: an Integer
+      #
+      # This method resets the receivers list of errors
+      def interval=(interval_value)
+        reset_errors
+        @interval = interval_value
+      end
+      
+      def value
+        @value || to_ical
+      end      
+
+      # Return a string containing the RFC 2445 representation of the recurrence rule
+      def to_ical
+        result = ["FREQ=#{freq}"]
+        result << "INTERVAL=#{interval}" unless interval == 1
+        result << "COUNT=#{count}" if count
+        result << "UNTIL=#{self.until.value}" if self.until
+        %w{bysecond byminute byhour byday bymonthday byyearday byweekno bymonth bysetpos}.each do |by_part|
+          val = by_list[by_part.to_sym]
+          result << "#{by_part.upcase}=#{[val].flatten.join(',')}" if val
+        end
+        result << "WKST=#{wkst}" unless wkst == "MO"
+        result.join(";")
+      end
+      
+      # Predicate to determine if the receiver generates a bounded or infinite set of occurrences
+      def bounded?
+        @count || @until
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/text.rb

@@ -0,0 +1,41 @@
+module RiCal
+  class PropertyValue
+    #- ©2009 Rick DeNatale
+    #- All rights reserved. Refer to the file README.txt for the license
+    #
+    # RiCal::PropertyValue::Text represents an icalendar Text property value
+    # which is defined in 
+    # rfc 2445 section 4.3.11 pp 45-46
+    class Text < PropertyValue
+      
+      # Return the string value of the receiver
+      def ruby_value
+        if value
+          value.gsub(/\\[;,nN\\]/) {|match|
+            case match[1,1]
+            when /[,;\\]/
+              match[1,1]
+            when 'n', 'N'
+              "\n"
+            else
+              match
+            end
+          }
+        else
+          nil
+        end
+      end
+      
+      def self.convert(parent, string) #:nodoc:
+        ical_str = string.gsub(/\n|,|;/) {|match|
+          if match == "\n"
+            '\n'
+          else
+            "\\#{match}"
+          end
+          }
+        self.new(parent, :value => ical_str)
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/uri.rb

@@ -0,0 +1,12 @@
+module RiCal
+  class PropertyValue
+    #- ©2009 Rick DeNatale
+    #- All rights reserved. Refer to the file README.txt for the license
+    #
+    # RiCal::PropertyValue::Uri represents an icalendar Uri property value
+    # which is defined in 
+    # rfc 2445 section 4.8.4.6 p 110
+    class Uri < PropertyValue
+    end
+  end
+end

data/lib/ri_cal/property_value/utc_offset.rb

@@ -0,0 +1,34 @@
+module RiCal
+  class PropertyValue
+    #- ©2009 Rick DeNatale
+    #- All rights reserved. Refer to the file README.txt for the license
+    #
+    class UtcOffset < PropertyValue # :nodoc:
+      attr_accessor :sign, :hours, :minutes, :seconds
+
+      def value=(string)
+        @value = string
+        parse_match = /([+-])(\d\d)(\d\d)(\d\d)?/.match(string)
+        if parse_match
+          @sign = parse_match[1] == "+" ? 1 : -1
+          @hours = parse_match[2].to_i
+          @minutes = parse_match[3].to_i
+          @seconds = parse_match[4].to_i || 0
+        end
+      end
+      
+      def to_seconds
+        @sign * ((((hours*60) + minutes) * 60) + seconds)
+      end
+      
+      def add_to_date_time_value(date_time_value)
+        date_time_value.advance(:hours => sign * hours, :minutes => sign * minutes, :seconds => sign * minutes)
+      end
+      
+      def subtract_from_date_time_value(date_time_value)
+        signum = -1 * sign
+        date_time_value.advance(:hours => signum * hours, :minutes => signum * minutes, :seconds => signum * minutes)
+      end
+    end
+  end
+end