icalendar 0.96.4 → 0.97

data/examples/parse_cal.rb

@@ -10,11 +10,11 @@ cal_file = File.open("../test/life.ics")
 
 # Parser returns an array of calendars because a single file
 # can have multiple calendar objects.
-cals = Icalendar::Parser.new(cal_file).parse
+cals = Icalendar::parse(cal_file)
 cal = cals.first
 
 # Now you can access the cal object in just the same way I created it
 event = cal.events.first
 
-puts "user_id: " + event.user_id
+puts "start date-time: " + event.dtstart.to_s
 puts "summary: " + event.summary

data/lib/icalendar/base.rb

@@ -31,5 +31,13 @@ module Icalendar #:nodoc:
   class Base
     @@logger = Logger.new(STDERR)
     @@logger.level = Logger::FATAL
+
+    def self.debug
+      @@logger.level = Logger::DEBUG
+    end
+
+    def self.quiet
+      @@logger.level = Logger::FATAL
+    end
   end
 end

data/lib/icalendar/calendar.rb

@@ -18,12 +18,10 @@ module Icalendar
 
     def initialize()
       super("VCALENDAR")
-      @properties = {}
-      @property_params = {}
 
       # Set some defaults
       self.calscale = "GREGORIAN"    # Who knows, but this is the only one in the spec.
-      self.prodid = "iCalendar-Ruby" # Current product... Should be overwritten
+      self.prodid = "iCalendar-Ruby" # Current product... Should be overwritten by apps that use the library
       self.version = "2.0" # Version of the specification
     end
 
@@ -35,6 +33,10 @@ module Icalendar
 
       e
     end
+    
+    def find_event(uid)
+      self.events.find {|e| e.uid == uid}
+    end
 
     def todo(&block)
       e = Todo.new
@@ -45,6 +47,10 @@ module Icalendar
       e
     end
 
+    def find_todo(uid)
+      self.todos.find {|t| t.uid == uid}
+    end
+    
     def journal(&block)
       e = Journal.new
       self.add_component e
@@ -54,6 +60,10 @@ module Icalendar
       e
     end
 
+    def find_journal(uid)
+      self.journals.find {|j| j.uid == uid}
+    end
+
     def freebusy(&block)
       e = Freebusy.new
       self.add_component e
@@ -63,6 +73,10 @@ module Icalendar
       e
     end
 
+    def find_freebusy(uid)
+      self.freebusys.find {|f| f.uid == uid}
+    end
+
     def timezone(&block)
       e = Timezone.new
       self.add_component e
@@ -71,6 +85,21 @@ module Icalendar
 
       e
     end
+    
+    # The "PUBLISH" method in a "VEVENT" calendar component is an
+    # unsolicited posting of an iCalendar object. Any CU may add published
+    # components to their calendar. The "Organizer" MUST be present in a
+    # published iCalendar component. "Attendees" MUST NOT be present. Its
+    # expected usage is for encapsulating an arbitrary event as an
+    # iCalendar object. The "Organizer" may subsequently update (with
+    # another "PUBLISH" method), add instances to (with an "ADD" method),
+    # or cancel (with a "CANCEL" method) a previously published "VEVENT"
+    # calendar component.
+    def publish
+      ip_method = "PUBLISH"
+
+    end
+
   end # class Calendar
 
 end # module Icalendar

data/lib/icalendar/component.rb

@@ -7,6 +7,23 @@
 =end
 
 module Icalendar
+  require 'socket'
+
+  class Geo < Icalendar::Base
+    attr_accessor :latitude, :longitude
+    alias :lat :latitude
+    alias :long :longitude
+
+    def initialize(lat, long)
+      @lat = lat
+      @long = long
+    end
+
+    def to_ical
+      "#{@lat.to_ical};#{@long.to_ical}"
+    end
+  end
+
   # The body of the iCalendar object consists of a sequence of calendar
   # properties and one or more calendar components. The calendar
   # properties are attributes that apply to the calendar as a whole. The
@@ -19,7 +36,7 @@ module Icalendar
     meta_include HashAttrs
 
     attr_reader :name
-    attr_accessor :properties, :property_params
+    attr_accessor :properties
 
     @@multi_properties = {}
 
@@ -27,7 +44,6 @@ module Icalendar
       @name = name
       @components = Hash.new([])
       @properties = {}
-      @property_params = {}
 
       @@logger.info("New #{@name[1,@name.size].capitalize}...")
     end
