kali 0.0.1

data/lib/kali/type/date.rb

@@ -0,0 +1,16 @@
+require "date"
+
+module Kali
+  # Used to represent calendar dates.
+  #
+  # See http://tools.ietf.org/html/rfc5545#section-3.3.4
+  class Type::Date < Type::DateTime
+    def encode!(*)
+      super.split("T").first
+    end
+
+    def decode!(string)
+      ::Date.parse(string)
+    end
+  end
+end

data/lib/kali/type/date_time.rb

@@ -0,0 +1,35 @@
+require "date"
+
+module Kali
+  # Used to represent a precise calendar date and time of day.
+  #
+  # See http://tools.ietf.org/html/rfc5545#section-3.3.5
+  class Type::DateTime < Type
+    def parameters
+      { Parameter::TimeZoneIdentifier => :tzid }
+    end
+
+    def encode!(object)
+      date_time = object.to_datetime
+      date_time.strftime("%Y%m%dT%H%M%S#{detect_timezone(date_time)}")
+    end
+
+    def decode!(string)
+      ::DateTime.parse(string)
+    end
+
+    private
+
+    def detect_timezone(date_time)
+      offset = date_time.to_datetime.zone
+      sign, hour, minute = offset.scan(/(\+|-)(\d{2}):(\d{2})/).flatten
+      offset = Integer("#{sign}1") * (60 * Integer(minute) + 3600 * Integer(hour))
+
+      if offset.zero?
+        "Z"
+      else
+        ""
+      end
+    end
+  end
+end

data/lib/kali/type/duration.rb

@@ -0,0 +1,41 @@
+module Kali
+  # Used to represent a duration of time, which can be nominal (days or weeks)
+  # or accurate (hours, days, minutes, or seconds).
+  #
+  # See http://tools.ietf.org/html/rfc5545#section-3.3.6
+  class Type::Duration < Type
+    LABELS = { week: "W", day: "D", hour: "H", minute: "M", second: "S" }
+
+    def encode!(obj)
+      negative = obj.delete(:negative) { false }
+      duration = obj.sort_by { |label, _| LABELS.key(label) }
+
+      nominal = true
+      duration = obj.each_with_object("") do |(label, amount), acc|
+        suffix = LABELS.fetch(label) do
+          raise ArgumentError, "#{label.inspect} is not a valid duration period. It must be one of #{labels.keys.inspect}"
+        end
+
+        acc << "T" if nominal && !(nominal = nominal?(label))
+        acc << "#{amount}#{suffix}"
+      end
+
+      "#{"-" if negative}P#{duration}"
+    end
+
+    def decode!(string)
+      duration = {}
+      duration[:negative] = true if string.start_with?("-")
+      matches = string.gsub(/\-\+PT/, "").scan(/((\d+)([WDHMS]))/)
+      matches.each.with_object(duration) do |(_, n, suffix), duration|
+        duration[LABELS.key(suffix)] = Integer(n)
+      end
+    end
+
+    private
+
+    def nominal?(key)
+      [:week, :day].include?(key)
+    end
+  end
+end

data/lib/kali/type/float.rb

@@ -0,0 +1,14 @@
+module Kali
+  # Used to represent floating point numbers.
+  #
+  # See http://tools.ietf.org/html/rfc5545#section-3.3.7
+  class Type::Float < Type
+    def encode!(object)
+      Float(object).to_s
+    end
+
+    def decode!(string)
+      Float(string)
+    end
+  end
+end

data/lib/kali/type/geo.rb

@@ -0,0 +1,21 @@
+module Kali
+  # Meta type (not defined in the RFC) for parsing and serializing
+  # GeographicPosition properties.
+  class Type::Geo < Type
+    def initialize(rule = nil)
+      super(->(o) { Array === o && o.size == 2 && (rule.nil? || rule === o) })
+      @latitude  = Type::Float.new(-90..90)
+      @longitude = Type::Float.new(-180..180)
+    end
+
+    def encode!(object)
+      [@latitude.encode(object.at(0)),
+       @longitude.encode(object.at(1))].join(";")
+    end
+
+    def decode!(string)
+      lat, lng = String(string).split(";")
+      [@latitude.decode(lat), @longitude.decode(lng)]
+    end
+  end
+end

data/lib/kali/type/integer.rb

@@ -0,0 +1,14 @@
+module Kali
+  # Used to represent integer numbers.
+  #
+  # See http://tools.ietf.org/html/rfc5545#section-3.3.8
+  class Type::Integer < Type
+    def encode!(object)
+      Integer(object).to_s
+    end
+
+    def decode!(string)
+      Integer(string)
+    end
+  end
+end

