taskjuggler 0.1.1 → 0.2.0

data/lib/taskjuggler/ICalendar.rb

@@ -0,0 +1,251 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = ICalendar.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011
+#               by Chris Schlaeger <chris@linux.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+require 'taskjuggler/Tj3Config'
+
+class TaskJuggler
+
+  # This class implements a very basic RFC5545 compliant iCalendar file
+  # generator. It currently only supports a very small subset of the tags that
+  # are needed for TaskJuggler.
+  class ICalendar
+
+    # The maximum allowed length of a content line without line end character.
+    LINELENGTH = 75
+
+    # Utility class to store name and email of a person.
+    class Person < Struct.new(:name, :email)
+    end
+
+    # Base class for all ICalendar components.
+    class Component
+
+      attr_accessor :description, :relatedTo, :organizer
+      attr_reader :uid
+
+      def initialize(ical, uid, summary, startDate)
+        @ical = ical
+        @type = self.class.to_s.split('::').last.upcase
+        @uid = uid + "-#{@type}"
+        @summary = summary
+        @startDate = startDate
+
+        # Optional attributes
+        @description = nil
+        @relatedTo = nil
+        @organizer = nil
+        @attendees = []
+      end
+
+      def setOrganizer(name, email)
+        @organizer = Person.new(name, email)
+      end
+
+      def addAttendee(name, email)
+        @attendees << Person.new(name, email)
+      end
+
+      def to_s
+        str = <<"EOT"
+BEGIN:V#{@type}
+DTSTAMP:#{dateTime(TjTime.new.utc)}
+CREATED:#{dateTime(@ical.creationDate)}
+UID:#{@uid}
+LAST-MODIFIED:#{dateTime(@ical.lastModified)}
+SUMMARY:#{quoted(@summary)}
+DTSTART:#{dateTime(@startDate)}
+EOT
+        str += "DESCRIPTION:#{quoted(@description)}\n" if @description
+        str += "RELATED-TO:#{@relatedTo}\n" if @relatedTo
+
+        if @organizer
+          str += "ORGANIZER;CN=#{@organizer.name}:mailto:#{@organizer.email}\n"
+        end
+        @attendees.each do |attendee|
+          str += "ATTENDEE;CN=#{attendee.name}:mailto:#{attendee.email}\n"
+        end
+
+        str += yield if block_given?
+
+        str += "END:V#{@type}\n\n"
+      end
+
+      private
+
+      def dateTime(date)
+        @ical.dateTime(date)
+      end
+
+      def quoted(str)
+        str.gsub(/([;,"\\])/, '\\\\\1').gsub(/\n/, '\n')
+      end
+
+    end
+
+    # Stores the data of an VTODO component and can generate one.
+    class Todo < Component
+
+      attr_accessor :priority, :percentComplete
+
+      # Create the Todo object with some mandatory data. _ical_ is a reference
+      # to the parent ICalendar object. _uid_ is a unique pattern used to
+      # generate the UID tag. _summary_ is a String for SUMMARY. _startDate_
+      # is used to generate DTSTART. _endDate_ is used to either generate
+      # the COMPLETED or DUE tag.
+      def initialize(ical, uid, summary, startDate, endDate)
+        super(ical, uid, summary, startDate)
+
+        # Mandatory attributes
+        @ical.addTodo(self)
+        @endDate = endDate
+        # Priority value (0 - 9)
+        @priority = 0
+        @percentComplete = -1
+      end
+
+      # Generate the VTODO record as String.
+      def to_s
+        super do
+          str = ''
+          if @percentComplete < 100.0
+            str += "DUE:#{dateTime(@endDate)}\n"
+          else
+            str += "COMPLETED:#{dateTime(@endDate)}\n"
+          end
+          str += "PERCENT-COMPLETE:#{@percentComplete}\n"
+        end
+      end
+
+    end
+
+    # Stores the data of an VTODO component and can generate one.
+    class Event < Component
+
+      # Create the Event object with some mandatory data. _ical_ is a
+      # reference to the parent ICalendar object. _uid_ is a unique pattern
+      # used to generate the UID tag. _summary_ is a String for SUMMARY.
+      # _startDate_ is used to generate DTSTART. _endDate_ is used to either
+      # generate the COMPLETED or DUE tag.
+      def initialize(ical, uid, summary, startDate, endDate)
+        super(ical, uid, summary, startDate)
+        @ical.addEvent(self)
+
+        # Mandatory attributes
+        @endDate = endDate
+        # Optional attributes
+        @priority = 1
+      end
+
+      # Generate the VEVENT record as String.
+      def to_s
+        super do
+          <<"EOT"
+PRIORITY:#{@priority}
+DTEND:#{dateTime(@endDate)}
+TRANSP:TRANSPARENT
+EOT
+        end
+      end
+
+    end
+
+    class Journal < Component
+
+      def initialize(ical, uid, summary, startDate)
+        super
+        @ical.addJournal(self)
+      end
+
+      def to_s
+        super
+      end
+
+    end
+
+    attr_reader :uid
+    attr_accessor :creationDate, :lastModified
+
+    def initialize(uid)
+      @uid = "#{AppConfig.packageName}-#{uid}"
+      @creationDate = @lastModified = TjTime.new.utc
+
+      @todos = []
+      @events = []
+      @journals = []
+    end
+
+    # Add a new VTODO component. For internal use only!
+    def addTodo(todo)
+      @todos << todo
+    end
+
+    # Add a new VEVENT component. For internal use only!
+    def addEvent(event)
+      @events << event
+    end
+
+    # Add a new VJOURNAL component. For internal user only!
+    def addJournal(journal)
+      @journals << journal
+    end
+
+    def to_s
+      str = <<"EOT"
+BEGIN:VCALENDAR
+PRODID:-//The #{AppConfig.softwareName} Project/NONSGML #{AppConfig.softwareName} #{AppConfig.version}//EN
+VERSION:2.0
+
+EOT
+      @todos.each { |todo| str += todo.to_s }
+      @events.each { |event| str += event.to_s }
+      @journals.each { |journal| str += journal.to_s }
+
+      str << <<"EOT"
+END:VCALENDAR
+EOT
+
+      foldLines(str)
+    end
+
+    def dateTime(date)
+      date.to_s("%Y%m%dT%H%M%SZ")
+    end
+
+    private
+
+    # Make sure that no line is longer than LINELENTH octets (excl. the
+    # newline character)
+    def foldLines(str)
+      newStr = ''
+      str.each_line do |line|
+        bytes = 0
+        line.each_utf8_char do |c|
+          # Make sure we support Ruby 1.8 and 1.9 String handling.
+          cBytes = c.bytesize
+          if bytes + cBytes > LINELENGTH && c != "\n"
+            newStr += "\n "
+            bytes = 0
+          else
+            bytes += cBytes
+          end
+          newStr << c
+        end
+      end
+      # Convert line ends to CR+LF
+      newStr.gsub(/\n/, "\r\n")
+    end
+
+  end
+
+end
+

data/lib/taskjuggler/Interval.rb

@@ -15,89 +15,66 @@ require 'taskjuggler/TjTime'
 
 class TaskJuggler
 
-  # The Interval class provides objects that model a time interval. The start
-  # end end time are represented as seconds after Jan 1, 1970. The start is part
-  # of the interval, the end is not.
+  # This is the based class used to store several kinds of intervals in
+  # derived classes.
   class Interval
 
-    attr_accessor :start, :end
+    attr_reader :start, :end
 
-    # Create a new Interval. _args_ can be three different kind of arguments.
-    #
-    # a and b should be TjTime objects.
-    #
-    # Interval.new(a, b)  | -> Interval(a, b)
-    # Interval.new(a)     | -> Interval(a, a)
-    # Interval.new(iv)    | -> Interval(iv.start, iv.end)
-    #
-    def initialize(*args)
-      if args.length == 1
-        if args[0].is_a?(TjTime)
-          # Just one argument, a date
-          @start = @end = args[0]
-        elsif args[0].is_a?(Interval)
-          # Just one argument, an Interval
-          @start = args[0].start
-          @end = args[0].end
-        else
-          raise "Illegal argument"
-        end
-      elsif args.length == 2
-        # Two arguments, a start and end date
-        @start = args[0]
-        @end = args[1]
-        raise "Interval start must be a date" unless @start.is_a?(TjTime)
-        raise "Interval end must be a date" unless @end.is_a?(TjTime)
-        if @end < @start
-          raise "Invalid interval"
-        end
-      else
-        raise "Illegal arguments"
+    # Create a new Interval object. _s_ is the interval start, _e_ the
+    # interval end (not included).
+    def initialize(s, e)
+      @start = s
+      @end = e
+      # The end must not be before the start.
+      if @end < @start
+        raise ArgumentError, "Invalid interval (#{s} - #{e})"
       end
     end
 
-    # Return the duration of the Interval.
-    def duration
-      @end - @start
-    end
-
-    # Return true if _arg_ is contained within the Interval. It can either be a
-    # single TjTime or another Interval.
+    # Return true if _arg_ is contained within the Interval. It can either
+    # be a single TjTime or another Interval.
     def contains?(arg)
-      if arg.is_a?(TjTime)
-        return @start <= arg && arg < @end
-      else
+      if arg.is_a?(Interval)
+        raise ArgumentError, "Class mismatch" if self.class != arg.class
         return @start <= arg.start && arg.end <= @end
+      else
+        raise ArgumentError, "Class mismatch" if @start.class != arg.class
+        return @start <= arg && arg < @end
       end
     end
 
-    # Check whether the Interval _arg_ overlaps with this interval.
+    # Check whether the Interval _arg_ overlaps with this Interval.
     def overlaps?(arg)
-      if arg.is_a?(TjTime)
-        return @start <= arg && arg < @end
-      else
+      if arg.is_a?(Interval)
+        raise ArgumentError, "Class mismatch" if self.class != arg.class
         return (@start <= arg.start && arg.start < @end) ||
                (arg.start <= @start && @start < arg.end)
+      else
+        raise ArgumentError, "Class mismatch" if @start.class != arg.class
+        return @start <= arg && arg < @end
       end
     end
 
     # Return a new Interval that contains the overlap of self and the Interval
     # _iv_. In case there is no overlap, nil is returned.
     def intersection(iv)
+      raise ArgumentError, "Class mismatch" if self.class != iv.class
       newStart = @start > iv.start ? @start : iv.start
       newEnd = @end < iv.end ? @end : iv.end
-      newStart < newEnd ? Interval.new(newStart, newEnd) : nil
+      newStart < newEnd ? self.class.new(newStart, newEnd) : nil
     end
 
     # Append or prepend the Interval _iv_ to self. If _iv_ does not directly
     # attach to self, just return self.
     def combine(iv)
+      raise ArgumentError, "Class mismatch" if self.class != iv.class
       if iv.end == @start
         # Prepend iv
-        Array.new Interval(iv.start, @end)
+        Array.new self.class.new(iv.start, @end)
       elsif @end == iv.start
         # Append iv
-        Array.new Interval(@start, iv.end)
+        Array.new self.class.new(@start, iv.end)
       else
         self
       end
@@ -106,6 +83,7 @@ class TaskJuggler
     # Compare self with Interval _iv_. This function only works for
     # non-overlapping Interval objects.
     def <=>(iv)
+      raise ArgumentError, "Class mismatch" if self.class != iv.class
       if @end < iv.start
         -1
       elsif iv.end < @start
@@ -116,15 +94,199 @@ class TaskJuggler
 
     # Return true if the Interval _iv_ describes an identical time period.
     def ==(iv)
+      raise ArgumentError, "Class mismatch" if self.class != iv.class
       @start == iv.start && @end == iv.end
     end
 
-    # Turn the Interval into a human readable form.
+  end
+
+  # The TimeInterval class provides objects that model a time interval. The
+  # start end end time are represented as seconds after Jan 1, 1970. The start
+  # is part of the interval, the end is not.
+  class TimeInterval < Interval
+
+    attr_accessor :start, :end
+
+    # Create a new TimeInterval. _args_ can be three different kind of arguments.
+    #
+    # a and b should be TjTime objects.
+    #
+    # TimeInterval.new(a, b)  | -> Interval(a, b)
+    # TimeInterval.new(a)     | -> Interval(a, a)
+    # TimeInterval.new(iv)    | -> Interval(iv.start, iv.end)
+    #
+    def initialize(*args)
+      if args.length == 1
+        if args[0].is_a?(TjTime)
+          # Just one argument, a date
+          super(args[0], args[0])
+        elsif args[0].is_a?(TimeInterval)
+          # Just one argument, a TimeInterval
+          super(args[0].start, args[0].end)
+        else
+          raise ArgumentError, "Illegal argument 1: #{args[0].class}"
+        end
+      elsif args.length == 2
+        # Two arguments, a start and end date
+        unless args[0].is_a?(TjTime)
+          raise ArgumentError, "Interval start must be a date, not a " +
+                "#{args[0].class}"
+        end
+        unless args[1].is_a?(TjTime)
+          raise ArgumentError, "Interval end must be a date, not a" +
+                "#{args[1].class}"
+        end
+        super(args[0], args[1])
+      else
+        raise ArgumentError, "Too many arguments: #{args.length}"
+      end
+    end
+
+    # Return the duration of the TimeInterval.
+    def duration
+      @end - @start
+    end
+
+    # Turn the TimeInterval into a human readable form.
     def to_s
       @start.to_s + ' - ' + @end.to_s
     end
 
   end
 
+  # This class describes an interval of a scoreboard. The start and end of the
+  # interval are stored as indexes but can always be converted back to TjTime
+  # objects if needed.
+  class ScoreboardInterval < Interval
+
+    attr_reader :sbStart, :slotDuration
+
+    # Create a new ScoreboardInterval. _args_ can be three different kind of
+    # arguments.
+    #
+    # sbStart must be a TjTime of the scoreboard start
+    # slotDuration must be the duration of the scoreboard slots in seconds
+    # a and b should be TjTime or Fixnum objects that describe the start and
+    # end time or index of the interval.
+    #
+    # TimeInterval.new(iv)
+    # TimeInterval.new(sbStart, slotDuration, a)
+    # TimeInterval.new(sbStart, slotDuration, a, b)
+    #
+    def initialize(*args)
+      case args.length
+      when 1
+        # If there is only one argument, it must be a ScoreboardInterval.
+        if args[0].is_a?(ScoreboardInterval)
+          @sbStart = args[0].sbStart
+          @slotDuration = args[0].slotDuration
+          # Just one argument, a TimeInterval
+          super(args[0].start, args[0].end)
+        else
+          raise ArgumentError, "Illegal argument 1: #{args[0].class}"
+        end
+      when 3
+        @sbStart = args[0]
+        @slotDuration = args[1]
+        # If the third argument is a date we convert it to a scoreboard index.
+        args[2] = dateToIndex(args[2]) if args[2].is_a?(TjTime)
+
+        if args[2].is_a?(Fixnum) || args[2].is_a?(Bignum)
+          super(args[2], args[2])
+        else
+          raise ArgumentError, "Illegal argument 3: #{args[0].class}"
+        end
+      when 4
+        @sbStart = args[0]
+        @slotDuration = args[1]
+        # If the third and forth arguments are a date we convert them to a
+        # scoreboard index.
+        args[2] = dateToIndex(args[2]) if args[2].is_a?(TjTime)
+        args[3] = dateToIndex(args[3]) if args[3].is_a?(TjTime)
+
+        if !(args[2].is_a?(Fixnum) || args[2].is_a?(Bignum))
+          raise ArgumentError, "Interval start must be an index or TjTime, " +
+                "not a #{args[2].class}"
+        end
+        if !(args[3].is_a?(Fixnum) || args[3].is_a?(Bignum))
+          raise ArgumentError, "Interval end must be an index or TjTime, " +
+                "not a #{args[3].class}"
+        end
+        super(args[2], args[3])
+      else
+        raise ArgumentError, "Wrong number of arguments: #{args.length}"
+      end
+
+      unless @sbStart.is_a?(TjTime)
+        raise ArgumentError, "sbStart must be a TjTime object, not a" +
+              "#{@sbStart.class}"
+      end
+      unless @slotDuration.is_a?(Fixnum)
+        raise ArgumentError, "slotDuration must be a Fixnum, not a " +
+              "#{@slotDuration.class}"
+      end
+
+    end
+
+    # Assign the start of the interval. +arg+ can be a Fixnum, Bignum or
+    # TjTime object.
+    def start=(arg)
+      case arg
+      when Fixnum
+      when Bignum
+        @start = arg
+      when TjTime
+        @start = dateToIndex(arg)
+      else
+        raise ArgumentError, "Unsupported class #{arg.class}"
+      end
+    end
+
+    # Assign the start of the interval. +arg+ can be a Fixnum, Bignum or
+    # TjTime object.
+    def end=(arg)
+      case arg
+      when Fixnum
+      when Bignum
+        @end = arg
+      when TjTime
+        @end = dateToIndex(arg)
+      else
+        raise ArgumentError, "Unsupported class #{arg.class}"
+      end
+    end
+
+    # Return the interval start as TjTime object.
+    def startDate
+      indexToDate(@start)
+    end
+
+    # Return the interval end as TjTime object.
+    def endDate
+      indexToDate(@end)
+    end
+
+    # Return the duration of the ScoreboardInterval.
+    def duration
+      indexToDate(@end) - indexToDate(@start)
+    end
+
+    # Turn the ScoreboardInterval into a human readable form.
+    def to_s
+      indexToDate(@start).to_s + ' - ' + indexToDate(@end).to_s
+    end
+
+    private
+
+    def dateToIndex(date)
+      (date - @sbStart).to_i / @slotDuration
+    end
+
+    def indexToDate(index)
+      @sbStart + (index * @slotDuration)
+    end
+
+  end
+
 end
 

data/lib/taskjuggler/IntervalList.rb

@@ -33,11 +33,11 @@ class TaskJuggler
             si += 1
           elsif self[si].end < list[li].end
             # self[si] does overlap with list[li] but list[li] goes further
-            res << Interval.new(list[li].start, self[si].end)
+            res << self[si].class.new(list[li].start, self[si].end)
             si += 1
           else
             # self[si] does overlap with list[li] but self[si] goes further
-            res << Interval.new(list[li].start, list[li].end)
+            res << self[si].class.new(list[li].start, list[li].end)
             li += 1
           end
         elsif list[li].start < self[si].start
@@ -48,11 +48,11 @@ class TaskJuggler
             li += 1
           elsif list[li].end < self[si].end
             # list[li] does overlap with self[si] but self[si] goes further
-            res << Interval.new(self[si].start, list[li].end)
+            res << self[si].class.new(self[si].start, list[li].end)
             li += 1
           else
             # list[li] does overlap with self[si] but list[li] goes further
-            res << Interval.new(self[si].start, self[si].end)
+            res << self[si].class.new(self[si].start, self[si].end)
             si += 1
           end
         else
@@ -86,7 +86,7 @@ class TaskJuggler
           raise "Intervals may not overlap and must be added in " +
                 "ascending order."
         elsif last.end == iv.start
-          self[-1] = Interval.new(last.start, iv.end)
+          self[-1] = last.class.new(last.start, iv.end)
           return self
         end
       end