friflaj_ri_cal 0.9.0

data/docs/incrementers.txt

@@ -0,0 +1,7 @@
+Seconds - Freq="SECONDLY", BYSECOND
+Minutes - Freq="MINUTELY", BYMINUTE
+Hours -   Freq="HOURLY",   BYHOUR
+Days -    Freq="DAILY",    BYDAY, BYMONTHDAY, BYYEARDAY
+Weeks -   Freq="WEEKLY",   BYWEEKNO
+Months -  Freq="MONTHLY",  BYMONTH
+Years -   Freq="YEARLY"

data/docs/test.ics

@@ -0,0 +1,38 @@
+BEGIN:VCALENDAR
+METHOD:PUBLISH
+X-WR-TIMEZONE:America/New_York
+PRODID:-//Apple Inc.//iCal 3.0//EN
+CALSCALE:GREGORIAN
+X-WR-CALNAME:test
+VERSION:2.0
+X-WR-RELCALID:1884C7F8-BC8E-457F-94AC-297871967D5E
+X-APPLE-CALENDAR-COLOR:#2CA10B
+BEGIN:VTIMEZONE
+TZID:US/Eastern
+BEGIN:DAYLIGHT
+TZOFFSETFROM:-0500
+TZOFFSETTO:-0400
+DTSTART:20070311T020000
+RRULE:FREQ=YEARLY;BYMONTH=3;BYDAY=2SU
+TZNAME:EDT
+END:DAYLIGHT
+BEGIN:STANDARD
+TZOFFSETFROM:-0400
+TZOFFSETTO:-0500
+DTSTART:20071104T020000
+RRULE:FREQ=YEARLY;BYMONTH=11;BYDAY=1SU
+TZNAME:EST
+END:STANDARD
+END:VTIMEZONE
+BEGIN:VEVENT
+SEQUENCE:5
+TRANSP:OPAQUE
+UID:00481E53-9258-4EA7-9F8D-947D3041A3F2
+DTSTART;TZID=US/Eastern:20090224T090000
+DTSTAMP:20090225T000908Z
+SUMMARY:Test Event
+CREATED:20090225T000839Z
+DTEND;TZID=US/Eastern:20090224T100000
+RRULE:FREQ=DAILY;INTERVAL=1;UNTIL=20090228T045959Z
+END:VEVENT
+END:VCALENDAR

data/lib/ri_cal.rb

@@ -0,0 +1,184 @@
+# 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:
+  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

data/lib/ri_cal/component.rb