data/lib/kali/type/list.rb

@@ -0,0 +1,37 @@
+module Kali
+  # Meta type (not explicitly defined in the RFC as a property type) to parse
+  # and serialize lists of other values. Lists are strongly typed, with elements
+  # of only one type occurring inside a list.
+  #
+  # See http://tools.ietf.org/html/rfc5545#section-3.1.1
+  class Type::List < Type
+    def initialize(subtype, restriction = nil)
+      super(restriction)
+      @subtype = subtype
+    end
+
+    def encode!(object)
+      object.map { |el| @subtype.encode(el) }.join(",")
+    end
+
+    def decode!(string)
+      tentative_parts = string.split(",")
+      parts = []
+      in_group = false
+      group_size = 1
+      tentative_parts.each.with_index do |part, index|
+        if part[-1] == "\\"
+          group_size += 1
+          in_group = true
+        elsif in_group
+          parts << tentative_parts[index - group_size + 1, group_size].join(",")
+          group_size = 1
+          in_group = false
+        else
+          parts << part
+        end
+      end
+      parts.map { |part| @subtype.decode(part) }
+    end
+  end
+end

data/lib/kali/type/quoted.rb

@@ -0,0 +1,18 @@
+module Kali
+  # Meta-type that just wraps a different type in double quote characters when
+  # encoding it, or takes out the quotes when decoding it.
+  class Type::Quoted < Type
+    def initialize(type, restriction = nil)
+      super(restriction)
+      @type = type
+    end
+
+    def encode!(object)
+      %Q("#{@type.encode(object)}")
+    end
+
+    def decode!(string)
+      @type.decode(string.gsub(/^"|"$/, ""))
+    end
+  end
+end

data/lib/kali/type/text.rb

@@ -0,0 +1,31 @@
+module Kali
+  # Used to represent strings of text.
+  #
+  # See http://tools.ietf.org/html/rfc5545#section-3.3.11
+  class Type::Text < Type
+    def parameters
+      {
+        Parameter::Language                => :language,
+        Parameter::AlternateRepresentation => :altrep
+      }
+    end
+
+    def encode!(object)
+      str = object.to_s.dup
+      str.gsub! "\\", "\\\\"
+      str.gsub! "\n", "\\n"
+      str.gsub! ";", "\\;"
+      str.gsub! ",", "\\,"
+      str
+    end
+
+    def decode!(string)
+      str = string.to_s.dup
+      str.gsub! "\\,", ","
+      str.gsub! "\\;", ";"
+      str.gsub! "\\n", "\n"
+      str.gsub! "\\\\", "\\"
+      str
+    end
+  end
+end

data/lib/kali/type/time.rb

@@ -0,0 +1,17 @@
+require "time"
+
+module Kali
+  # Used to represent precise times of the day.
+  #
+  # See http://tools.ietf.org/html/rfc5545#section-3.3.12
+  class Type::Time < Type::DateTime
+    def encode!(*)
+      super.split("T").last
+    end
+
+    def decode!(string)
+      _, hour, minute, second, utc = *string.match(/(\d{2})(\d{2})(\d{2})?(Z)?/)
+      ::Time.parse([hour, minute, second || "00"].join(":") + utc.to_s)
+    end
+  end
+end

data/lib/kali/type/uri.rb

@@ -0,0 +1,16 @@
+require "uri"
+
+module Kali
+  # Used to represent URIs in properties.
+  #
+  # See http://tools.ietf.org/html/rfc5545#section-3.3.13
+  class Type::URI < Type
+    def encode!(uri)
+      uri.to_s
+    end
+
+    def decode!(string)
+      ::URI.parse(string)
+    end
+  end
+end

data/lib/kali/typed_list.rb

@@ -0,0 +1,52 @@
+module Kali
+  # Public: List of objects that have a specific type in them. Useful for lists
+  # of properties (like ATTENDEE or COMMENT, that can have multiple instances of
+  # the same property in a component) or sub-components.
+  class TypedList
+    include Enumerable
+
+    # Internal: Initialize the List.
+    #
+    # type - The type of objects that this list contains.
+    def initialize(type)
+      @type = type
+      @items = []
+    end
+
+    # Public: Add a new item to the list.
+    #
+    # value - The item to be added. If it's an instance of the type of the list,
+    #         then it adds it directly, otherwise it passes this to the
+    #         constructor of that type. If it's `nil` it's ignored and just an
+    #         empty new instance of the correct type is added to the list.
+    #
+    # Returns the list.
+    # Yields the Property if a block is passed.
+    def add(value = nil)
+      item = case value
+      when @type; value
+      when nil;   @type.new
+      else        @type.new(value)
+      end
+
+      yield item if block_given?
+      @items << item
+      self
+    end
+    alias_method :<<, :add
+
+    # Public: Get an iCalendar representation of this list of properties.
+    #
+    # Returns a String.
+    def to_ics
+      @items.map(&:to_ics).join("\n")
+    end
+
+    # Internal: Iterate over the properties in this list.
+    #
+    # Yields each property in turn.
+    def each(&block)
+      @items.each(&block)
+    end
+  end
+end

