rubyredrick-ri_cal 0.0.2

data/lib/ri_cal/component/timezone.rb

@@ -0,0 +1,193 @@
+require File.join(File.dirname(__FILE__), %w[.. properties timezone.rb])
+
+module RiCal
+  class Component
+    #- ©2009 Rick DeNatale
+    #- All rights reserved. Refer to the file README.txt for the license
+    #
+    # An Timezone (VTIMEZONE) calendar component describes a timezone used within the calendar.
+    # A Timezone has two or more TimezonePeriod subcomponents which describe the transitions between
+    # standard and daylight saving time.
+    #
+    # to see the property accessing methods for this class see the RiCal::Properties::Timezone module
+    class Timezone < Component
+      include RiCal::Properties::Timezone
+
+        # The identifier of the timezone, e.g. "Europe/Paris".
+        def identifier
+          tzid
+        end
+
+        # An alias for identifier.
+        def name
+          # Don't use alias, as identifier gets overridden.
+          identifier
+        end
+
+        # Returns the TimezonePeriod for the given UTC time. utc can either be a DateTime,
+        # Time or integer timestamp (Time.to_i). Any timezone information in utc is ignored (it is treated as a UTC time).
+        def period_for_utc(time)
+          last_period(last_before_utc(standard, time), last_before_utc(daylight, time))
+        end
+
+        # Returns the set of TimezonePeriod instances that are valid for the given
+        # local time as an array. If you just want a single period, use
+        # period_for_local instead and specify how ambiguities should be resolved.
+        # Returns an empty array if no periods are found for the given time.
+        def periods_for_local(local)
+          local = local.to_ri_cal_date_time_value
+          candidate_standard = last_before_local(standard, local)
+          candidate_daylight = last_before_local(daylight, local)
+          if candidate_daylight && candidate_daylight.swallows_local?(local, candidate_standard)
+            []  # Invalid local time
+          elsif candidate_standard
+            if candidate_daylight
+              if candidate_daylight.dtstart > candidate_standard.dtstart
+                [candidate_daylight]
+              elsif candidate_standard.ambiguous_local?(local)
+                [candidate_daylight, candidate_standard]
+              else
+                [candidate_standard].compact
+              end
+            else
+              [candidate_standard].compact
+            end
+          end
+        end
+
+
+        # Returns the TimezonePeriod for the given local time. local can either be
+        # a DateTime, Time or integer timestamp (Time.to_i). Any timezone
+        # information in local is ignored (it is treated as a time in the current
+        # timezone).
+        #
+        # Warning: There are local times that have no equivalent UTC times (e.g.
+        # in the transition from standard time to daylight savings time). There are
+        # also local times that have more than one UTC equivalent (e.g. in the
+        # transition from daylight savings time to standard time).
+        #
+        # In the first case (no equivalent UTC time), a PeriodNotFound exception
+        # will be raised.
+        #
+        # In the second case (more than one equivalent UTC time), an AmbiguousTime
+        # exception will be raised unless the optional dst parameter or block
+        # handles the ambiguity.
+        #
+        # If the ambiguity is due to a transition from daylight savings time to
+        # standard time, the dst parameter can be used to select whether the
+        # daylight savings time or local time is used. For example,
+        #
+        #   Timezone.get('America/New_York').period_for_local(DateTime.new(2004,10,31,1,30,0))
+        #
+        # would raise an AmbiguousTime exception.
+        #
+        # Specifying dst=true would the daylight savings period from April to
+        # October 2004. Specifying dst=false would return the standard period
+        # from October 2004 to April 2005.
+        #
+        # If the dst parameter does not resolve the ambiguity, and a block is
+        # specified, it is called. The block must take a single parameter - an
+        # array of the periods that need to be resolved. The block can select and
+        # return a single period or return nil or an empty array
+        # to cause an AmbiguousTime exception to be raised.
+        #
+        # TODO: need to check for ambiguity
+        def period_for_local(local, dst=nil)
+          results = periods_for_local(local)
+
+          if results.empty?
+            raise TZInfo::PeriodNotFound
+          elsif results.size < 2
+            results.first
+          else
+            # ambiguous result try to resolve
+
+            unless dst.nil?
+              matches = results.find_all {|period| period.dst? == dst}
+              results = matches unless matches.empty?
+            end
+
+            if results.size < 2
+              results.first
+            else
+              # still ambiguous, try the block
+
+              if block_given?
+                results = yield results
+              end
+
+              if results.is_a?(TimezonePeriod)
+                results
+              elsif results && results.size == 1
+                results.first
+              else
+                raise TZInfo::AmbiguousTime, "#{local} is an ambiguous local time."
+              end
+            end
+          end
+        end
+
+        # convert time from utc time to this time zone
+        def utc_to_local(time)
+          time = time.to_ri_cal_date_time_value
+          converted = time + period_for_utc(time).tzoffsetto_property
+          converted.tzid = identifier
+          converted
+        end
+
+        # convert time from this time zone to utc time
+        def local_to_utc(time)
+          time = time.to_ri_cal_date_time_value
+          period = period_for_local(time)
+          converted = time - period.tzoffsetto_property
+          converted.tzid = "UTC"
+          converted
+        end
+      end
+
+      def self.entity_name #:nodoc:
+        "VTIMEZONE"
+      end
+
+      def standard #:nodoc:
+        @subcomponents["STANDARD"]
+      end
+
+      def daylight #:nodoc:
+        @subcomponents["DAYLIGHT"]
+      end
+
+      def last_period(standard, daylight) #:nodoc:
+        if standard
+          if daylight
+            standard.dtstart > daylight.dtstart ? standard : daylight
+          else
+            standard
+          end
+        else
+          daylight
+        end
+      end
+
+      def last_before_utc(period_array, time) #:nodoc:
+        candidates = period_array.map {|period|
+          period.last_before_utc(time)
+        }
+        result = candidates.max {|a, b| a.dtstart_property <=> b.dtstart_property}
+        result
+      end
+
+      def last_before_local(period_array, time) #:nodoc:
+        candidates = period_array.map {|period|
+          period.last_before_local(time)
+        }
+        result = candidates.max {|a, b| a.dtstart_property <=> b.dtstart_property}
+        result
+      end
+  end
+end
+
+
+%w[timezone_period.rb daylight_period.rb standard_period.rb].each do |filename|
+  require "#{File.dirname(__FILE__)}/timezone/#{filename}"
+end