@@ -0,0 +1,254 @@
+module RiCal
+  class Component #:nodoc:
+
+    autoload :Alarm, "ri_cal/component/alarm.rb"
+    autoload :Calendar, "ri_cal/component/calendar.rb"
+    autoload :Event, "ri_cal/component/event.rb"
+    autoload :Freebusy, "ri_cal/component/freebusy.rb"
+    autoload :Journal, "ri_cal/component/journal.rb"
+    autoload :NonStandard, "ri_cal/component/non_standard.rb"
+    autoload :TZInfoTimezone, "ri_cal/component/t_z_info_timezone.rb"
+    autoload :Timezone, "ri_cal/component/timezone.rb"
+    autoload :Todo, "ri_cal/component/todo.rb"
+
+    class ComponentBuilder #:nodoc:
+      def initialize(component)
+        @component = component
+      end
+
+      def method_missing(selector, *args, &init_block) #:nodoc:
+        if(sub_comp_class = @component.subcomponent_class[selector])
+          if init_block
+            sub_comp = sub_comp_class.new(@component)
+            if init_block.arity == 1
+              yield ComponentBuilder.new(sub_comp)
+            else
+              ComponentBuilder.new(sub_comp).instance_eval(&init_block)
+            end
+            self.add_subcomponent(sub_comp)
+          end
+        else
+          sel = selector.to_s
+          sel = "#{sel}=" unless /(^(add_)|(remove_))|(=$)/ =~ sel
+          if @component.respond_to?(sel)
+            @component.send(sel, *args)
+          else
+            super
+          end
+        end
+      end
+    end
+
+    attr_accessor :imported #:nodoc:
+
+    def initialize(parent=nil, entity_name = nil, &init_block) #:nodoc:
+      @parent = parent
+      if block_given?
+        if init_block.arity == 1
+          init_block.call(ComponentBuilder.new(self))
+        else
+          ComponentBuilder.new(self).instance_eval(&init_block)
+        end
+      end
+    end
+
+    def default_tzid #:nodoc:
+      if @parent
+        @parent.default_tzid
+      else
+        PropertyValue::DateTime.default_tzid
+      end
+    end
+
+    def find_timezone(identifier) #:nodoc:
+      if @parent
+        @parent.find_timezone(identifier)
+      else
+        begin
+          Calendar::TZInfoWrapper.new(TZInfo::Timezone.get(identifier), self)
+        rescue ::TZInfo::InvalidTimezoneIdentifier => ex
+          raise RiCal::InvalidTimezoneIdentifier.invalid_tzinfo_identifier(identifier)
+        end
+      end
+    end
+
+    def tz_info_source?
+      if @parent
+        @parent.tz_info_source?
+      else
+        true
+      end
+    end
+
+    def time_zone_for(ruby_object) #:nodoc:
+      @parent.time_zone_for(ruby_object) #:nodoc:
+    end
+
+    def subcomponent_class #:nodoc:
+      {}
+    end
+
+    def self.from_parser(parser, parent, entity_name) #:nodoc:
+      entity = self.new(parent, entity_name)
+      entity.imported = true
+      line = parser.next_separated_line
+      while parser.still_in(entity_name, line)
+        entity.process_line(parser, line)
+        line = parser.next_separated_line
+      end
+      entity
+    end
+
+    def self.parse(io) #:nodoc:
+      Parser.new(io).parse
+    end
+
+    def imported? #:nodoc:
+      imported
+    end
+
+    def self.parse_string(string) #:nodoc:
+      parse(StringIO.new(string))
+    end
+
+    def subcomponents #:nodoc:
+      @subcomponents ||= Hash.new {|h, k| h[k] = []}
+    end
+
+    def entity_name #:nodoc:
+      self.class.entity_name
+    end
+
+    # return an array of Alarm components within this component :nodoc:
+    # Alarms may be contained within Events, and Todos
+    def alarms
+      subcomponents["VALARM"]
+    end
+
+    def add_subcomponent(component) #:nodoc:
+      subcomponents[component.entity_name] << component
+    end
+
+    def parse_subcomponent(parser, line) #:nodoc:
+      subcomponents[line[:value]] << parser.parse_one(line, self)
+    end
+
+    def process_line(parser, line) #:nodoc:
+      if line[:name] == "BEGIN"
+        parse_subcomponent(parser, line)
+      else
+        setter = self.class.property_parser[line[:name]]
+        if setter
+          send(setter, line)
+        else
+          self.add_x_property(line[:name], PropertyValue::Text.new(self, line))
+        end
+      end
+    end
+
+    # return a hash of any extended properties, (i.e. those with a property name starting with "X-"
+    # representing an extension to the RFC 2445 specification)
+    def x_properties
+      @x_properties ||= Hash.new {|h,k| h[k] = []}
+    end
+
+    # Add a n extended property
+    def add_x_property(name, prop, debug=false)
+      x_properties[name.gsub("_","-").upcase] << prop.to_ri_cal_text_property
+    end
+
+    def method_missing(selector, *args, &b) #:nodoc:
+      xprop_candidate = selector.to_s
+      if (match = /^(x_.+)(=?)$/.match(xprop_candidate))
+        x_property_key = match[1].gsub('_','-').upcase
+        if match[2] == "="
+          args.each do |val|
+            add_x_property(x_property_key, val)
+          end
+        else
+          x_properties[x_property_key].map {|property| property.value}
+        end
+      else
+        super
+      end
+    end
+
+    # Predicate to determine if the component is valid according to RFC 2445
+    def valid?
+      !mutual_exclusion_violation
+    end
+
+    def initialize_copy(original) #:nodoc:
+    end
+
+    def prop_string(prop_name, *properties) #:nodoc:
+      properties = properties.flatten.compact
+      if properties && !properties.empty?
+        properties.map {|prop| "#{prop_name}#{prop.to_s}"}.join("\n")
+      else
+        nil
+      end
+    end
+
+    def add_property_date_times_to(required_timezones, property) #:nodoc:
+      if property
+        if Array === property
+          property.each do |prop|
+            prop.add_date_times_to(required_timezones)
+          end
+        else
+          property.add_date_times_to(required_timezones)
+        end
+      end
+    end
+
+    def export_prop_to(export_stream, name, prop) #:nodoc:
+      if prop
+        string = prop_string(name, prop)
+        export_stream.puts(string) if string
+      end
+    end
+
+    def export_x_properties_to(export_stream) #:nodoc:
+      x_properties.each do |name, props|
+        props.each do | prop |
+          export_stream.puts("#{name}#{prop}")
+        end
+      end
+    end
+
+    def export_subcomponent_to(export_stream, subcomponent) #:nodoc:
+      subcomponent.each do |component|
+        component.export_to(export_stream)
+      end
+    end
+
+    # return a string containing the rfc2445 format of the component
+    def to_s
+      io = StringIO.new
+      export_to(io)
+      io.string
+    end
+
+    # Export this component to an export stream
+    def export_to(export_stream)
+      export_stream.puts("BEGIN:#{entity_name}")
+      export_properties_to(export_stream)
+      export_x_properties_to(export_stream)
+      subcomponents.values.each do |sub|
+        export_subcomponent_to(export_stream, sub)
+      end
+      export_stream.puts("END:#{entity_name}")
+    end
+
+    # Export this single component as an iCalendar component containing only this component and
+    # any required additional components (i.e. VTIMEZONES referenced from this component)
+    # if stream is nil (the default) then this method will return a string,
+    # otherwise stream should be an IO to which the iCalendar file contents will be written
+    def export(stream=nil)
+      wrapper_calendar = Calendar.new
+      wrapper_calendar.add_subcomponent(self)
+      wrapper_calendar.export(stream)
+    end
+  end
+end