icalendar 1.5.4 → 2.0.0.beta.1

data/lib/icalendar/alarm.rb

@@ -0,0 +1,35 @@
+module Icalendar
+
+  class Alarm < Component
+
+    required_property :action
+    required_property :trigger, Icalendar::Values::Duration
+    required_property :description, Icalendar::Values::Text,
+                      ->(alarm, description) { alarm.action.downcase == 'audio' || !description.nil? }
+    required_property :summary, Icalendar::Values::Text,
+                      ->(alarm, summary) { alarm.action.downcase != 'email' || !summary.nil? }
+    required_multi_property :attendee, Icalendar::Values::CalAddress,
+                            ->(alarm, attendees) { alarm.action.downcase != 'email' || !attendees.compact.empty? }
+
+    optional_single_property :duration, Icalendar::Values::Duration
+    optional_single_property :repeat, Icalendar::Values::Integer
+
+    optional_property :attach, Icalendar::Values::Uri
+
+    def initialize
+      super 'alarm'
+    end
+
+    def valid?(strict = false)
+      if strict
+        # must be part of event or todo
+        !(parent.nil? || parent.name == 'event' || parent.name == 'todo') and return false
+      end
+      # either both duration and repeat or neither should be set
+      [duration, repeat].compact.size == 1 and return false
+      # attach must be single for audio actions
+      action.downcase == 'audio' && attach.compact.size > 1 and return false
+      super
+    end
+  end
+end

data/lib/icalendar/calendar.rb

@@ -1,110 +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
-
 module Icalendar
 
   class Calendar < Component
-    ical_component :timezones, :events, :todos, :journals, :freebusys
-
-    ical_property :calscale, :calendar_scale
-    ical_property :prodid, :product_id
-    ical_property :version
-    ical_property :ip_method
-
-    def initialize()
-      super("VCALENDAR")
+    required_property :version
+    required_property :prodid
+    optional_single_property :calscale
+    optional_single_property :ip_method
 
-      # 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 by apps that use the library
-      self.version = "2.0" # Version of the specification
-    end
-
-    def print_headers
-      "VERSION:#{version}\r\n"
-    end
+    component :timezone, :tzid
+    component :event
+    component :todo
+    component :journal
+    component :freebusy
 
-    def properties_to_print
-      @properties.select { |k,v| k != 'version' }
+    def initialize
+      super 'calendar'
+      self.prodid = 'icalendar-ruby'
+      self.version = '2.0'
+      self.calscale = 'GREGORIAN'
     end
 
-    def event(&block)
-      calendar_tzid = timezone_id
-      build_component Event.new do
-        # Note: I'm not sure this is the best way to pass this down, but it works
-        self.tzid = calendar_tzid
-
-        if block
-          instance_eval(&block)
-          if tzid
-            dtstart.ical_params = { "TZID" => tzid }
-            dtend.ical_params = { "TZID" => tzid } unless dtend.nil?
-          end
-        end
-      end
-    end
-
-    def find_event(uid)
-      events.find {|e| e.uid == uid}
-    end
-
-    def todo(&block)
-      build_component Todo.new, &block
-    end
-
-    def find_todo(uid)
-      todos.find {|t| t.uid == uid}
-    end
-
-    def journal(&block)
-      build_component Journal.new, &block
-    end
-
-    def find_journal(uid)
-      journals.find {|j| j.uid == uid}
-    end
-
-    def freebusy(&block)
-      build_component Freebusy.new, &block
-    end
-
-    def find_freebusy(uid)
-      freebusys.find {|f| f.uid == uid}
-    end
-
-    def timezone(&block)
-      build_component Timezone.new, &block
-    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
-      self.ip_method = "PUBLISH"
+      self.ip_method = 'PUBLISH'
     end
+  end
 
-    private
-
-      def build_component(component, &block)
-        add_component component
-        component.instance_eval(&block) if block
-        component
-      end
-
-      def timezone_id
-        timezones[0].tzid if timezones.length > 0
-      end
-  end # class Calendar
-
-end # module Icalendar
+end

data/lib/icalendar/component.rb

@@ -1,432 +1,70 @@
-=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 'socket'
 
 module Icalendar
-  require 'socket'
-
-  MAX_LINE_LENGTH = 75
-
-  class Geo < Icalendar::Base
-    attr_accessor :latitude, :longitude
-    alias :lat :latitude
-    alias :lat= :latitude=
-    alias :long :longitude
-    alias :long= :longitude=
-
-    def initialize(lat, long)
-      @latitude = lat
-      @longitude = long
-    end
-
-    def to_ical
-      "#{@latitude.to_ical};#{@longitude.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
-  # 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
-
-    CAL_EXTENSION_REGEX = /\Ax_[a-z_]+=?\Z/
 
-    meta_include HashAttrs
+  class Component
+    include HasProperties
+    include HasComponents
 
     attr_reader :name
-    attr_accessor :properties
+    attr_reader :ical_name
+    attr_accessor :parent
 
