icalendar 1.5.4 → 2.0.0.beta.1

data/lib/icalendar/event.rb

@@ -0,0 +1,51 @@
+module Icalendar
+
+  class Event < Component
+    required_property :dtstamp, Icalendar::Values::DateTime
+    required_property :uid
+    # dtstart only required if calendar's method is nil
+    required_property :dtstart, Icalendar::Values::DateTime,
+                      ->(event, dtstart) { !dtstart.nil? || !(event.parent.nil? || event.parent.ip_method.nil?) }
+
+    optional_single_property :dtend, Icalendar::Values::DateTime
+    optional_single_property :duration, Icalendar::Values::Duration
+    mutually_exclusive_properties :dtend, :duration
+
+    optional_single_property :ip_class
+    optional_single_property :created, Icalendar::Values::DateTime
+    optional_single_property :description
+    optional_single_property :geo, Icalendar::Values::Float
+    optional_single_property :last_modified, Icalendar::Values::DateTime
+    optional_single_property :location
+    optional_single_property :organizer, Icalendar::Values::CalAddress
+    optional_single_property :priority, Icalendar::Values::Integer
+    optional_single_property :sequence, Icalendar::Values::Integer
+    optional_single_property :status
+    optional_single_property :summary
+    optional_single_property :transp
+    optional_single_property :url, Icalendar::Values::Uri
+    optional_single_property :recurrence_id, Icalendar::Values::DateTime
+
+    optional_property :rrule, Icalendar::Values::Recur, true
+    optional_property :attach, Icalendar::Values::Uri
+    optional_property :attendee, Icalendar::Values::CalAddress
+    optional_property :categories
+    optional_property :comment
+    optional_property :contact
+    optional_property :exdate, Icalendar::Values::DateTime
+    optional_property :request_status
+    optional_property :related_to
+    optional_property :resources
+    optional_property :rdate, Icalendar::Values::DateTime
+
+    component :alarm, false
+
+    def initialize
+      super 'event'
+      self.dtstamp = Icalendar::Values::DateTime.new Time.now.utc, 'tzid' => 'UTC'
+      self.uid = new_uid
+    end
+
+  end
+
+end

data/lib/icalendar/freebusy.rb

@@ -0,0 +1,27 @@
+module Icalendar
+
+  class Freebusy < Component
+
+    required_property :dtstamp, Icalendar::Values::DateTime
+    required_property :uid
+
+    optional_single_property :contact
+    optional_single_property :dtstart, Icalendar::Values::DateTime
+    optional_single_property :dtend, Icalendar::Values::DateTime
+    optional_single_property :organizer, Icalendar::Values::CalAddress
+    optional_single_property :url, Icalendar::Values::Uri
+
+    optional_property :attendee, Icalendar::Values::CalAddress
+    optional_property :comment
+    optional_property :freebusy, Icalendar::Values::Period
+    optional_property :request_status
+
+    def initialize
+      super 'freebusy'
+      self.dtstamp = Icalendar::Values::DateTime.new Time.now.utc, 'tzid' => 'UTC'
+      self.uid = new_uid
+    end
+
+  end
+
+end

data/lib/icalendar/has_components.rb

