icalendar 0.95

data/lib/icalendar.rb

@@ -0,0 +1,27 @@
+=begin
+  Copyright (C) 2005 Jeff Rose
+
+  This library is free software; you can redistribute it and/or modify it
+  under the same terms as the ruby language itself, see the file COPYING for
+  details.
+=end
+
+$:.unshift(File.dirname(__FILE__))
+
+# Base classes and mixin modules
+require 'icalendar/conversions'
+#require 'icalendar/helpers'
+require 'icalendar/base'
+require 'icalendar/component'
+
+# Calendar and components
+require 'icalendar/calendar'
+require 'icalendar/component/event'
+require 'icalendar/component/journal'
+require 'icalendar/component/todo'
+require 'icalendar/component/freebusy'
+require 'icalendar/component/timezone'
+require 'icalendar/component/alarm'
+
+# Calendar parser
+require 'icalendar/parser'

data/lib/icalendar/#helpers.rb#

@@ -0,0 +1,92 @@
+=begin
+  Copyright (C) 2005 Jeff Rose
+  Copyright (C) 2005 Sam Roberts
+
+  This library is free software; you can redistribute it and/or modify it
+  under the same terms as the ruby language itself, see the file COPYING for
+  details.
+=end
+
+module Icalendar
+  module DateProp
+    # You have to do this to mixin class methods rather than instance methods.
+    def self.append_features(base)
+      super
+      klass.extend(ClassMethods)
+    end
+
+    # This is made a sub-module just so it can be added as class 
+    # methods rather than instance methods.
+    module ClassMethods
+      def ical_property(dp, alias_name = nil)
+        dp = "#{dp}".strip.downcase
+        getter = dp
+        setter = "#{dp}="
+        query = "#{dp}?"
+
+        unless instance_methods.include? getter
+          code = <<-code
+            def #{getter}(*a)
+              if a.empty?
+                @properties[#{dp.upcase}]
+              else
+                self.#{dp} = a.first
+              end 
+            end
+          code
+
+          module_eval code
+        end
+           
+        unless instance_methods.include? setter
+          code = <<-code
+            def #{setter} a
+              @properties[#{dp.upcase}] = a
+            end
+          code
+
+          module_eval code
+        end
+
+        unless instance_methods.include? query
+          code = <<-code
+            def #{query}
+              @properties.has_key?(#{dp.upcase})
+            end
+          code
+
+          module_eval code
+        end
+
+        # Define the getter
+        getter = "get#{property.to_s.capitalize}"
+        define_method(getter.to_sym) do
+          puts "inside getting..."
+          getDateProperty(property.to_s.upcase)  
+        end
+        
+        # Define the setter
+        setter = "set#{property.to_s.capitalize}"        
+        define_method(setter.to_sym) do |*params|
+          date = params[0]
+          utc = params[1]
+          puts "inside setting..."
+          setDateProperty(property.to_s.upcase, date, utc)
+        end
+
+        # Create aliases if a name was specified
+#         if not aliasName.nil?
+#           gasym = "get#{aliasName.to_s.capitalize}".to_sym 
+#           gsym = getter.to_sym
+#           alias gasym gsym 
+          
+#           sasym = "set#{aliasName.to_s.capitalize}".to_sym 
+#           ssym = setter.to_sym
+#           alias sasym ssym 
+#        end
+      end
+
+    end
+    
+  end
+end

data/lib/icalendar/base.rb

@@ -0,0 +1,31 @@
+=begin
+  Copyright (C) 2005 Jeff Rose
+
+  This library is free software; you can redistribute it and/or modify it
+  under the same terms as the ruby language itself, see the file COPYING for
+  details.
+=end
+require 'logger'
+
+module Icalendar #:nodoc:
+
+  # A simple error class to differentiate iCalendar library exceptions
+  # from ruby language exceptions or others.
+  class IcalendarError < StandardError #:nodoc:
+  end
+
+  # Exception used when the library encounters a bogus calendar component.
+  class InvalidComponentClass < IcalendarError
+  end
+
+  # Exception used when the library encounters a bogus property value.
+  class InvalidPropertyValue < IcalendarError
+  end
+
+  # This class serves as the base class for just about everything in
+  # the library so that the logging system can be configured in one place.
+  class Base
+    @@logger = Logger.new(STDERR)
+    @@logger.level = Logger::WARN
+  end
+end

data/lib/icalendar/calendar.rb

@@ -0,0 +1,112 @@
+=begin
+  Copyright (C) 2005 Jeff Rose
+
+  This library is free software; you can redistribute it and/or modify it
+  under the same terms as the ruby language itself, see the file COPYING for
+  details.
+=end
+
+module Icalendar
+
+  
+  class Calendar < Component
+    attr_accessor :events, :todos, :journals, :freebusys, :timezones
+
+    ical_property :calscale, :calendar_scale
+    ical_property :prodid, :product_id
+    ical_property :version
+    ical_property :method
+    
+    def initialize()
+      super("VCALENDAR")
+      @properties = {}
+      @property_params = {}
+      
+      @events = []
+      @todos = []
+      @journals = []
+      @freebusys = []
+      @timezones = []
+      
+      # 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.version = "2.0" # Version of the specification
+
+    end
+
+    def event(&block)
+      e = Event.new
+      self.add e
+      
+      e.instance_eval &block if block
+
+      e
+    end
+
+    def todo(&block)
+      e = Todo.new
+      self.add e
+      
+      e.instance_eval &block if block
+
+      e
+    end
+
+    def journal(&block)
+      e = Journal.new
+      self.add e
+      
+      e.instance_eval &block if block
+
+      e
+    end
+
+    def freebusy(&block)
+      e = Freebusy.new
+      self.add e
+      
+      e.instance_eval &block if block
+
+      e
+    end
+
+    def timezone(&block)
+      e = Timezone.new
+      self.add e
+      
+      e.instance_eval &block if block
+
+      e
+    end
+
+
+    #TODO: Implement the rest of these ^ methods for todo etc...
+
+    def add(component)
+      if component.is_a? Event
+          @events << component
+        elsif component.is_a? Todo
+          @todos << component
+        elsif component.is_a? Journal
+          @journals << component
+        elsif component.is_a? Freebusy
+          @freebusys << component
+        elsif component.is_a? Timezone
+          @timezones << component
+        else
+          raise InvalidComponentClass
+      end
+    end
+    
+    def to_ical
+      print_string do |s|
+        @events.each { |event| s << event.to_ical }
+        @todos.each { |todo| s << todo.to_ical }
+        @journals.each { |journal| s << journal.to_ical }
+        @freebusys.each { |freebusy| s << freebusy.to_ical }
+        @timezones.each { |timezone| s << timezone.to_ical }
+      end
+    end
+  end
+end

data/lib/icalendar/component.rb

@@ -0,0 +1,253 @@
+=begin
+  Copyright (C) 2005 Jeff Rose
+
+  This library is free software; you can redistribute it and/or modify it
+  under the same terms as the ruby language itself, see the file COPYING for
+  details.
+=end
+
+module Icalendar
+  # 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
+  # calendar components are collections of properties that express a
+  # particular calendar semantic. For example, the calendar component can
+  # specify an Event, a Todo, a Journal entry, Timezone information, or
+  # Freebusy time information, or an Alarm.
+  class Component < Icalendar::Base
+    attr_reader :name
+    attr_accessor :properties, :property_params
+
+    @@multi_properties = {}
+
+    def initialize(name)
+      @name = name
+      @properties = {}
+      @property_params = {}
+
+      @@logger.info("New #{@name[1,@name.size].capitalize}...")
+    end
+    
+    def print_string
+      s = ""
+      
+      # Begin a new component
+      s << "BEGIN:#{@name.upcase}\r\n"
+
+      # Then print the properties, possible parameters and potentially
+      # multiple parameter values for each parameter.
+      @properties.each do |key,value| 
+        # Property name
+        s << "#{key.upcase}"
+        
+        # Possible parameters
+        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
+              end
+            end
+          end
+        end
+
+        # Property value
+        s << ":#{value.to_ical}\r\n" 
+      end
+
+      # Any custom body of the derived component
+      yield(s)
+      
+      # End of this component
+      s << "END:#{@name.upcase}\r\n"
+    end
+
+    # TODO: Look into the x-property, x-param stuff...
+    def custom_property(name, value)
+      @properties[name] = value
+    end
+
+    def multi_property?(name)
+      @@multi_properties.has_key?(name)
+    end
+
+    # Make it protected so we can monitor usage...
+    protected
+
+    # 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?
+      
+      # Change underscores in property name to a dash
+      property[/_/] = '-' if property =~ /_/
+
+      # All properties names are stored in caps...
+      property = property.upcase
+
+      unless instance_methods.include? getter
+        code = <<-code
+            def #{getter}(*a)
+              if a.empty?
+                @properties["#{property}"]
+              else
+                self.#{getter} = a.first
+              end 
+            end
+        code
+
+        class_eval code, "component.rb", 124
+
+        alias_method("#{alias_name}", "#{getter}") unless alias_name.nil?
+      end
+
+      unless instance_methods.include? setter
+        code = <<-code
+            def #{setter} a
+              unless a.respond_to?(:to_ical)
+                raise(NotImplementedError, "Property value does not support to_ical method!")
+              end
+              
+              @properties["#{property}"] = a
+            end
+        code
+            
+        class_eval code, "component.rb", 134
+
+        alias_method("#{alias_name}=", "#{setter}") unless alias_name.nil?
+      end
+          
+      unless instance_methods.include? query
+        code = <<-code
+            def #{query}
+              @properties.has_key?("#{property}")
+            end
+        code
+            
+        class_eval code, "component.rb", 144
+
+        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
+
+      # Getter for whole array
+      unless instance_methods.include? getter
+        code = <<-code
+            def #{getter}(*a)
+              if a.empty?
+                if @properties.has_key?("#{property}")
+                  @properties["#{property}"]
+                else
+                  []
+                end
+              else
+                self.#{setter}(a.first)
+              end 
+            end
+        code
+
+        class_eval code, "component.rb", 186
+      end
+
+      # Setter for whole array
+      unless instance_methods.include? setter
+        code = <<-code
+            def #{setter}(a)
+              if a.respond_to?(:to_ary)
+                a.to_ary.each do |val|
+                  unless val.respond_to?(:to_ical)
+                    raise(NotImplementedError, "Property values do not support to_ical method!")
+                  end
+                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."
+              end
+            end
+        code
+            
+        class_eval code, "component.rb", 198
+      end
+          
+      # Query for any of these properties
+      unless instance_methods.include? query
+        code = <<-code
+            def #{query}
+              @properties.has_key?("#{property}")
+            end
+        code
+            
+        class_eval code, "component.rb", 210
+      end
+
+      # Add another item to this properties array
+      unless instance_methods.include? adder
+        code = <<-code
+            def #{adder}(a)
+              unless a.respond_to?(:to_ical)
+                raise(NotImplementedError, "Property value object does not support to_ical method!")
+              end
+              
+              if @properties.has_key?("#{property}")
+                @properties["#{property}"] << a
+              else
+                @properties["#{property}"] = [a]
+              end
+            end
+        code
+
+        class_eval code, "component.rb", 228
+      end
+
+      # Remove an item from this properties array
+      unless instance_methods.include? remover
+        code = <<-code
+            def #{remover}(a)
+              if @properties.has_key?("#{property}")
+                @properties["#{property}"].delete(a)
+              end
+            end
+        code
+
+        class_eval code, "component.rb", 241
+      end
+
+    end
+  end
+end