micahwedemeyer-ri_cal 0.8.9

data/lib/ri_cal/property_value/recurrence_rule.rb

@@ -0,0 +1,154 @@
+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
+      
+      autoload :EnumerationSupportMethods, "ri_cal/property_value/recurrence_rule/enumeration_support_methods.rb"
+      autoload :OccurrenceIncrementer,     "ri_cal/property_value/recurrence_rule/occurrence_incrementer.rb"
+      autoload :Enumerator, "ri_cal/property_value/recurrence_rule/enumerator.rb"
+      autoload :InitializationMethods, "ri_cal/property_value/recurrence_rule/initialization_methods.rb"
+      autoload :NegativeSetposEnumerator, "ri_cal/property_value/recurrence_rule/negative_setpos_enumerator.rb"
+      autoload :NumberedSpan, "ri_cal/property_value/recurrence_rule/numbered_span.rb"
+      autoload :RecurringDay, "ri_cal/property_value/recurrence_rule/recurring_day.rb"
+      autoload :RecurringMonthDay, "ri_cal/property_value/recurrence_rule/recurring_month_day.rb"
+      autoload :RecurringNumberedWeek, "ri_cal/property_value/recurrence_rule/recurring_numbered_week.rb"
+      autoload :RecurringYearDay, "ri_cal/property_value/recurrence_rule/recurring_year_day.rb"
+      autoload :TimeManipulation, "ri_cal/property_value/recurrence_rule/time_manipulation.rb"
+      autoload :Validations, "ri_cal/property_value/recurrence_rule/validations.rb"
+      
+      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(timezone_finder)
+        @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 #:nodoc:
+        @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,44 @@
+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 to_ri_cal_text_property
+        self
+      end
+      
+      def self.convert(parent, string) #:nodoc:
+        ical_str = string.gsub(/\n\r?|\r\n?|,|;|\\/) {|match|
+          if ["\n", "\r", "\n\r", "\r\n"].include?(match)
+            '\\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,11 @@
+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,33 @@
+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

data/lib/ri_cal/property_value/zulu_date_time.rb

@@ -0,0 +1,34 @@
+require 'date'
+module RiCal
+  class PropertyValue
+    #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+    #
+    # RiCal::PropertyValue::CalAddress represents an icalendar CalAddress property value
+    # which is defined in RFC 2445 section 4.3.5 pp 35-37
+    class ZuluDateTime < PropertyValue::DateTime
+      
+      def tzid
+        "UTC"
+      end
+
+      def value=(val) # :nodoc:
+        if DateTime === val
+          @date_time_value = val
+        else
+          super(val)
+        end
+        @date_time_value = @date_time_value.utc if @date_time_value
+      end
+      
+      def to_ri_cal_zulu_date_time
+        self
+      end
+      
+      def self.convert(timezone_finder, ruby_object) # :nodoc:
+          result = super
+          result.to_ri_cal_zulu_date_time
+      end
+      
+    end
+  end
+end

data/lib/ri_cal/property_value.rb

@@ -0,0 +1,159 @@
+module RiCal
+  #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+  #
+  # PropertyValue provides common implementation of various RFC 2445 property value types
+  class PropertyValue
+    
+    autoload :Array, "ri_cal/property_value/array.rb"
+    autoload :CalAddress, "ri_cal/property_value/cal_address.rb"
+    autoload :Date, "ri_cal/property_value/date.rb"
+    autoload :DateTime, "ri_cal/property_value/date_time.rb"
+    autoload :Duration, "ri_cal/property_value/duration.rb"
+    autoload :Geo, "ri_cal/property_value/geo.rb"
+    autoload :Integer, "ri_cal/property_value/integer.rb"
+    autoload :OccurrenceList, "ri_cal/property_value/occurrence_list.rb"
+    autoload :Period, "ri_cal/property_value/period.rb"
+    autoload :RecurrenceRule, "ri_cal/property_value/recurrence_rule.rb"
+    autoload :Text, "ri_cal/property_value/text.rb"
+    autoload :Uri, "ri_cal/property_value/uri.rb"
+    autoload :UtcOffset, "ri_cal/property_value/utc_offset.rb"
+    autoload :ZuluDateTime, "ri_cal/property_value/zulu_date_time.rb"
+
+    attr_writer :params, :value #:nodoc:
+    attr_reader :timezone_finder #:nodoc:
+    def initialize(timezone_finder, options={}) # :nodoc:
+      @timezone_finder = timezone_finder
+      validate_value(options)
+      ({:params => {}}).merge(options).each do |attribute, val|
+        unless attribute == :name
+          setter = :"#{attribute.to_s.downcase}="
+          send(setter, val)
+        end
+      end
+    end
+    
+    def self.if_valid_string(timezone_finder, string) #:nodoc:
+      if valid_string?(string)
+        new(timezone_finder, :value => string)
+      else
+        nil
+      end
+    end
+
+    def validate_value(options) #:nodoc:
+      val = options[:value]
+      raise "Invalid property value #{val.inspect}" if val.kind_of?(String) && /^;/.match(val)
+    end
+
+    # return a hash containing the parameters and values, if any
+    def params
+      @params ||= {}
+    end
+
+    def to_options_hash #:nodoc:
+      options_hash = {:value => value}
+      options_hash[:params] = params unless params.empty?
+    end
+    
+    def self.date_or_date_time(timezone_finder, separated_line) # :nodoc:
+      match = separated_line[:value].match(/(\d\d\d\d)(\d\d)(\d\d)((T?)((\d\d)(\d\d)(\d\d))(Z?))?/)
+      raise Exception.new("Invalid date") unless match
+      if match[5] == "T" # date-time
+        time = Time.utc(match[1].to_i, match[2].to_i, match[3].to_i, match[7].to_i, match[8].to_i, match[9].to_i)
+        parms = (separated_line[:params] ||{}).dup
+        if match[10] == "Z"
+          raise Exception.new("Invalid time, cannot combine Zulu with timezone reference") if parms[:tzid]
+          parms['TZID'] = "UTC"
+        end
+        PropertyValue::DateTime.new(timezone_finder, separated_line.merge(:params => parms))
+      else
+        PropertyValue::Date.new(timezone_finder, separated_line)
+      end
+    end
+    
+    def self.date_or_date_time_or_period(timezone_finder, separated_line) #:nodoc:
+      if separated_line[:value].include?("/")
+        PropertyValue::Period.new(timezone_finder, separated_line)
+      else
+        date_or_date_time(timezone_finder, separated_line)
+      end
+    end
+
+    # def self.from_string(string) # :nodoc:
+    #   new(nil, :value => string)
+    # end
+
+    def self.convert(timezone_finder, value) #:nodoc:
+      new(timezone_finder, :value => value)
+    end
+
+    # Determine if another object is equivalent to the receiver.
+    def ==(o)
+      if o.class == self.class
+        equality_value == o.equality_value
+      else
+        super
+      end
+    end
+
+    # Return the string value
+    def value
+      @value
+    end
+
+    def equality_value #:nodoc:
+      value
+    end
+
+    def visible_params # :nodoc:
+      params
+    end
+
+    def parms_string #:nodoc:
+      if (vp = visible_params) && !vp.empty?
+        # We only sort for testability reasons
+        vp.keys.sort.map {|key| ";#{key}=#{vp[key]}"}.join
+      else
+        ""
+      end
+    end
+
+    # Return a string representing the receiver in RFC 2445 format
+    def to_s #:nodoc:
+      "#{parms_string}:#{value}"
+    end
+
+    # return the ruby value
+    def ruby_value
+      self.value
+    end
+
+    def to_ri_cal_property_value #:nodoc:
+      self
+    end
+    
+    def find_timezone(timezone_identifier) #:nodoc:
+      if timezone_finder
+        timezone_finder.find_timezone(timezone_identifier)
+      else
+        raise "Unable to find timezone with tzid #{timezone_identifier}"
+      end
+    end
+    
+    def default_tzid #:nodoc:
+      if timezone_finder
+        timezone_finder.default_tzid
+      else
+        PropertyValue::DateTime.default_tzid
+      end
+    end
+    
+    def tz_info_source? #:nodoc:
+      if timezone_finder
+        timezone_finder.tz_info_source?
+      else
+        true
+      end
+    end
+  end
+end

data/lib/ri_cal/required_timezones.rb

@@ -0,0 +1,55 @@
+module RiCal
+  #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+  #
+  # RequireTimezones collects the timezones used by a given calendar component or set of calendar components
+  # For each timezone we collect it's id, and the earliest and latest times which reference the zone
+  class RequiredTimezones #:nodoc:
+    
+    
+    # A required timezone represents a single timezone and the earliest and latest times which reference it.
+    class RequiredTimezone #:nodoc:
+      
+      attr_reader :first_time, :last_time, :timezone
+      
+      def initialize(tzid)
+        @timezone = RiCal::Component::TZInfoTimezone.new(TZInfo::Timezone.get(tzid))
+      end
+      
+      def tzid
+        @timezone.identifier
+      end
+      
+      def add_datetime(date_time)
+        if @first_time 
+          @first_time = date_time if date_time < @first_time
+        else
+          @first_time = date_time
+        end
+        if @last_time 
+          @last_time = date_time if date_time > @last_time
+        else
+          @last_time = date_time
+        end
+      end
+    end
+    
+    def required_timezones
+      @required_zones ||= {}
+    end
+    
+    def required_zones
+      required_timezones.values
+    end
+    
+    def export_to(export_stream)
+      required_zones.each do |z|
+        tzinfo_timezone =z.timezone
+        tzinfo_timezone.export_local_to(export_stream, z.first_time, z.last_time)
+      end
+    end
+    
+    def add_datetime(date_time, tzid)
+      (required_timezones[tzid] ||= RequiredTimezone.new(tzid)).add_datetime(date_time)
+    end
+  end
+end

data/lib/ri_cal.rb

@@ -0,0 +1,187 @@
+#- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+#
+# The RiCal module provides the outermost namespace, along with several convenience methods for parsing
+# and building calendars and calendar components.
+module RiCal
+  
+  require 'stringio'
+  require 'rational'
+  
+  my_dir =  File.dirname(__FILE__)
+  
+  $LOAD_PATH << my_dir unless $LOAD_PATH.include?(my_dir)
+
+  if Object.const_defined?(:ActiveSupport)
+    as = Object.const_get(:ActiveSupport)
+    if as.const_defined?(:TimeWithZone)
+      time_with_zone = as.const_get(:TimeWithZone)
+    end
+  end
+  
+  # TimeWithZone will be set to ActiveSupport::TimeWithZone if the activesupport gem is loaded
+  # otherwise it will be nil
+  TimeWithZone = time_with_zone  
+  
+  autoload :Component, "ri_cal/component.rb"
+  autoload :CoreExtensions, "ri_cal/core_extensions.rb" 
+  autoload :FastDateTime, "ri_cal/fast_date_time.rb" 
+  autoload :FloatingTimezone, "ri_cal/floating_timezone.rb" 
+  autoload :InvalidPropertyValue, "ri_cal/invalid_property_value.rb" 
+  autoload :InvalidTimezoneIdentifier, "ri_cal/invalid_timezone_identifier.rb" 
+  autoload :OccurrenceEnumerator, "ri_cal/occurrence_enumerator.rb"
+  autoload :OccurrencePeriod, "ri_cal/occurrence_period.rb"
+  autoload :TimezonePeriod, "ri_cal/properties/timezone_period.rb"
+  autoload :Parser, "ri_cal/parser.rb"
+  autoload :Properties, "ri_cal/properties.rb"
+  autoload :PropertyValue, "ri_cal/property_value.rb" 
+  autoload :RequiredTimezones, "ri_cal/required_timezones.rb" 
+  require "ri_cal/core_extensions.rb"
+  # :stopdoc:
+  VERSION = '0.8.5'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to rquire all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+    Dir.glob(search_me).sort.each {|rb|
+      require rb}
+  end
+  
+  # :startdoc:
+  
+  # Parse an io stream and return an array of iCalendar entities.
+  # Normally this will be an array of RiCal::Component::Calendar instances
+  def self.parse(io)
+    Parser.new(io).parse
+  end
+  
+  # Parse a string and return an array of iCalendar entities.
+  # see RiCal.parse
+  def self.parse_string(string)
+    parse(StringIO.new(string))
+  end
+  
+  def self.debug # :nodoc:
+    @debug
+  end
+  
+  def self.debug=(val) # :nodoc:
+    @debug = val
+  end
+ 
+  # return a new Alarm event or todo component.  If a block is provided it will will be executed in
+  # the context of a builder object which can be used to initialize the properties of the 
+  # new Alarm.  
+  def self.Alarm(&init_block)
+    Component::Alarm.new(&init_block)
+  end
+  
+  # return a new Calendar.  If a block is provided it will will be executed in
+  # the context of a builder object which can be used to initialize the properties and components of the 
+  # new calendar.  
+  def self.Calendar(&init_block)
+    Component::Calendar.new(&init_block)
+  end
+
+  # return a new Event calendar component.  If a block is provided it will will be executed in
+  # the context of a builder object which can be used to initialize the properties and alarms of the 
+  # new Event.  
+  def self.Event(&init_block)
+    Component::Event.new(&init_block)
+  end
+
+  # return a new Freebusy calendar component.  If a block is provided it will will be executed in
+  # the context of a builder object which can be used to initialize the properties and components of the 
+  # new Freebusy.  
+  def self.Freebusy(&init_block)
+    Component::Freebusy.new(&init_block)
+  end
+
+  # return a new Journal calendar component.  If a block is provided it will will be executed in
+  # the context of a builder object which can be used to initialize the properties and components of the 
+  # new Event.  
+  def self.Journal(&init_block)
+    Component::Journal.new(&init_block)
+  end
+
+  # return a new Timezone calendar component.  If a block is provided it will will be executed in
+  # the context of a builder object which can be used to initialize the properties and timezone periods of the 
+  # new Timezone.  
+  def self.Timezone(&init_block)
+    Component::Timezone.new(&init_block)
+  end
+
+  # return a new TimezonePeriod timezone component.  If a block is provided it will will be executed in
+  # the context of a builder object which can be used to initialize the properties of the 
+  # new TimezonePeriod.  
+  def self.TimezonePeriod(&init_block)
+    Component::TimezonePeriod.new(&init_block)
+  end
+
+  # return a new Todo calendar component.  If a block is provided it will will be executed in
+  # the context of a builder object which can be used to initialize the properties and alarms of the 
+  # new Todo.  
+  def self.Todo(&init_block)
+    Component::Todo.new(&init_block)
+  end
+  
+  def self.ro_calls=(value)
+    @ro_calls = value
+  end
+  
+  def self.ro_calls
+    @ro_calls ||= 0
+  end
+  
+  def self.ro_misses=(value)
+    @ro_misses = value
+  end
+  
+  def self.ro_misses
+    @ro_misses ||= 0
+  end
+  
+  def self.RationalOffset
+    self.ro_calls += 1
+    @rational_offset ||= Hash.new {|h, seconds|
+      self.ro_misses += 1
+      h[seconds] = Rational(seconds, 86400)}
+  end
+
+end  # module RiCal
+
+(-12..12).each do |hour_offset|
+  RiCal.RationalOffset[hour_offset * 86400]
+end
+
+
+#RiCal.require_all_libs_relative_to(__FILE__)
+# EOF