@@ -0,0 +1,83 @@
+module Icalendar
+
+  module HasComponents
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_eval do
+        attr_reader :custom_components
+      end
+    end
+
+    def initialize(*args)
+      @custom_components = Hash.new { |h, k| h[k] = [] }
+      super
+    end
+
+    def add_component(c)
+      c.parent = self
+      yield c if block_given?
+      send("#{c.name.downcase}s") << c
+      c
+    end
+
+    def method_missing(method, *args, &block)
+      method_name = method.to_s
+      if method_name =~ /^add_(x_\w+)$/
+        component_name = $1
+        custom = args.first || Component.new(component_name, component_name.upcase)
+        custom_components[component_name] << custom
+        yield custom if block_given?
+        custom
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      method_name.to_s.start_with?('add_x_') || super
+    end
+
+    module ClassMethods
+      def components
+        @components ||= []
+      end
+
+      def component(singular_name, find_by = :uid, klass = nil)
+        components = "#{singular_name}s"
+        self.components << components
+        component_var = "@#{components}"
+
+        define_method components do
+          if instance_variable_defined? component_var
+            instance_variable_get component_var
+          else
+            instance_variable_set component_var, []
+          end
+        end
+
+        define_method singular_name do |c = nil, &block|
+          if c.nil?
+            c = begin
+              klass ||= Icalendar.const_get singular_name.capitalize
+              klass.new
+            rescue NameError => ne
+              puts "WARN: #{ne.message}"
+              Component.new singular_name
+            end
+          end
+          add_component c, &block
+        end
+
+        define_method "find_#{singular_name}" do |id|
+          send(components).find { |c| c.send(find_by) == id }
+        end if find_by
+
+        define_method "add_#{singular_name}" do |c|
+          send singular_name, c
+        end
+      end
+    end
+  end
+
+end

data/lib/icalendar/has_properties.rb

@@ -0,0 +1,156 @@
+module Icalendar
+
+  module HasProperties
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_eval do
+        attr_reader :custom_properties
+      end
+    end
+
+    def initialize(*args)
+      @custom_properties = Hash.new { |h, k| h[k] = [] }
+      super
+    end
+
+    def valid?(strict = false)
+      self.class.required_properties.each_pair do |prop, validator|
+        validator.call(self, send(prop)) or return false
+      end
+      self.class.mutex_properties.each do |mutexprops|
+        mutexprops.map { |p| send p }.compact.size > 1 and return false
+      end
+      if strict
+        self.class.suggested_single_properties.each do |single_prop|
+          send(single_prop).size > 1 and return false
+        end
+      end
+      true
+    end
+
+    def method_missing(method, *args, &block)
+      method_name = method.to_s
+      if method_name.start_with? 'x_'
+        if method_name.end_with? '='
+          if args.first.is_a? Icalendar::Value
+            custom_properties[method_name.chomp('=')] << args.first
+          else
+            custom_properties[method_name.chomp('=')] << Icalendar::Values::Text.new(args.first)
+          end
+        else
+          custom_properties[method_name]
+        end
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      method.to_s.start_with?('x_') || super
+    end
+
+    module ClassMethods
+      def properties
+        single_properties + multiple_properties
+      end
+
+      def single_properties
+        @single_properties ||= []
+      end
+
+      def multiple_properties
+        @multiple_properties ||= []
+      end
+
+      def required_properties
+        @required_properties ||= {}
+      end
+
+      def suggested_single_properties
+        @suggested_single_properties ||= []
+      end
+
+      def mutex_properties
+        @mutex_properties ||= []
+      end
+
+      def default_property_types
+        @default_property_types ||= Hash.new { |h,k| Icalendar::Values::Text }
+      end
+
+      def required_property(prop, klass = Icalendar::Values::Text, validator = nil)
+        validator ||= ->(component, value) { !value.nil? }
+        self.required_properties[prop] = validator
+        single_property prop, klass
+      end
+
+      def required_multi_property(prop, klass = Icalendar::Values::Text, validator = nil)
+        validator ||= ->(component, value) { !value.compact.empty? }
+        self.required_properties[prop] = validator
+        multi_property prop, klass
+      end
+
+      def optional_single_property(prop, klass = Icalendar::Values::Text)
+        single_property prop, klass
+      end
+
+      def mutually_exclusive_properties(*properties)
+        self.mutex_properties << properties
+      end
+
+      def optional_property(prop, klass = Icalendar::Values::Text, suggested_single = false)
+        self.suggested_single_properties << prop if suggested_single
+        multi_property prop, klass
+      end
+
+      def single_property(prop, klass)
+        self.single_properties << prop.to_s
+        self.default_property_types[prop.to_s] = klass
+
+        define_method prop do
+          instance_variable_get "@#{prop}"
+        end
+
+        define_method "#{prop}=" do |value|
+          instance_variable_set "@#{prop}", map_property_value(value, klass, false)
+        end
+      end
+
+      def multi_property(prop, klass)
+        self.multiple_properties << prop.to_s
+        self.default_property_types[prop.to_s] = klass
+        property_var = "@#{prop}"
+
+        define_method "#{prop}=" do |value|
+          instance_variable_set property_var, [map_property_value(value, klass, true)].compact
+        end
+
+        define_method prop do
+          if instance_variable_defined? property_var
+            instance_variable_get property_var
+          else
+            send "#{prop}=", nil
+          end
+        end
+
+        define_method "append_#{prop}" do |value|
+          send(prop) << map_property_value(value, klass, true)
+        end
+      end
+    end
+
+    private
+
+    def map_property_value(value, klass, multi_valued)
+      if value.nil? || value.is_a?(Icalendar::Value)
+        value
+      elsif value.is_a? ::Array
+        Icalendar::Values::Array.new value, klass, {}, {delimiter: (multi_valued ? ',' : ';')}
+      else
+        klass.new value
+      end
+    end
+
+  end
+end

