taskjuggler 0.0.7 → 0.0.8

data/lib/WorkingHours.rb

@@ -11,140 +11,31 @@
 #
 
 require 'Interval'
+require 'Scoreboard'
 
 class TaskJuggler
 
-  # This cache class is used to speedup accesses to the frequently used
-  # WorkingHours::onShift? function. It saves the result the first time the
-  # function is called for a particular date and working hour set and returns
-  # it on subsequent calls again. Each partucular set of working hours needs
-  # its separate cache. The OnShiftCache object is shared amongst all
-  # WorkingHours objects so that WorkingHours objects with identical working
-  # hours can share the cache.
-  class OnShiftCache
-
-    # Create the OnShiftCache object. There should be only one for the
-    # application.
-    def initialize
-      @caches = []
-      @workingHoursTable = []
-      # The cache is an array with entries for each date. To minimize the
-      # necessary storage space, we need to guess the smallest used date
-      # (which gets index 0 then) and the smallest distance between dates.
-      @minDate = nil
-      # We assume a timing resolution of 1 hour (the TaskJuggler default)
-      # first.
-      @minDateDelta = 60 * 60
-    end
-
-    # Register the WorkingHours object with the caches. The function will
-    # return the actual cache used for this particular set of working hours.
-    # The WorkingHours object may not change its working hours after this
-    # call. The returned cache reference is used as a handle for subsequent
-    # OnShiftCache::set and OnShiftCache::get calls.
-    def register(wh)
-      # Search the list of already registered caches for an identical set of
-      # WorkingHours. In case one is found, return the reference to this
-      # cache.
-      @workingHoursTable.length.times do |i|
-        if @workingHoursTable[i] == wh
-          return @caches[i]
-        end
-      end
-      # If this is a new set of WorkingHours we create a new cache for it.
-      @workingHoursTable << WorkingHours.new(wh)
-      @caches << []
-      @caches.last
-    end
-
-    # Set the +value+ for a given +cache+ and +date+.
-    def set(cache, date, value)
-      cache[dateToIndex(date)] = value
-    end
-
-    # Get the value for a given +cache+ and +date+.
-    def get(cache, date)
-      cache[dateToIndex(date)]
-    end
-
-    private
-
-    # When the @minDate or @minDateDelta values need to be changed, we have to
-    # clear all the caches again.
-    def resetCaches
-      @caches.each { |c| c.clear }
-    end
-
-    # Convert a TjTime +date+ to an index in the cache Array. To optimize the
-    # size of the cache, we have to guess the smallest used date and the
-    # regular distance between the date values. If we have to correct these
-    # guessed values, we have to clear the caches.
-    def dateToIndex(date)
-      if @minDate.nil? || date < @minDate
-        @minDate = date
-        resetCaches
-      end
-      startDate = date - @minDate
-      div, mod = startDate.divmod(@minDateDelta)
-      if mod != 0
-        resetCaches
-        # We have to guess the timingresolution of the project here. Possible
-        # values are 5, 10, 15, 20, 30 or 60 minutes.
-        case @minDateDelta / 60
-        when 60
-          @minDateDelta = 30
-        when 30
-          @minDateDelta = 20
-        when 20
-          @minDateDelta = 15
-        when 15
-          @minDateDelta = 10
-        when 10
-          @minDateDelta = 5
-        else
-          raise "Illegal timing resolution!"
-        end
-        @minDateDelta *= 60
-        div = startDate / @minDateDelta
-      end
-
-      div
-    end
-
-  end
-
   # Class to store the working hours for each day of the week. The working hours
   # are stored as Arrays of Fixnum intervals for each day of the week. A day off
   # is modelled as empty Array for that week day. The start end end times of
   # each working period are stored as seconds after midnight.
   class WorkingHours
 
-    attr_reader :days
-    attr_accessor :timezone
-
-    # All WorkingHours objects share the same cache to speedup the onShift?
-    # method.
-    @@onShiftCache = OnShiftCache.new
+    attr_reader :days, :startDate, :endDate, :slotDuration, :timezone,
+                :scoreboard
 
     # Create a new WorkingHours object. The method accepts a reference to an
     # existing WorkingHours object in +wh+. When it's present, the new object
-    # will be a deep copy of the given object.
-    def initialize(wh = nil)
+    # will be a deep copy of the given object. The Scoreboard object is _not_
+    # deep copied. It will be copied on write.
+    def initialize(arg1 = nil, startDate = nil, endDate = nil)
       # One entry for every day of the week. Sunday === 0.
       @days = Array.new(7, [])
-      @cache = nil
+      @scoreboard = nil
 