data/lib/ri_cal/component/todo.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), %w[.. properties todo.rb])
+
+module RiCal
+  class Component
+    #- ©2009 Rick DeNatale
+    #- All rights reserved. Refer to the file README.txt for the license
+    #
+    # A Todo (VTODO) calendar component groups properties describing a to-do
+    # Todos may have multiple occurrences
+    #
+    # Todos may also contain one or more ALARM subcomponents
+    # to see the property accessing methods for this class see the RiCal::Properties::Todo module
+    # to see the methods for enumerating occurrences of recurring to-dos see the RiCal::OccurrenceEnumerator module
+    class Todo < Component
+      include Properties::Todo
+
+      def self.entity_name #:nodoc:
+        "VTODO"
+      end
+
+      def subcomponent_class #:nodoc:
+        {:alarm => Alarm }
+      end
+    end
+  end
+end

data/lib/ri_cal/component.rb

@@ -0,0 +1,224 @@
+module RiCal
+  #- ©2009 Rick DeNatale
+  #- All rights reserved. Refer to the file README.txt for the license
+  #
+  class Component    
+    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
+
+    autoload :Timezone, "#{File.dirname(__FILE__)}/component/timezone.rb"
+    
+    attr_accessor :imported #:nodoc:
+
+    def initialize(parent=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 find_timezone(identifier) #:nodoc:
+      @parent.find_timezone(identifier)
+    end
+    
+    def time_zone_for(ruby_object)
+      @parent.time_zone_for(ruby_object) #:nodoc:
+    end
+    
+    def subcomponent_class #:nodoc:
+      {}
+    end
+
+    def self.from_parser(parser, parent) #:nodoc:
+      entity = self.new(parent)
+      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 ||= {}
+    end
+
+    # Add a n extended property 
+    def add_x_property(name, prop)
+      x_properties[name] = prop
+    end
+    
+    def method_missing(selector, *args, &b)
+      xprop_candidate = selector.to_s
+      if (match = /^x_(.+)(=?)$/.match(xprop_candidate))
+        if match[2] == "="
+          add_x_property("x_#{match[1]}", *args)
+        else
+          x_properties[xprop_candidate]
+        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, prop|
+        export_stream.puts("#{name}:#{prop}")
+      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 do |sub|
+        export_subcomponent_to(export_subcomponent_to, 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
+
+Dir[File.dirname(__FILE__) + "/component/*.rb"].sort.each do |path|
+  filename = File.basename(path)
+  require path
+end

data/lib/ri_cal/core_extensions/array/conversions.rb

@@ -0,0 +1,15 @@
+module RiCal
+  module CoreExtensions #:nodoc:
+    module Array #:nodoc:
+      #- ©2009 Rick DeNatale
+      #- All rights reserved. Refer to the file README.txt for the license
+      #
+      module Conversions
+        # return the concatenation of the elements representation in rfc 2445 format
+        def to_rfc2445_string # :doc:
+          join(",")
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/core_extensions/array.rb

@@ -0,0 +1,7 @@
+require "#{File.dirname(__FILE__)}/array/conversions.rb"
+class Array #:nodoc:
+  #- ©2009 Rick DeNatale
+  #- All rights reserved. Refer to the file README.txt for the license
+  #
+  include RiCal::CoreExtensions::Array::Conversions
+end

data/lib/ri_cal/core_extensions/date/conversions.rb

@@ -0,0 +1,27 @@
+module RiCal
+  module CoreExtensions #:nodoc:
+    module Date #:nodoc:
+      #- ©2009 Rick DeNatale
+      #- All rights reserved. Refer to the file README.txt for the license
+      #
+      module Conversions
+        # Return an RiCal::PropertyValue::DateTime representing the receiver
+        def to_ri_cal_date_time_value
+          RiCal::PropertyValue::DateTime.new(nil, :value => self)
+        end
+        
+        # Return an RiCal::PropertyValue::Date representing the receiver
+        def to_ri_cal_date_value
+          RiCal::PropertyValue::Date.new(nil, :value => self)
+        end
+
+        alias_method :to_ri_cal_date_or_date_time_value, :to_ri_cal_date_value
+        
+        # Return the natural ri_cal_property for this object
+        def to_ri_cal_property_value
+          to_ri_cal_date_value
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/core_extensions/date.rb

@@ -0,0 +1,13 @@
+require "#{File.dirname(__FILE__)}/date/conversions.rb"
+require "#{File.dirname(__FILE__)}/time/week_day_predicates.rb"
+require "#{File.dirname(__FILE__)}/time/calculations.rb"
+require 'date'
+
+class Date #:nodoc:
+  #- ©2009 Rick DeNatale
+  #- All rights reserved. Refer to the file README.txt for the license
+  #
+  include RiCal::CoreExtensions::Time::WeekDayPredicates
+  include RiCal::CoreExtensions::Time::Calculations
+  include RiCal::CoreExtensions::Date::Conversions
+end

data/lib/ri_cal/core_extensions/date_time/conversions.rb

@@ -0,0 +1,27 @@
+module RiCal
+  module CoreExtensions #:nodoc:
+    module DateTime #:nodoc:
+      #- ©2009 Rick DeNatale
+      #- All rights reserved. Refer to the file README.txt for the license
+      #
+      module Conversions
+        # Return an RiCal::PropertyValue::DateTime representing the receiver
+        def to_ri_cal_date_time_value
+          RiCal::PropertyValue::DateTime.from_time(self)
+        end
+
+        alias_method :to_ri_cal_date_or_date_time_value, :to_ri_cal_date_time_value
+
+        # Return the natural ri_cal_property for this object
+        def to_ri_cal_property_value
+          to_ri_cal_date_time_value
+        end
+        
+        # Return a proxy to this object which will be interpreted as a floating time.
+        def with_floating_timezone
+          RiCal::TimeWithFloatingTimezone.new(self)
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/core_extensions/date_time.rb

@@ -0,0 +1,13 @@
+require "#{File.dirname(__FILE__)}/date_time/conversions.rb"
+require "#{File.dirname(__FILE__)}/time/week_day_predicates.rb"
+require "#{File.dirname(__FILE__)}/time/calculations.rb"
+require 'date'
+
+class DateTime #:nodoc:
+  #- ©2009 Rick DeNatale
+  #- All rights reserved. Refer to the file README.txt for the license
+  #
+  include RiCal::CoreExtensions::Time::WeekDayPredicates
+  include RiCal::CoreExtensions::Time::Calculations
+  include RiCal::CoreExtensions::DateTime::Conversions
+end

data/lib/ri_cal/core_extensions/object/conversions.rb

@@ -0,0 +1,20 @@
+module RiCal
+  module CoreExtensions #:nodoc:
+    module Object #:nodoc:
+      #- ©2009 Rick DeNatale
+      #- All rights reserved. Refer to the file README.txt for the license
+      #
+      module Conversions
+        # Used to format rfc2445 output for RiCal
+        def to_rfc2445_string
+          to_s
+        end
+        
+        # Used by RiCal specs returns the receiver
+        def to_ri_cal_ruby_value
+          self
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/core_extensions/object.rb

@@ -0,0 +1,8 @@
+require "#{File.dirname(__FILE__)}/object/conversions.rb"
+
+class Object #:nodoc:
+  #- ©2009 Rick DeNatale
+  #- All rights reserved. Refer to the file README.txt for the license
+  #
+  include RiCal::CoreExtensions::Object::Conversions
+end

data/lib/ri_cal/core_extensions/string/conversions.rb

@@ -0,0 +1,32 @@
+module RiCal
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      #- ©2009 Rick DeNatale
+      #- All rights reserved. Refer to the file README.txt for the license
+      #
+      module Conversions
+        # Parse the receiver as an RiCal::PropertyValue::DateTime
+        def to_ri_cal_date_time_value
+          RiCal::PropertyValue::DateTime.from_string(self)
+        end
+
+        alias_method :to_ri_cal_date_or_date_time_value, :to_ri_cal_date_time_value
+
+        # Parse the receiver as an RiCal::PropertyValue::DurationValue
+        def to_ri_cal_duration_value
+          RiCal::PropertyValue::Duration.from_string(self)
+        end
+
+        # code stolen from ActiveSupport Gem
+        unless  ::String.instance_methods.include?("camelize")
+          # Convert the receiver to camelized form
+          # This method duplicates the method provided by ActiveSupport, and will only be defined
+          # by the RiCal gem if it is not already defined.
+          def camelize
+            self.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/core_extensions/string.rb

@@ -0,0 +1,8 @@
+require "#{File.dirname(__FILE__)}/string/conversions.rb"
+
+class String #:nodoc:
+  #- ©2009 Rick DeNatale
+  #- All rights reserved. Refer to the file README.txt for the license
+  #
+  include RiCal::CoreExtensions::String::Conversions
+end