data/lib/icalendar/journal.rb

@@ -0,0 +1,39 @@
+module Icalendar
+
+  class Journal < Component
+
+    required_property :dtstamp, Icalendar::Values::DateTime
+    required_property :uid
+
+    optional_single_property :ip_class
+    optional_single_property :created, Icalendar::Values::DateTime
+    optional_single_property :dtstart, Icalendar::Values::DateTime
+    optional_single_property :last_modified, Icalendar::Values::DateTime
+    optional_single_property :organizer, Icalendar::Values::CalAddress
+    optional_single_property :recurrence_id, Icalendar::Values::DateTime
+    optional_single_property :sequence, Icalendar::Values::Integer
+    optional_single_property :status
+    optional_single_property :summary
+    optional_single_property :url, Icalendar::Values::Uri
+
+    optional_property :rrule, Icalendar::Values::Recur, true
+    optional_property :attach, Icalendar::Values::Uri
+    optional_property :attendee, Icalendar::Values::CalAddress
+    optional_property :categories
+    optional_property :comment
+    optional_property :contact
+    optional_property :description
+    optional_property :exdate, Icalendar::Values::DateTime
+    optional_property :request_status
+    optional_property :related_to
+    optional_property :rdate, Icalendar::Values::DateTime
+
+    def initialize
+      super 'journal'
+      self.dtstamp = Icalendar::Values::DateTime.new Time.now.utc, 'tzid' => 'UTC'
+      self.uid = new_uid
+    end
+
+  end
+
+end

data/lib/icalendar/parser.rb

@@ -1,441 +1,113 @@
-=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
-
-require 'date'
-require 'uri'
-require 'stringio'
-
 module Icalendar
 
-  def Icalendar.parse(src, single = false)
-    cals = Icalendar::Parser.new(src).parse
-
-    if single
-      cals.first
-    else
-      cals
-    end
-  end
-
-  class Parser < Icalendar::Base
-    # date = date-fullyear ["-"] date-month ["-"] date-mday
-    # date-fullyear = 4 DIGIT
-    # date-month = 2 DIGIT
-    # date-mday = 2 DIGIT
-    DATE = '(\d\d\d\d)-?(\d\d)-?(\d\d)'
-
-    # time = time-hour [":"] time-minute [":"] time-second [time-secfrac] [time-zone]
-    # time-hour = 2 DIGIT
-    # time-minute = 2 DIGIT
-    # time-second = 2 DIGIT
-    # time-secfrac = "," 1*DIGIT
-    # time-zone = "Z" / time-numzone
-    # time-numzome = sign time-hour [":"] time-minute
-    TIME = '(\d\d):?(\d\d):?(\d\d)(\.\d+)?(Z|[-+]\d\d:?\d\d)?'
-
-    # Defines if this is a strict parser.
-    attr_accessor :strict
-
-    def initialize(src, strict = true)
-      # Setup the parser method hash table
-      setup_parsers
-
-      # The default behavior is to raise an error when the parser
-      # finds an unknown property. Set this to false to discard
-      # unknown properties instead of raising an error.
-      @strict = strict
-
-      if src.respond_to?(:gets)
-        @file = src
-      elsif (not src.nil?) and src.respond_to?(:to_s)
-        @file = StringIO.new(src.to_s, 'r')
-      else
-        raise ArgumentError, "CalendarParser.new cannot be called with a #{src.class} type!"
-      end
-
-      @prev_line = @file.gets
-      @prev_line.chomp! unless @prev_line.nil?
+  class Parser
 