-      if wh.nil?
-        # Create a new object with default working hours.
-        @timezone = nil
-        # Set the default working hours. Monday to Friday 9am - 12pm, 1pm - 6pm.
-        # Saturday and Sunday are days off.
-        1.upto(5) do |day|
-          @days[day] = [ [ 9 * 60 * 60, 12 * 60 * 60 ],
-                         [ 13 * 60 * 60, 18 * 60 * 60 ] ]
-        end
-      else
-        # Copy the values from the given object.
+      if arg1.is_a?(WorkingHours)
+        # Create a copy of the passed WorkingHours object.
+        wh = arg1
         @timezone = wh.timezone
         7.times do |day|
           hours = []
@@ -153,13 +44,37 @@ class TaskJuggler
           end
           setWorkingHours(day, hours)
         end
+        @startDate = wh.startDate
+        @endDate = wh.endDate
+        @slotDuration = wh.slotDuration
+        @scoreboard = wh.scoreboard
+      else
+        slotDuration = arg1
+        if arg1.nil? || startDate.nil? || endDate.nil?
+          raise "You must supply values for slotDuration, start and end dates"
+        end
+        @startDate = startDate
+        @endDate = endDate
+        @slotDuration = slotDuration
+
+        # Create a new object with default working hours.
+        @timezone = nil
+        # Set the default working hours. Monday to Friday 9am - 12pm, 1pm - 6pm.
+        # Saturday and Sunday are days off.
+        1.upto(5) do |day|
+          @days[day] = [ [ 9 * 60 * 60, 12 * 60 * 60 ],
+                         [ 13 * 60 * 60, 18 * 60 * 60 ] ]
+        end
       end
     end
 
     # Return true of the given WorkingHours object +wh+ is identical to this
     # object.
     def ==(wh)
-      return false if wh.nil? || @timezone != wh.timezone
+      return false if wh.nil? || @timezone != wh.timezone ||
+             @startDate != wh.startDate ||
+             @endDate != wh.endDate ||
+             @slotDuration != wh.slotDuration
 
       7.times do |d|
         return false if @days[d].length != wh.days[d].length
@@ -178,10 +93,8 @@ class TaskJuggler
     # specifies the time of day as minutes after midnight. The first value is
     # the start time of the interval, the second the end time.
     def setWorkingHours(dayOfWeek, intervals)
-      if @cache
-        raise 'You cannot change the working hours after onShift? has been ' +
-              'called.'
-      end
+      # Changing the working hours requires the score board to be regenerated.
+      @scoreboard = nil
 
       # Legal values range from 0 Sunday to 6 Saturday.
       if dayOfWeek < 0 || dayOfWeek > 6
@@ -199,6 +112,13 @@ class TaskJuggler
       @days[dayOfWeek] = intervals
     end
 
+    # Set the time zone _zone_ for the working hours. This will reset the
+    # @scoreboard.
+    def timezone=(zone)
+      @scoreboard = nil
+      @timezone = zone
+    end
+
     # Return the working hour intervals for a given day of the week.
     # +dayOfWeek+ must 0 for Sunday, 1 for Monday and so on. The result is an
     # Array that contains Arrays of 2 Fixnums.
@@ -208,64 +128,24 @@ class TaskJuggler
 
     # Return true if _date_ is within the defined working hours.
     def onShift?(date)
-      @cache = @@onShiftCache.register(self) unless @cache
-
-      # If we have the result cached already, return it.
-      unless (os = @@onShiftCache.get(@cache, date)).nil?
-        return os
-      end
-
-      # The date is in UTC. The weekday needs to be calculated according to the
-      # timezone of the project.
-      projectDate = toLocaltime(date)
-      dow = projectDate.wday
-
-      # The working hours need to be put into the proper time zone.
-      localDate = toLocaltime(date, @timezone)
-      secondsOfDay = localDate.secondsOfDay
-
-      @days[dow].each do |iv|
-        # Check the working hours of that day if they overlap with +date+.
-        if iv[0] <= secondsOfDay && secondsOfDay < iv[1]
-          # Store the result in the cache.
-          @@onShiftCache.set(@cache, date, true)
-          return true
-        end
-      end
+      initScoreboard unless @scoreboard
 
-      # Store the result in the cache.
-      @@onShiftCache.set(@cache, date, false)
-      false
+      @scoreboard.get(date)
     end
 
-    # This function does not belong here! It should be handled via the
-    # ShiftAssignment.
+    # Return true only if all slots in the _interval_ are offhour slots.
     def timeOff?(interval)