data/lib/kali/utils.rb

@@ -0,0 +1,6 @@
+module Kali
+  module Utils
+    autoload :Text,  "kali/utils/text"
+    autoload :Named, "kali/utils/named"
+  end
+end

data/lib/kali/utils/named.rb

@@ -0,0 +1,17 @@
+module Kali
+  module Utils
+    module Named
+      # Public: Get/Set the name of the property implemented by this class.
+      def name(name = nil)
+        @name = name if name
+        @name
+      end
+
+      # Public: Get a default name for the method used as an accessor for this
+      # property, based on the name of the property.
+      def method_name
+        @method_name ||= name.to_s.downcase.gsub("-", "_") unless name.nil?
+      end
+    end
+  end
+end

data/lib/kali/utils/text.rb

@@ -0,0 +1,42 @@
+module Kali
+  module Utils
+    module Text
+      module_function
+
+      # Public: Fold lines as indicated by the Content Lines section of
+      # [RFC5545](http://tools.ietf.org/html/rfc5545#section-3.1).
+      #
+      # FIXME: This is splitting into 75 *character* long lines, and not 75
+      # *octet* long lines. We should deal with UTF-8 properly.
+      #
+      # line - A String.
+      #
+      # Returns a multi-line String.
+      def fold_line(line)
+        head, tail = line[0...75], line[75..-1]
+        tail &&= tail.scan(/.{0,74}/)
+          .reject { |fragment| fragment.nil? || fragment.empty? }
+          .map { |fragment| " #{fragment}" }
+        [head, *tail].join("\r\n")
+      end
+
+      # Public: Collapse a folded line into a single line without line breaks. See
+      # `TextUtils.fold_line`, and [RFC5545][rfc].
+      #
+      # [rfc]: http://tools.ietf.org/html/rfc5545#section-3.1
+      #
+      # FIXME: This isn't taking into account that the line could have been folded
+      # in the middle of a multi-byte character.
+      #
+      # lines - A multi-line String that follows the folding format specified by
+      # the RFC.
+      #
+      # Returns a String.
+      def unfold_line(lines)
+        head, *tail = lines.split("\r\n")
+        tail.map! { |line| line[1..-1] }
+        [head, *tail].join("")
+      end
+    end
+  end
+end

data/lib/kali/version.rb

@@ -0,0 +1,3 @@
+module Kali
+  VERSION = "0.0.1"
+end

data/test/component/calendar_test.rb

@@ -0,0 +1,20 @@
+require "test_helper"
+
+class CalendarTest < MiniTest::Unit::TestCase
+  def test_calendar_defaults
+    cal = Kali::Calendar.new
+    assert_equal Kali::Property::ProductIdentifier.default, cal.prodid.to_s
+    assert_equal Kali::Property::Version.default,           cal.version.to_s
+    assert_equal Kali::Property::CalendarScale.default,     cal.calscale.to_s
+  end
+
+  def test_calendar_overwrites_default_properties
+    cal = Kali::Calendar.new do |calendar|
+      calendar.prodid = "Product Id"
+      calendar.method = "REQUEST"
+    end
+
+    assert_equal "Product Id", cal.prodid.value
+    assert_equal "REQUEST",    cal.method.value
+  end
+end

data/test/component/event_test.rb

@@ -0,0 +1,17 @@
+require "test_helper"
+
+class EventTest < MiniTest::Unit::TestCase
+  def test_event_properties
+    event = Kali::Event.new do |e|
+      e.sequence = 0
+      e.uid = 1
+      e.description = "Some description about the event"
+      e.geo = [-54.458594, -34.123310]
+      e.categories = ["CATEGORY A", "CATEGORY B"]
+      e.comments.add do |comment|
+        comment.value = "This is a comment --John"
+      end
+      e.comments.add "This is another comment --Jane"
+    end
+  end
+end