@@ -43,37 +59,74 @@ module Icalendar
       @components[key] << component
     end
 
+    # Add a component to the calendar.
     alias add add_component
 
+    # Add an event to the calendar.
+    alias add_event add_component
+
+    # Add a todo item to the calendar.
+    alias add_todo add_component
+
+    # Add a journal item to the calendar.
+    alias add_journal add_component
+
+    def remove_component(component)
+      key = (component.class.to_s.downcase + 's').gsub('icalendar::', '').to_sym
+
+      if @components.has_key? key
+        @components[key].delete(component)
+      end
+    end
+
+    # Remove a component from the calendar.
+    alias remove remove_component
+
+    # Remove an event from the calendar.
+    alias remove_event remove_component
+
+    # Remove a todo item from the calendar.
+    alias remove_todo remove_component
+
+    # Remove a journal item from the calendar.
+    alias remove_journal remove_component
+
+    # Used to generate unique component ids
+    def new_uid
+      "#{DateTime.now}_#{rand(999999999)}@#{Socket.gethostname}"
+    end
+
+    # Output in the icalendar format
     def to_ical
-      print_component do |s|
+      print_component do
+        s = ""
         @components.each_value do |comps|
           comps.each { |component| s << component.to_ical }
         end
+        s
       end
     end
 
     # Print this icalendar component
     def print_component
-      s = ""
-
       # Begin a new component
-      s << "BEGIN:#{@name.upcase}\r\n"
+      "BEGIN:#{@name.upcase}\r\n" +
 
       # Then the properties
-      print_properties(s)
+      print_properties +
 
-      # Any custom body of the derived component
-      yield(s)
+      # sub components
+      yield +
 
       # End of this component
-      s << "END:#{@name.upcase}\r\n"
+      "END:#{@name.upcase}\r\n"
     end
 
     # Print this components properties
-    def print_properties(s)
-      @properties.each do |key,value| 
+    def print_properties
+      s = ""
 
+      @properties.each do |key,val| 
         # Take out underscore for property names that conflicted
         # with built-in words.
         if key =~ /ip_.*/
@@ -81,47 +134,51 @@ module Icalendar
         end
 
         # Property name
-        s << "#{key.upcase}"
+        s << "#{key.upcase}" + 
 
         # Possible parameters
-        print_parameter(s, key, value)
+        print_parameters(val) + 
 
         # Property value
-        s << ":#{value.to_ical}\r\n" 
+        ":#{val.to_ical}\r\n" 
       end
+
+      s
     end
 
     # Print the parameters for a specific property
-    def print_parameter(s, key, value)
-      if @property_params.has_key?(key) 
-        params = @property_params[key]
-        params.each do |key,val|
-          s << ";#{key}"
-          val = [ val ] unless val.respond_to?(:to_ary)
-
-          # Possible parameter values
-          unless val.empty?
-            s << "="
-            sep = "" # First entry comes after = sign, but then we need commas
-            val.each do |pval| 
-              if pval.respond_to? :to_ical 
-                s << sep << pval.to_ical
-                sep = ","
-              end
+    def print_parameters(val)
+      s = ""
+      return s unless val.respond_to?(:ical_params) and not val.ical_params.nil?
+
+      val.ical_params.each do |key,val|
+        s << ";#{key}"
+        val = [ val ] unless val.is_a?(Array)
+
+        # Possible parameter values
+        unless val.empty?
+          s << "="
+          sep = "" # First entry comes after = sign, but then we need commas
+          val.each do |pval| 
+            if pval.respond_to? :to_ical 
+              s << sep << pval.to_ical
+              sep = ","
             end
           end
-
         end
       end
+      s
     end
 
     # TODO: Look into the x-property, x-param stuff...
+    # This would really only be needed for subclassing to add additional
+    # properties to an application using the API.
     def custom_property(name, value)
       @properties[name] = value
     end
 
     def multi_property?(name)
-      @@multi_properties.has_key?(name.upcase)
+      @@multi_properties.has_key?(name.downcase)
     end
 
     # Make it protected so we can monitor usage...
@@ -133,107 +190,114 @@ module Icalendar
 
     # Define a set of methods supporting a new property
     def Component.ical_property(property, alias_name = nil, prop_name = nil)
-
       property = "#{property}".strip.downcase