-      t = interval.start.midnight
-      while t < interval.end
-        dow = t.wday
-        unless @days[dow].empty?
-          dayStart = t < interval.start ? interval.start.secondsOfDay :
-                                          t.secondsOfDay
-          dayEnd = t.sameTimeNextDay > interval.end ? interval.end.secondsOfDay :
-                   60 * 60 * 24;
-          @days[dow].each do |iv|
-            return false if (dayStart <= iv[0] && iv[0] < dayEnd) ||
-                            (iv[0] <= dayStart && dayStart < iv[1])
-          end
-        end
-        t = t.sameTimeNextDay
+      initScoreboard unless @scoreboard
+
+      startIdx = @scoreboard.dateToIdx(interval.start, true)
+      endIdx = @scoreboard.dateToIdx(interval.end, true)
+
+      startIdx.upto(endIdx - 1) do |i|
+        return false if @scoreboard[i]
       end
       true
     end
 
-    # Probably should be put into ShiftAssignment as well.
-    def dayOff?(date)
-      projectDate = toLocaltime(date)
-      dow = projectDate.wday
-      @days[dow].empty?
-    end
-
     # Returns the time interval settings for each day in a human readable form.
     def to_s
       dayNames = %w( Sun Mon Tue Wed Thu Fri Sat )
@@ -295,26 +175,51 @@ class TaskJuggler
 
   private
 
-    # Convert a UTC date into the corresponding date in the local time zone.
-    # This is either the current system setting or the time zone specified by
-    # _tz_.
-    def toLocaltime(date, tz = nil)
+    def initScoreboard
+      # The scoreboard is an Array of True/False values. It spans a certain
+      # time period with one entry per time slot.
+      @scoreboard = Scoreboard.new(@startDate, @endDate, @slotDuration, false)
+
       oldTimezone = nil
       # Set environment variable TZ to appropriate time zone
       if @timezone
-        oldTimezone = ENV['tz']
-        ENV['tz'] = @timezone
+        oldTimezone = ENV['TZ']
+        ENV['TZ'] = @timezone
       end
 
-      localDate = date.dup
-      localDate.localtime
+      date = @startDate
+      @scoreboard.collect! do |slot|
+        localDate = date.dup
+        localDate.localtime
+
+        # The date is in UTC. The weekday needs to be calculated according to
+        # the local timezone.
+        weekday = localDate.wday
+        secondsOfDay = localDate.secondsOfDay
+
+        result = false
+        @days[weekday].each do |iv|
+          # Check the working hours of that day if they overlap with +date+.
+          if iv[0] <= secondsOfDay && secondsOfDay < iv[1]
+            # The time slot is a working slot.
+            result = true
+            break
+          end
+        end
+        # Calculate date of next scoreboard slot
+        date += @slotDuration
 
-      # Restore environment
-      if oldTimezone
-        ENV['tz'] = oldTimezone
+        result
       end
 
-      localDate
+      # Restore environment
+      if @timezone
+        if oldTimezone
+          ENV['TZ'] = oldTimezone
+        else
+          ENV.delete('TZ')
+        end
+      end
     end
 
   end

data/lib/daemon/ReportServer.rb

@@ -98,7 +98,7 @@ class TaskJuggler
 
     def addFile(file)
       begin
-        @tj.parseFile(file, 'properties')
+        @tj.parseFile(file, :properties)
       rescue TjException
         return false
       end
@@ -108,8 +108,9 @@ class TaskJuggler
 
     def generateReport(id, regExpMode, dynamicAttributes)
       @log.info("Generating report #{id}")
+      startTime = Time.now
       if (ok = @tj.generateReport(id, regExpMode, dynamicAttributes))
-        @log.debug("Report #{id} generated")
+        @log.info("Report #{id} generated in #{Time.now - startTime} seconds")
       else
         @log.error("Report generation of #{id} failed")
       end

data/lib/reports/CSVFile.rb

@@ -55,7 +55,7 @@ class TaskJuggler
         file = File.open(fileName, 'r')
       end
 
-      @data = parse(file.read)
+      parse(file.read)
 
       file.close unless fileName == '.'
       @data