-    @@multi_properties = {}
-    @@multiline_properties = {}
-
-    def initialize(name)
+    def initialize(name, ical_name = nil)
       @name = name
-      @components = Hash.new { |h, k| h[k] = [] }
-      @properties = {}
-
-      @@logger.info("New #{@name[1,@name.size].capitalize}...")
-    end
-
-    # Add a sub-component to the current component object.
-    def add_component(component)
-      @components[component.key_name] << 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)
-      @components[component.key_name].delete(component)
+      @ical_name = ical_name || "V#{name.upcase}"
+      super()
     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
-      printer do
-        [print_headers,
-          print_properties,
-          print_subcomponents].join
-      end
-    end
-
-    # Print this icalendar component
-    def print_component
-      to_ical
+      [
+        "BEGIN:#{ical_name}",
+        ical_properties,
+        ical_components,
+        "END:#{ical_name}\r\n"
+      ].compact.join "\r\n"
     end
 
-    def print_subcomponents
-      @components.values.map do |component_parts|
-        Array(component_parts).map &:to_ical
-      end.join
-    end
-
-    def printer
-      ["BEGIN:#{@name.upcase}\r\n",
-      yield,
-      "END:#{@name.upcase}\r\n"].join
-    end
-
-    def print_properties(properties = properties_to_print)
-      excludes = %w(geo rrule categories exdate)
-      properties.sort.map do |key, val|
-        property = fix_conflict_with_built_in(key)
-        prelude = property.gsub(/_/, '-').upcase
-
-        if multiline_property? property
-          val.map do |part|
-            params = print_parameters part
-            value = escape_chars ":#{part.to_ical}"
-            chunk_lines "#{prelude}#{params}#{value}"
-          end.join
-        else
-          params = print_parameters val
-          value = ":#{val.to_ical}"
-          value = escape_chars(value) unless excludes.include? property
-          chunk_lines "#{prelude}#{params}#{value}"
-        end
-      end.join
-    end
-
-    # Take out underscore for property names that conflicted
-    # with built-in words.
-    def fix_conflict_with_built_in(key)
-      key.sub(/\Aip_/, '')
-    end
-
-    def escape_chars(value)
-      value.gsub("\\", "\\\\").gsub("\r\n", "\n").gsub("\r", "\n").gsub("\n", "\\n").gsub(",", "\\,").gsub(";", "\\;")
-    end
-
-    def chunk_lines(str, length = MAX_LINE_LENGTH, separator = "\r\n ")
-      chunks = str.scan(/.{1,#{length}}/)
-      lines = chunks.join(separator) << separator
-      lines.gsub(/ *$/, '')
-    end
-
-    # Print the parameters for a specific property.
-    def print_parameters(value)
-      return "" unless value.respond_to?(:ical_params)
-
-      Array(value.ical_params).map do |key, val|
-        val = Array(val)
-        next if val.empty?
-
-        escaped = val.map { |v| Parser.escape(v.to_ical) }.join(',')
-        ";#{key}=" << escaped
-      end.join
-    end
-
-    def properties_to_print
-      @properties # subclasses can exclude properties
-    end
-
-    def print_headers
-      "" # subclasses can specify headers
-    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.downcase)
-    end
-
-    def multiline_property?(name)
-      @@multiline_properties.has_key?(name.downcase)
-    end
-
-    # Make it protected so we can monitor usage...
-    protected
-
-    def key_name
-      (self.class.to_s.downcase + 's').gsub('icalendar::', '').to_sym
-    end
-
-    def self.ical_component(*syms)
-      hash_accessor :@components, *syms
-    end
-
-    # Define a set of methods supporting a new property
-    def self.ical_property(property, alias_name = nil, prop_name = nil)
-      property = "#{property}".strip.downcase
-      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.downcase unless prop_name.nil?
-
-      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 self.ical_multi_property(property, singular, plural)
-      property = "#{property}".strip.downcase.gsub(/-/, '_')
-      plural = "#{plural}".strip.downcase
-
-      # Set this key so the parser knows to use an array for
-      # storing this property type.
-      @@multi_properties["#{property}"] = true
-
-      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
-
-    # Define a set of methods defining a new property, which
-    # supports multiple values in multiple lines with same property name
-    def self.ical_multiline_property(property, singular, plural)
-      @@multiline_properties["#{property}"] = true
-      ical_multi_property(property, singular, plural)
-    end
-
-
     private
 
-    def self.generate_getter(property, alias_name)
-      unless instance_methods.include? property
-        code = <<-code
-            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?
-                val = FrozenProxy.new val if val.frozen?
-                # 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", 219
-        alias_method("#{alias_name}", "#{property}") unless alias_name.nil?
-      end
-    end
-
-    def self.generate_setter(property, alias_name)
-      setter = property + '='
-      unless instance_methods.include? setter
-        code = <<-code
-            def #{setter}(val)
-              #{property}(val)
-            end
-        code
-
-        class_eval code, "component.rb", 233
-        alias_method("#{alias_name}=", "#{property+'='}") unless alias_name.nil?
-      end
-    end
-
-    def self.generate_query(property, alias_name)
-      query = "#{property}?"
-      unless instance_methods.include? query
-        code = <<-code
-            def #{query}
-              @properties.has_key?("#{property.downcase}")
-            end
-        code
-
-        class_eval code, "component.rb", 226
-
-        alias_method("#{alias_name}\?", "#{query}") unless alias_name.nil?
-      end
-    end
-
-    def self.generate_multi_getter(property, plural)
-      # Getter for whole array
-      unless instance_methods.include? plural
-        code = <<-code
-            def #{plural}(a = nil, params = nil)
-              if a.nil?
-                @properties["#{property}"] || []
-              else
-                self.#{plural}=(a).tap do |val|
-                  unless params.nil?
-                    unless val.respond_to?(:ical_params)
-                      val.class.class_eval { attr_accessor :ical_params }
-                    end
-                    val.ical_params = params
-                  end
-                end
-              end
-            end
-        code
-
-        class_eval code, "component.rb", 186
-        alias_method property, plural
-      end
-    end
-
-    def self.generate_multi_setter(property, plural)
-      # Setter for whole array
-      unless instance_methods.include? plural+'+'
-        code = <<-code
-            def #{plural}=(a)
-              if a.respond_to?(:to_ary)
-                @properties["#{property}"] = a.to_ary
-              elsif a =~ /^[^"].*(?<!\\\\),.*[^"]$/
-                @properties["#{property}"] = a.split(/(?<!\\\\),/).to_ary
-              else
-                (@properties["#{property}"] ||= []) << a
-              end
-            end
-        code
-
-        class_eval code, "component.rb", 198
-      end
-    end
-
-    def self.generate_multi_query(property, plural)
-      # Query for any of these properties
-      unless instance_methods.include? plural+'?'
-        code = <<-code
-            def #{plural}?
-              @properties.has_key?("#{property}")
-            end
-        code
-
-        class_eval code, "component.rb", 210
-      end
+    def ical_properties
+      (self.class.properties + custom_properties.keys).map do |prop|
+        value = send prop
+        unless value.nil?
+          if value.is_a? ::Array
+            value.map do |part|
+              ical_fold "#{ical_prop_name prop}#{part.to_ical self.class.default_property_types[prop]}"
+            end.join "\r\n" unless value.empty?
+          else
+            ical_fold "#{ical_prop_name prop}#{value.to_ical self.class.default_property_types[prop]}"
+          end
+        end
+      end.compact.join "\r\n"
     end
 
-    def self.generate_multi_adder(property, singular)
-      adder = "add_"+singular.to_s
-      # Add another item to this properties array
-      unless instance_methods.include? adder
-        code = <<-code
-            def #{adder}(val, params = {})
-              unless val.respond_to?(:to_ical)
-                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
-                @properties["#{property}"] = [val]
-              end
-            end
-        code
-
-        class_eval code, "component.rb", 289
-        alias_method("add_#{property.downcase}", "#{adder}")
-      end
+    def ical_prop_name(prop_name)
+      prop_name.gsub(/\Aip_/, '').gsub('_', '-').upcase
     end
 
-    def self.generate_multi_remover(property, singular)
-      # Remove an item from this properties array
-      unless instance_methods.include? "remove_#{singular}"
-        code = <<-code
-            def remove_#{singular}(a)
-              if @properties.has_key?("#{property}")
-                @properties["#{property}"].delete(a)
-              end
-            end
-        code
-
-        class_eval code, "component.rb", 303
-        alias_method("remove_#{property.downcase}", "remove_#{singular}")
-      end
+    def ical_fold(content_line)
+      split = content_line.split ''
+      [].tap { |a| a << split.shift(Icalendar::MAX_LINE_LENGTH).join until split.empty? }.join "\r\n "
     end
 
-    public
-
-    def method_missing(method_name, *args, &block)
-      # Allow proprietary calendar extensions to be set
-      #
-      # Example:
-      #   cal.x_wr_calname = "iCalendar Calendar"
-      if method_name =~ CAL_EXTENSION_REGEX
-
-        # Make sure to remove '=' from the end of the method_name so we can
-        # define it
-        name = method_name.to_s.chomp '='
-
-        self.class.class_eval do
-          ical_multiline_property name, name, name
+    def ical_components
+      collection = []
+      (self.class.components + custom_components.keys).each do |component_name|
+        components = send component_name
+        components.each do |component|
+          collection << component.to_ical
         end
-        send method_name, *args
-      else
-        super
       end
+      collection.empty? ? nil : collection.join.chomp("\r\n")
     end
+  end
 
-    def respond_to_missing?(method_name, include_private = false)
-      method_name.to_s =~ CAL_EXTENSION_REGEX || super
-    end
-  end # class Component
 end