-      getter = "#{property}"
-      setter = "#{property}="
-      query = "#{property}?"
       alias_name = "#{alias_name}".strip.downcase unless alias_name.nil?
 
       # If a prop_name was given then we use that for the actual storage
-      property = "#{prop_name}".strip.upcase unless prop_name.nil?
+      property = "#{prop_name}".strip.downcase unless prop_name.nil?
 
-      # Change underscores in property name to a dash
-      property[/_/] = '-' if property =~ /_/
+      generate_getter(property, alias_name)
+      generate_setter(property, alias_name)
+      generate_query(property, alias_name)
+    end
+    
+    # Define a set of methods defining a new property, which 
+    # supports multiple values for the same property name.
+    def Component.ical_multi_property(property, singular, plural)
+      property = "#{property}".strip.downcase.gsub(/-/, '_')
+      plural = "#{plural}".strip.downcase
 
-      # All properties names are stored in caps...
-      property = property.upcase
+      # Set this key so the parser knows to use an array for
+      # storing this property type.
+      @@multi_properties["#{property}"] = true
 
-      unless instance_methods.include? getter
-        code = <<-code
-            def #{getter}(val = nil, params = {})
-              if val.nil?
-                @properties["#{property}"]
-              else
-                # Set the value just like normal
-                self.#{setter}(val)
-              end 
-            end
-        code
+      generate_multi_getter(property, plural)
+      generate_multi_setter(property, plural)
+      generate_multi_query(property, plural)
+      generate_multi_adder(property, singular)
+      generate_multi_remover(property, singular)
+    end
 
-        class_eval code, "component.rb", 155
-        alias_method("#{alias_name}", "#{getter}") unless alias_name.nil?
-      end
+    private
 
-      unless instance_methods.include? setter
+    def Component.generate_getter(property, alias_name)
+      unless instance_methods.include? property
         code = <<-code
-            def #{setter}(val)
+            def #{property}(val = nil, params = nil)
+              return @properties["#{property}"] if val.nil?
+
               unless val.respond_to?(:to_ical)
                 raise(NotImplementedError, "Value of type (" + val.class.to_s + ") does not support to_ical method!")
               end
 
+              unless params.nil?
+                # Extend with the parameter methods only if we have to...
+                unless val.respond_to?(:ical_params) 
+                  val.class.class_eval { attr_accessor :ical_params }
+                end
+                val.ical_params = params
+              end
+
               @properties["#{property}"] = val
             end
         code
 
-        class_eval code, "component.rb", 171
+        class_eval code, "component.rb", 219
+        alias_method("#{alias_name}", "#{property}") unless alias_name.nil?
+      end
+    end
+
+    def Component.generate_setter(property, alias_name)
+      setter = property + '='
+      unless instance_methods.include? setter
+        code = <<-code
+            def #{setter}(val)
+              #{property}(val)
+            end
+        code
 
-        alias_method("#{alias_name}=", "#{setter}") unless alias_name.nil?
+        class_eval code, "component.rb", 233
+        alias_method("#{alias_name}=", "#{property+'='}") unless alias_name.nil?
       end
+    end
 
+    def Component.generate_query(property, alias_name)
+      query = "#{property}?"
       unless instance_methods.include? query
         code = <<-code
             def #{query}
-              @properties.has_key?("#{property}")
+              @properties.has_key?("#{property.downcase}")
             end
         code
 
-        class_eval code, "component.rb", 183
+        class_eval code, "component.rb", 226
 
         alias_method("#{alias_name}\?", "#{query}") unless alias_name.nil?
       end    
     end
 
-    # Define a set of methods defining a new property, which 
-    # supports multiple values for the same property name.
-    def Component.ical_multi_property(property, singular, plural)
-      property = "#{property}".strip.upcase
-      singular = "#{singular}".strip.downcase
-      plural = "#{plural}".strip.downcase
-
-      getter = "#{plural}"
-      setter = "#{plural}="
-      adder = "add_#{singular}"
-      remover = "remove_#{singular}"
-      query = "#{plural}?"
-
-      # Set this key so the parser knows to use an array for
-      # storing this property type.
-      @@multi_properties["#{property}"] = true
-
+    def Component.generate_multi_getter(property, plural)     
       # Getter for whole array
-      unless instance_methods.include? getter
+      unless instance_methods.include? plural
         code = <<-code