data/lib/reports/CollisionDetector.rb

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = CollisionDetector.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009, 2010 by Chris Schlaeger <cs@kde.org>
+#
+# 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 'reports/HTMLGraphics'
+
+class TaskJuggler
+
+  class CollisionDetector
+
+    include HTMLGraphics
+
+    def initialize(width, height)
+      @width = width
+      @height = height
+
+      # The zones are stored as Arrays of line segments. Horizontal blocks are
+      # stored separately from vertical blocks. Blocked segments for a
+      # particular x coordinate are stored in @vLines, for y coordinates in
+      # @hLines. Each entry is an Array of [ start, end ] values that describe
+      # the blocked segments of that particular line. Start and end point are
+      # part of the segment. A listed segment will not be overwritten during
+      # routing.
+      @hLines = Array.new(@height) { |i| i = [] }
+      @vLines = Array.new(@width) { |i| i = [] }
+    end
+
+    # This function registers an area as don't-cross-zone. The rectangular zone
+    # is described by _x_, _y_, _w_ and _h_. If _horiz_ is true, the zone will
+    # be blocked for horizontal lines, if _vert_ is true the zone will be
+    # blocked for vertical lines.
+    def addBlockedZone(x, y, w, h, horiz, vert)
+      # Clip the input rectangle to fit within the handled area of this router.
+      x = clip(x.to_i, @width - 1)
+      y = clip(y.to_i, @height - 1)
+      w = clip(w.to_i, @width - x)
+      h = clip(h.to_i, @height - y)
+
+      # We can ignore empty zones.
+      return if w == 0 || h == 0
+
+      # Break the rectangle into line segments and add them to the appropriate
+      # line Arrays.
+      if horiz
+        y.upto(y + h - 1) do |i|
+          addSegment(@hLines[i], [ x, x + w - 1 ])
+        end
+      end
+      if vert
+        x.upto(x + w - 1) do |i|
+          addSegment(@vLines[i], [ y, y + h - 1 ])
+        end
+      end
+    end
+
+    # Find out if there is a block at line _pos_ for the start/end coordinates
+    # given by _segment_. If _horizontal_ is true, we are looking for a
+    # horizontal block, otherwise a vertical.
+    def collision?(pos, segment, horizontal)
+      line = (horizontal ? @hLines : @vLines)[pos]
+
+      # For complex charts, the segment lists can be rather long. We use a
+      # binary search to be fairly efficient.
+      l = 0
+      u = line.length - 1
+      while l <= u
+        # Look at the element in the middle between l and u.
+        p = l + ((u - l) / 2).to_i
+        return true if overlaps?(line[p], segment)
+
+        if segment[0] > line[p][1]
+          # The potential target is above p. Adjust lower bound.
+          l = p + 1
+        else
+          # The potential target is below p. Adjust upper bound.
+          u = p - 1
+        end
+      end
+      false
+    end
+
+    def to_html
+      html = []
+      # Change this to determine what zones you want to see.
+      if true
+        # Show vertical blocks
+        x = 0
+        @vLines.each do |line|
+          line.each do |segment|
+            html << lineToHTML(x, segment[0], x, segment[1], 'white')
+          end
+          x += 1
+        end
+      else
+        # Show horizontal blocks
+        y = 0
+        @hLines.each do |line|
+          line.each do |segment|
+            html << lineToHTML(segment[0], y, segment[1], y, 'white')
+          end
+          y += 1
+        end
+      end
+      html
+    end
+
+    private
+
+    # Simple utility function to limit _v_ between 0 and _max_.
+    def clip(v, max)
+      v = 0 if v < 0
+      v = max if v > max
+      v
+    end
+
+    # This function adds a new segment to the line. In case the new segment
+    # overlaps with or directly attaches to existing segments, these segments
+    # are merged into a single segment.
+    def addSegment(line, newSegment)
+      # Search for overlaping or directly attaching segments in the list.
+      i = 0
+      while (i < line.length)
+        segment = line[i]
+        if mergeable?(newSegment, segment)
+          # Merge exiting segment into new one
+          merge(newSegment, segment)
+          # Remove the old one from the list and restart with the newly created
+          # one at the same position.
+          line.delete_at(i)
+          next
+        elsif segment[0] > newSegment[1]
+          # Segments are stored in ascending order. If the next segment starts
+          # with a larger value, we insert the new segment before the larger
+          # one.
+          line.insert(i, newSegment)
+          return
+        end
+        i += 1
+      end
+      # Append new segment
+      line << newSegment
+    end
+
+    # Return true if the two segments described by _s1_ and _s2_ overlap each
+    # other. A segment is a [ start, end ] Array. The two points are part of the
+    # segment.
+    def overlaps?(s1, s2)
+      (s1[0] <= s2[0] && s2[0] <= s1[1]) ||
+      (s2[0] <= s1[0] && s1[0] <= s2[1])
+    end
+
+    # Return true if the two segments described by _s1_ and _s2_ overlap each
+    # other or are directly attached to each other.
+    def mergeable?(s1, s2)
+      overlaps?(s1, s2) ||
+      (s1[1] + 1 == s2[0]) ||
+      (s2[1] + 1 == s1[0])
+    end
+
+    # Merge the two segments described by _dst_ and _src_ into _dst_.
+    def merge(dst, seg)
+      dst[0] = seg[0] if seg[0] < dst[0]
+      dst[1] = seg[1] if seg[1] > dst[1]
+    end
+
+  end
+
+end
+