-      @@logger.debug("New Calendar Parser: #{@file.inspect}")
-    end
+    attr_reader :source, :strict
 
-    def self.escape(value)
-      if value =~ %r{\A#{Parser::QSTR}\z|\A#{Parser::PTEXT}\z}
-        value
+    def initialize(source, strict = true)
+      if source.respond_to? :gets
+        @source = source
+      elsif source.respond_to? :to_s
+        @source = StringIO.new source.to_s, 'r'
       else
-        stripped = value.gsub '"', "'"
-        if stripped =~ /\A#{Parser::PTEXT}\z/
-          stripped
-        else
-          %|"#{stripped}"|
-        end
-      end
-    end
-
-    # Define next line for an IO object.
-    # Works for strings now with StringIO
-    def next_line
-      line = @prev_line
-
-      if line.nil?
-        return nil
+        raise ArgumentError, 'Icalendar::Parser.new must be called with a String or IO object'
       end
-
-      # Loop through until we get to a non-continuation line...
-      loop do
-        nextLine = @file.gets
-        @@logger.debug "new_line: #{nextLine}"
-
-        if !nextLine.nil?
-          nextLine.chomp!
-        end
-
-        # If it's a continuation line, add it to the last.
-        # If it's an empty line, drop it from the input.
-        if( nextLine =~ /^[ \t]/ )
-          line << nextLine[1, nextLine.size]
-        elsif( nextLine =~ /^$/ )
-        else
-          @prev_line = nextLine
-          break
-        end
-      end
-      line
+      @strict = strict
     end
 
-    # Parse the calendar into an object representation
     def parse
+      source.rewind
+      @data = source.gets and @data.chomp!
       calendars = []
-
-      @@logger.debug "parsing..."
-      # Outer loop for Calendar objects
-      while (line = next_line)
-        fields = parse_line(line)
-
-        # Just iterate through until we find the beginning of a calendar object
-        if fields[:name] == "BEGIN" and fields[:value] == "VCALENDAR"
-          cal = parse_component Calendar.new
-          @@logger.debug "Added parsed calendar..."
-          calendars << cal
+      while (fields = next_fields)
+        if fields[:name] == 'begin' && fields[:value].downcase == 'vcalendar'
+          calendars << parse_component(Calendar.new)
         end
       end
-
       calendars
     end
 
     private
 
-    # Parse a single VCALENDAR object
-    # -- This should consist of the PRODID, VERSION, option METHOD & CALSCALE,
-    # and then one or more calendar components: VEVENT, VTODO, VJOURNAL,
-    # VFREEBUSY, VTIMEZONE
-    def parse_component(component = Calendar.new)
-      @@logger.debug "parsing new component..."
-
-      while (line = next_line)
-        fields = parse_line(line)
-
-        name = fields[:name].upcase
-
-        # Although properties are supposed to come before components, we should
-        # be able to handle them in any order...
-        if name == "END"
+    def parse_component(component)
+      while (fields = next_fields)
+        if fields[:name] == 'end'
           break
-        elsif name == "BEGIN" # New component
-          case(fields[:value])
-          when "VEVENT" # Event
-            component.add_component parse_component(Event.new)
-          when "VTODO" # Todo entry
-            component.add_component parse_component(Todo.new)
-          when "VALARM" # Alarm sub-component for event and todo
-            component.add_component parse_component(Alarm.new)
-          when "VJOURNAL" # Journal entry
-            component.add_component parse_component(Journal.new)
-          when "VFREEBUSY" # Free/Busy section
-            component.add_component parse_component(Freebusy.new)
-          when "VTIMEZONE" # Timezone specification
-            component.add_component parse_component(Timezone.new)
-          when "STANDARD" # Standard time sub-component for timezone
-            component.add_component parse_component(Standard.new)
-          when "DAYLIGHT" # Daylight time sub-component for timezone
-            component.add_component parse_component(Daylight.new)
-          else # Uknown component type, skip to matching end
-            until ((line = next_line) == "END:#{fields[:value]}"); end
-            next
+        elsif fields[:name] == 'begin'
+          klass_name = fields[:value].gsub(/\AV/, '').downcase.capitalize
+          if Icalendar.const_defined? klass_name
+            component.add_component parse_component(Icalendar.const_get(klass_name).new)
+          elsif Icalendar::Timezone.const_defined? klass_name
+            component.add_component parse_component(Icalendar::Timezone.const_get(klass_name).new)
+          else
+            component.add_component parse_component(Component.new klass_name.downcase, fields[:value])
           end
-        else # If its not a component then it should be a property
-          params = fields[:params]
-          value = fields[:value]
-
-          # Lookup the property name to see if we have a string to
-          # object parser for this property type.
-          if @parsers.has_key?(name)
-            value = @parsers[name].call(name, params, value)
+        else
+          # new property
+          klass = component.class.default_property_types[fields[:name]]
+          if !fields[:params]['value'].nil?
+            klass_name = fields[:params].delete('value').first
+            unless klass_name.upcase == klass.value_type
+              klass_name = klass_name.downcase.gsub(/(?:\A|-)(.)/) { |m| m[-1].upcase }
+              klass = Icalendar::Values.const_get klass_name if Icalendar::Values.const_defined?(klass_name)
+            end
           end
-
-          name = name.downcase
-
-          # TODO: check to see if there are any more conflicts.
-          if name == 'class' or name == 'method' or name == 'name'
-            name = "ip_" + name
+          if klass.value_type != 'RECUR' && fields[:value] =~ /(?<!\\)([,;])/
+            delimiter = $1
+            prop_value = Icalendar::Values::Array.new fields[:value].split(/(?<!\\)[;,]/),
+                                                      klass,
+                                                      fields[:params],
+                                                      delimiter: delimiter
+          else
+            prop_value = klass.new fields[:value], fields[:params]
           end
-
-          # Replace dashes with underscores
-          name = name.gsub('-', '_')
-
-          if component.multiline_property?(name)
-            adder = "add_" + name
-            if component.respond_to?(adder)
-              component.send(adder, value, params)
-            else
-              raise(UnknownPropertyMethod, "Unknown property type: #{adder}") if strict
-            end
+          prop_name = %w(class method).include?(fields[:name]) ? "ip_#{fields[:name]}" : fields[:name]
+          if component.class.multiple_properties.include? prop_name
+            component.send "append_#{prop_name}", prop_value
           else
-            if component.respond_to?(name)
-              component.send(name, value, params)
-            else
-              raise(UnknownPropertyMethod, "Unknown property type: #{name}") if strict
-            end
+            component.send "#{prop_name}=", prop_value
           end
         end
       end
-
       component
     end
 
-    # 1*(ALPHA / DIGIT / "=")
-    NAME    = '[-a-z0-9]+'
-
-    # <"> <Any character except CTLs, DQUOTE> <">
-    QSTR    = '"[^"]*"'
-
-    # Contentline
-    LINE = "(#{NAME})((?:(?:[^:]*?)(?:#{QSTR})(?:[^:]*?))+|(?:[^:]*))\:(.*)"
-
-    # *<Any character except CTLs, DQUOTE, ";", ":", ",">
-    PTEXT   = '[^";:,]*'
-
-    # param-value = ptext / quoted-string
-    PVALUE  = "#{QSTR}|#{PTEXT}"
-
-    # param = name "=" param-value *("," param-value)
-    PARAM = ";(#{NAME})(=?)((?:#{PVALUE})(?:,#{PVALUE})*)"
-
-    def parse_line(line)
-      unless line =~ %r{#{LINE}}i # Case insensitive match for a valid line
-        raise "Invalid line in calendar string!"
-      end
-
-      name = $1.upcase # The case insensitive part is upcased for easier comparison...
-      paramslist = $2
-      value = $3.gsub("\\;", ";").gsub("\\,", ",").gsub("\\n", "\n").gsub("\\\\", "\\")
-
-      # Parse the parameters
-      params = {}
-      if paramslist.size > 1
-        paramslist.scan( %r{#{PARAM}}i ) do
-
-        # parameter names are case-insensitive, and multi-valued
-        pname = $1
-        pvals = $3
-
-        # If there isn't an '=' sign then we need to do some custom
-        # business.  Defaults to 'type'
-        if $2 == ""
-          pvals = $1
-          case $1
-          when /quoted-printable/i
-            pname = 'encoding'
-
-          when /base64/i
-            pname = 'encoding'
-
-          else
-            pname = 'type'
-          end
-        end
-
-        # Make entries into the params dictionary where the name
-        # is the key and the value is an array of values.
-        unless params.key? pname
-          params[pname] = []
-        end
-
-        # Save all the values into the array.
-        pvals.scan( %r{(#{PVALUE})} ) do
-          if $1.size > 0
-            params[pname] << $1
-          end
-        end
+    def next_fields
+      line = @data or return nil
+      loop do
+        @data = source.gets and @data.chomp!
+        if @data =~ /\A[ \t].+\z/
+          line << @data[1, @data.size]
+        elsif @data !~ /\A\s*\z/
+          break
         end
       end
-
-      {:name => name, :value => value, :params => params}
-    end
-
-    ## Following is a collection of parsing functions for various
-    ## icalendar property value data types...  First we setup
-    ## a hash with property names pointing to methods...
-    def setup_parsers
-      @parsers = {}
-
-      # Integer properties
-      m = self.method(:parse_integer)
-      @parsers["PERCENT-COMPLETE"] = m
-      @parsers["PRIORITY"] = m
-      @parsers["REPEAT"] = m
-      @parsers["SEQUENCE"] = m
-
-      # Dates and Times
-      m = self.method(:parse_datetime)
-      @parsers["COMPLETED"] = m
-      @parsers["DTEND"] = m
-      @parsers["DUE"] = m
-      @parsers["DTSTART"] = m
-      @parsers["RECURRENCE-ID"] = m
-      @parsers["CREATED"] = m
-      @parsers["DTSTAMP"] = m
-      @parsers["LAST-MODIFIED"] = m
-      @parsers["ACKNOWLEDGED"] = m
-
-      m = self.method(:parse_multi_datetime)
-      @parsers["EXDATE"] = m
-      @parsers["RDATE"] = m
-
-      # URI's
-      m = self.method(:parse_uri)
-      @parsers["TZURL"] = m
-      @parsers["ATTENDEE"] = m
-      @parsers["ORGANIZER"] = m
-      @parsers["URL"] = m
-
-      # This is a URI by default, and if its not a valid URI
-      # it will be returned as a string which works for binary data
-      # the other possible type.
-      @parsers["ATTACH"] = m
-
-      # GEO
-      m = self.method(:parse_geo)
-      @parsers["GEO"] = m
-
-      #RECUR
-      m = self.method(:parse_recur)
-      @parsers["RRULE"] = m
-      @parsers["EXRULE"] = m
-
-    end
-
-    # Booleans
-    # NOTE: It appears that although this is a valid data type
-    # there aren't any properties that use it...  Maybe get
-    # rid of this in the future.
-    def parse_boolean(name, params, value)
-      if value.upcase == "FALSE"
-        false
-      else
-        true
-      end
+      parse_fields line
     end
 
-    # Dates, Date-Times & Times
-    # NOTE: invalid dates & times will be returned as strings...
-    def parse_datetime(name, params, value)
-      if params["VALUE"] && params["VALUE"].first == "DATE"
-        result = Date.parse(value)
-      else
-        result = DateTime.parse(value)
-        if /Z$/ =~ value
-          timezone = "UTC"
-        else
-          timezone = params["TZID"].first if params["TZID"]
-        end
-        result.icalendar_tzid = timezone
-      end
-      result
-    rescue Exception
-      value
-    end
+    NAME = '[-a-zA-Z0-9]+'
+    QSTR = '"[^"]*"'
+    PTEXT = '[^";:,]*'
+    PVALUE = "(?:#{QSTR}|#{PTEXT})"
+    PARAM = "(#{NAME})=(#{PVALUE}(?:,#{PVALUE})*)"
+    VALUE = '.*'
+    LINE = "(?<name>#{NAME})(?<params>(?:;#{PARAM})*):(?<value>#{VALUE})"
 
-    # Multiple valued Dates
-    def parse_multi_datetime(name, params, value)
-      use_date = params['VALUE'] && params['VALUE'].first == 'DATE'
-      tzid = params['TZIID'].first if params['TZID']
-      result = []
-      value.split(/,/).each do |val|
-        if use_date
-          result << Date.parse(val)
-        else
-          dt = DateTime.parse val
-          if /Z$/ =~ val
-            timezone = 'UTC'
-          else
-            timezone = tzid
-          end
-          dt.icalendar_tzid = timezone
-          result << dt
+    def parse_fields(input)
+      parts = %r{#{LINE}}.match(input) or raise "Invalid iCalendar input line: #{input}"
+      params = {}
+      parts[:params].scan %r{#{PARAM}} do |match|
+        param_name = match[0].downcase
+        params[param_name] ||= []
+        match[1].scan %r{#{PVALUE}} do |param_value|
+          params[param_name] << param_value.gsub(/\A"|"\z/, '') if param_value.size > 0
         end
       end
-      result
-    rescue Exception
-      [value]
-    end
-
-    def parse_recur(name, params, value)
-      [::Icalendar::RRule.new(name, params, value)]
-    end
-
-    # Durations
-    # TODO: Need to figure out the best way to represent durations
-    # so just returning string for now.
-    def parse_duration(name, params, value)
-      value
+      {
+        name: parts[:name].downcase.gsub('-', '_'),
+        params: params,
+        value: parts[:value]
+      }
     end
-
-    # Floats
-    # NOTE: returns 0.0 if it can't parse the value
-    def parse_float(name, params, value)
-      value.to_f
-    end
-
-    # Integers
-    # NOTE: returns 0 if it can't parse the value
-    def parse_integer(name, params, value)
-      value.to_i
-    end
-
-    # Periods
-    # TODO: Got to figure out how to represent periods also...
-    def parse_period(name, params, value)
-      value
-    end
-
-    # Calendar Address's & URI's
-    # NOTE: invalid URI's will be returned as strings...
-    def parse_uri(name, params, value)
-      begin
-        URI.parse(value)
-      rescue Exception
-        value
-      end
-    end
-
-    # Geographical location (GEO)
-    # NOTE: returns an array with two floats (long & lat)
-    # if the parsing fails return the string
-    def parse_geo(name, params, value)
-      strloc = value.split(';')
-      if strloc.size != 2
-        return value
-      end
-
-      Geo.new(strloc[0].to_f, strloc[1].to_f)
-    end
-
   end
 end