-            def #{getter}(*a)
-              if a.empty?
-                if @properties.has_key?("#{property}")
-                  @properties["#{property}"]
-                else
-                  []
-                end
+            def #{plural}(a = nil)
+              if a.nil?
+                @properties["#{property}"] || []
               else
-                self.#{setter}(a.first)
+                self.#{plural}=(a)
               end 
             end
         code
 
         class_eval code, "component.rb", 186
       end
+    end
 
+    def Component.generate_multi_setter(property, plural)
       # Setter for whole array
-      unless instance_methods.include? setter
+      unless instance_methods.include? plural+'+'
         code = <<-code
-            def #{setter}(a)
+            def #{plural}=(a)
               if a.respond_to?(:to_ary)
                 a.to_ary.each do |val|
                   unless val.respond_to?(:to_ical)
@@ -242,27 +306,31 @@ module Icalendar
                 end
 
                 @properties["#{property}"] = a.to_ary
-
               else
-                raise ArgumentError, "#{getter} is a multi-property that must be an array! Use the #{adder} method to add single entries."
+                raise ArgumentError, "#{plural} is a multi-property that must be an array! Use the add_[property] method to add single entries."
               end
             end
         code
 
         class_eval code, "component.rb", 198
       end
+    end
 
+    def Component.generate_multi_query(property, plural)
       # Query for any of these properties
-      unless instance_methods.include? query
+      unless instance_methods.include? plural+'?'
         code = <<-code
-            def #{query}
+            def #{plural}?
               @properties.has_key?("#{property}")
             end
         code
 
         class_eval code, "component.rb", 210
       end
+    end
 
+    def Component.generate_multi_adder(property, singular)
+      adder = "add_"+singular.to_s
       # Add another item to this properties array
       unless instance_methods.include? adder
         code = <<-code
@@ -271,6 +339,14 @@ module Icalendar
                 raise(NotImplementedError, "Property value object does not support to_ical method!")
               end
 
+              unless params.nil?
+                # Extend with the parameter methods only if we have to...
+                unless val.respond_to?(:ical_params) 
+                  val.class.class_eval { attr_accessor :ical_params }
+                end
+                val.ical_params = params
+              end
+
               if @properties.has_key?("#{property}")
                 @properties["#{property}"] << val
               else
@@ -279,52 +355,50 @@ module Icalendar
             end
         code
 
-        class_eval code, "component.rb", 228
+        class_eval code, "component.rb", 289
         alias_method("add_#{property.downcase}", "#{adder}") 
       end
+    end
 
+    def Component.generate_multi_remover(property, singular)
       # Remove an item from this properties array
-      unless instance_methods.include? remover
+      unless instance_methods.include? "remove_#{singular}"
         code = <<-code
-            def #{remover}(a)
+            def remove_#{singular}(a)
               if @properties.has_key?("#{property}")
                 @properties["#{property}"].delete(a)
               end
             end
         code
 
-        class_eval code, "component.rb", 241
-        alias_method("remove_#{property.downcase}", "#{remover}")
+        class_eval code, "component.rb", 303
+        alias_method("remove_#{property.downcase}", "remove_#{singular}")
       end
-
     end
 
     def method_missing(method_name, *args)
+      @@logger.debug("Inside method_missing...")
       method_name = method_name.to_s.downcase
 
       unless method_name =~ /x_.*/
-        raise NoMethodError
-      end
-
-      val = args.first
-
-      unless val.respond_to?(:to_ical)
-        raise(NotImplementedError, "Value of type (" + val.class.to_s + ") does not support to_ical method!")
+        raise NoMethodError, "Method Name: #{method_name}"
       end
 
-      if method_name =~ /(.*)(=)/ # Its a setter
-        @properties[$1] = val
-        @@logger.debug("Setting #{$1} => #{val}")
+      # x-properties are accessed with underscore but stored with a dash so
+      # they output correctly and we don't have to special case the
+      # output code, which would require checking every property.
+      if args.size > 0 # Its a setter
+        # Pull off the possible equals
+        @properties[method_name[/x_[^=]*/].gsub('x_', 'x-')] = args.first
       else # Or its a getter
-        @@logger.debug("Getting #{method_name} => #{@properties[method_name]}")
-        return @properties[method_name]
+        return @properties[method_name.gsub('x_', 'x-')]
       end
     end
 
     public
 
     def respond_to?(method_name)
-      unless method_name.to_s.downcase =~ /x-.*/
+      unless method_name.to_s.downcase =~ /x_.*/
         super
       end