taskjuggler 0.0.2 → 0.0.3

data/lib/WorkingHours.rb

@@ -159,7 +159,7 @@ class TaskJuggler
     # Return true of the given WorkingHours object +wh+ is identical to this
     # object.
     def ==(wh)
-      return false if @timezone != wh.timezone
+      return false if wh.nil? || @timezone != wh.timezone
 
       7.times do |d|
         return false if @days[d].length != wh.days[d].length

data/lib/XMLElement.rb

@@ -45,11 +45,19 @@ class TaskJuggler
       if arg.is_a?(XMLElement)
         @children << arg
       elsif arg.is_a?(Array)
+        # Delete all nil entries
+        arg.delete_if { |i| i.nil? }
+        # Check that the rest are really all XMLElement objects.
+        arg.each do |i|
+          unless i.is_a?(XMLElement)
+            raise "Element must be of type XMLElement not #{i.class}"
+          end
+        end
         @children += arg
       elsif arg.nil?
         # do nothing
       else
-        raise 'Elements must be of type XMLElement'
+        raise "Elements must be of type XMLElement not #{arg.class}"
       end
       self
     end
@@ -57,8 +65,8 @@ class TaskJuggler
     # Return the element and all sub elements as properly formatted XML.
     def to_s(indent = 0)
       out = '<' + @name
-      @attributes.each do |attrName, attrValue|
-        out << ' ' + attrName + '="' + quoteAttr(attrValue) + '"'
+      @attributes.keys.sort.each do |attrName|
+        out << " #{attrName}=\"#{quoteAttr(@attributes[attrName])}\""
       end
       if @children.empty? && !@mayNotBeEmpty
         out << '/>'

data/lib/deep_copy.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = deep_copy.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 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.
+#
+
+# This file extends some Ruby core classes to add deep-copying support. I'm
+# aware of the commonly suggested method using Marshal:
+#
+# class Object
+#   def deep_copy
+#     Marshal.load(Marshal.dump(self))
+#   end
+# end
+#
+# But just because I program in Ruby, I don't have to write bloatware. It's
+# like taking a trip to the moon and back to shop groceries at the store
+# around the corner. I'm not sure if I need more special cases than Array and
+# Hash, but this file works for me.
+#
+# In certain cases the full deep copy may not be desired. To preserve
+# references to objects, you need to overload deep_clone and handle the
+# special cases. Alternatively, an object can be frozen to prevent deep
+# copies.
+
+class Object
+
+  # This is a variant of Object#clone that returns a deep copy of an object.
+  def deep_clone
+    # We can't clone frozen objects. So just return a reference to them.
+    return self if frozen?
+
+    # In case we have loops in our graph, we return references, not
+    # deep-copied objects.
+    if RUBY_VERSION < '1.9.0'
+      return @clonedObject if instance_variables.include?('@clonedObject')
+    else
+      return @clonedObject if instance_variables.include?(:@clonedObject)
+    end
+
+    # Clone the current Object (shallow copy with internal state)
+    begin
+      @clonedObject = clone
+    rescue TypeError
+      return self
+    end
+    # Recursively copy all instance variables.
+    @clonedObject.instance_variables.each do |var|
+      val = instance_variable_get(var).deep_clone
+      @clonedObject.instance_variable_set(var, val)
+    end
+    if kind_of?(Array)
+      @clonedObject.collect! { |x| x.deep_clone }
+    elsif kind_of?(Hash)
+      @clonedObject.each { |key, val| store(key, val.deep_clone) }
+    end
+    # Remove the @clonedObject again.
+    if RUBY_VERSION < '1.9.0'
+      remove_instance_variable('@clonedObject')
+    else
+      remove_instance_variable(:@clonedObject)
+    end
+  end
+
+end
+

data/lib/ms_test.rb

@@ -0,0 +1,27 @@
+project mstest "Milestone test" "1.0" 2009-06-22 +1y {
+  extend task {
+    reference Url "URL"
+  }
+}
+
+resource tux "Tux" {
+  vacation 2009-06-29 +1.5w
+}
+
+task foo "Foo" {
+  task post_ms "Post MS" {
+    start 2009-06-22
+  }
+  task milestone "MS" {
+    effort 10d
+    allocate tux
+    Url "http://www.amd64.org"
+  }
+}
+
+resourcereport mstest "mstest" {
+  formats html
+  period 2009-06-25 +2m
+  columns no, name, weekly
+  hidetask 0
+}

data/lib/reports/ColumnTable.rb

@@ -44,19 +44,21 @@ class TaskJuggler
       # Now we generate a 'div' that will contain the nested table. It has a
       # height that fits all lines but has a maximum width. In case the embedded
       # table is larger, a scrollbar will appear. We assume that the scrollbar
-      # has a height of 18 pixels or less.
+      # has a height of SCROLLBARHEIGHT pixels or less.
       # Due to Firefoxes broken table rendering we have to specify a minimum
       # width. It may not excede the maxWidth value.
       mWidth = minWidth
       mWidth = @maxWidth if mWidth > @maxWidth
       td << (scrollDiv = XMLElement.new('div', 'class' => 'tabback',
         'style' => 'position:relative; overflow:auto; ' +
-                   "max-width:#{@maxWidth}px; " +
-                   "min-width:#{mWidth}px; " +
+                   "width:#{mWidth}px; " +
                    'margin-top:-1px; margin-bottom:-1px; ' +
-                   "height:#{height + 18 + 2}px;"))
+                   "height:#{height + SCROLLBARHEIGHT + 2}px;"))
 
-      scrollDiv << super
+      scrollDiv << (contentDiv = XMLElement.new('div',
+        'style' => 'margin: 0px; padding: 0px; position: absolute; top: 0px;' +
+                   "left: 0px; width: #{@maxWidth}px; height: #{height}px; "))
+      contentDiv << super
       td
     end
 

data/lib/reports/GanttChart.rb

@@ -27,6 +27,10 @@ class TaskJuggler
   # created, the user must call generateByWidth or generateByResolution.
   class GanttChart
 
+    # The height in pixels of a horizontal scrollbar on an HTML page. This
+    # value should be large enough to work for all browsers.
+    SCROLLBARHEIGHT = 20
+
     include HTMLGraphics
 
     attr_reader :start, :end, :now, :weekStartsMonday, :header, :width,
@@ -37,7 +41,7 @@ class TaskJuggler
     # more information about the chart before we can actually generate it. _now_
     # is the date that should be used as current date. _weekStartsMonday_ is
     # true if the weeks should start on Mondays instead of Sundays. _table_ is a
-    # reference to the ReportTableElement that the chart is part of.
+    # reference to the TableReport that the chart is part of.
     def initialize(now, weekStartsMonday, table = nil)
       # The start and end dates of the reported interval.
       @start = nil
@@ -146,15 +150,17 @@ class TaskJuggler
         'style' => 'padding:0px; vertical-align:top;')
       # Now we generate two 'div's nested into each other. The first div is the
       # view. It may contain a scrollbar if the second div is wider than the
-      # first one. In case we need a scrollbar The outer div is 18 pixels
-      # heigher to hold the scrollbar. Unfortunately this must be a hardcoded
-      # value even though the height of the scrollbar varies from system to
-      # system. This value should be good enough for most systems.
-      td << (scrollDiv = XMLElement.new('div',
+      # first one. In case we need a scrollbar The outer div is
+      # SCROLLBARHEIGHT pixels heigher to hold the scrollbar. Unfortunately
+      # this must be a hardcoded value even though the height of the scrollbar
+      # varies from system to system. This value should be good enough for
+      # most systems.
+      td << (scrollDiv = XMLElement.new('div', 'class' => 'tabback',
         'style' => 'position:relative; ' +
                    "overflow:auto; " +
                    "width:#{hasScrollbar? ? @viewWidth : @width}px; " +
-                   "height:#{@height + (hasScrollbar? ? 18 : 0)}px;"))
+                   "height:#{@height +
+                             (hasScrollbar? ? SCROLLBARHEIGHT : 0)}px;"))
       scrollDiv << (div = XMLElement.new('div',
         'style' => "margin:0px; padding:0px; " +
                    "position:absolute; " +
@@ -244,7 +250,7 @@ class TaskJuggler
       @router.addZone(@header.nowLineX - 1, 0, 3, @height - 1, false, true)
 
       @tasks.each do |task, lines|
-        generateDepArrow(task, lines)
+        generateDepArrows(task, lines)
       end
     end
 
@@ -252,41 +258,61 @@ class TaskJuggler
     # for a specific _task_. _lines_ is a list of GanttLines that the tasks are
     # displayed on. Reports with multiple scenarios have multiple lines per
     # task.
-    def generateDepArrow(task, lines)
+    def generateDepArrows(task, lines)
       # Since we need the line and the index we use an index iterator.
       lines.length.times do |lineIndex|
         line = lines[lineIndex]
         scenarioIdx = line.scenarioIdx
 
         # Generate the dependencies on the start of the task.
-        startX, startY = line.getTask.startDepLineStart
-        task['startsuccs', scenarioIdx].each do |t, onEnd|
-          # Skip inherited dependencies and tasks that are not included in the
-          # chart.
-          if (t.parent &&
-              task.hasDependency?(scenarioIdx, 'startsuccs', t.parent, onEnd)) ||
-             !@tasks.include?(t)
-            next
-          end
-          endX, endY = @tasks[t][lineIndex].getTask.send(
-            onEnd ? :endDepLineEnd : :startDepLineEnd)
-          routeArrow(startX, startY, endX, endY)
-        end
+        collectAndSortArrows('startsuccs', task, scenarioIdx, lineIndex,
+                             *line.getTask.startDepLineStart)
 
         # Generate the dependencies on the end of the task.
-        startX, startY = line.getTask.endDepLineStart
-        task['endsuccs', scenarioIdx].each do |t, onEnd|
-          # Skip inherited dependencies and tasks that are not included in the
-          # chart.
-          if (t.parent &&
-              task.hasDependency?(scenarioIdx, 'endsuccs', t.parent, onEnd)) ||
-             !@tasks.include?(t)
-            next
-          end
-          endX, endY = @tasks[t][lineIndex].getTask.send(
-            onEnd ? :endDepLineEnd : :startDepLineEnd)
-          routeArrow(startX, startY, endX, endY)
+        collectAndSortArrows('endsuccs', task, scenarioIdx, lineIndex,
+                             *line.getTask.endDepLineStart)
+      end
+    end
+
+    # Generate the dependencies on the start or end of the task depending on
+    # _kind_. Use 'startsuccs' for the start and 'endsuccs' for end. _startX_
+    # and _startY_ are the graphic coordinates for the begin of the arrow
+    # line. _task_ references the Task in question and _scenarioIdx_ the
+    # scenario. _lineIndex_ specifies the line number in the chart.
+    def collectAndSortArrows(kind, task, scenarioIdx, lineIndex, startX, startY)
+      # We need to sort the arrows. This is an Array that holds 6 values for
+      # each entry: The x and y coordinates for start and end points, the
+      # sinus value of the angle between a vertical and the line specified by
+      # the points and the length of the line.
+      touples = []
+      task[kind, scenarioIdx].each do |t, onEnd|
+        # Skip inherited dependencies and tasks that are not included in the
+        # chart.
+        if (t.parent &&
+            task.hasDependency?(scenarioIdx, kind, t.parent, onEnd)) ||
+           !@tasks.include?(t)
+          next
         end
+        endX, endY = @tasks[t][lineIndex].getTask.send(
+          onEnd ? :endDepLineEnd : :startDepLineEnd)
+        # To make sure that we minimize the crossings of arrows that
+        # originate from the same position, we sort the arrows by the
+        # smallest angle between the vertical line through the task end
+        # and the line between the start and end of the arrow.
+        oppLeg = endX - startX
+        adjLeg = (startY - endY).abs
+        hypothenuse = Math.sqrt(adjLeg ** 2 + oppLeg ** 2)
+        # We can now calculate the sinus values of the angle between the
+        # vertical and a line through the coordinates.
+        touples << [ startX, startY, endX, endY,
+                     (oppLeg / hypothenuse), hypothenuse ]
+      end
+      # We sort the arrows from small to a large angle. In case the angle is
+      # identical, we use the length of the line as second criteria.
+      touples.sort! { |t1, t2| t1[4] == t2[4] ? t1[5] <=> t2[5] :
+                                                t1[4] <=> t2[4] }
+      touples.each do |t|
+        routeArrow(*t[0, 4])
       end
     end
 

data/lib/reports/GanttHeader.rb

@@ -74,7 +74,7 @@ class TaskJuggler
                        :hour)
       when 'day'
         genHeaderScale(@largeScale, 0, h, :beginOfMonth, :sameTimeNextMonth,
-                       :shortMonthName)
+                       :monthAndYear)
         genHeaderScale(@smallScale, h + 1, h, :midnight, :sameTimeNextDay, :day)
       when 'week'
         genHeaderScale(@largeScale, 0, h, :beginOfMonth, :sameTimeNextMonth,

data/lib/reports/GanttRouter.rb

@@ -93,7 +93,8 @@ class TaskJuggler
         #                     2------X end Point
         #                     |endGap|
         #
-        xSeg = placeLine([ startPoint[1], endPoint[1] ],
+        xSeg = placeLine([ startPoint[1] + (startPoint[1] < endPoint[1] ?
+                                            1 : -1), endPoint[1] ],
                          false, startPoint[0] + startGap, 1)
         if xSeg && xSeg < endPoint[0] - endGap
           addLineTo(points, xSeg, startPoint[1])  # Point 1
@@ -108,7 +109,7 @@ class TaskJuggler
       #
       #                     x1
       #            |startGap|
-      # startPoint X--------1
+      # startPoint X--------1 yLS
       #                     |
       #     3---------------2 ySeg
       #     |
@@ -119,11 +120,12 @@ class TaskJuggler
       # Place horizontal segue. We don't know the width yet, so we have to
       # assume full width. That's acceptable for horizontal lines.
       ySeg = placeLine([ 0, @width - 1 ], true, startPoint[1],
-                       startPoint[1] < endPoint[1] ? 1 : -1)
+                        startPoint[1] < endPoint[1] ? 1 : -1)
       raise "Routing failed" unless ySeg
 
       # Place 1st vertical
-      x1 = placeLine([ startPoint[1], ySeg ], false, startPoint[0] + startGap, 1)
+      x1 = placeLine([ startPoint[1] + (startPoint[1] < endPoint[1] ? 1 : -1),
+                       ySeg ], false, startPoint[0] + startGap, 1)
       raise "Routing failed" unless x1
 
       # Place 2nd vertical
@@ -297,7 +299,7 @@ class TaskJuggler
       segment.sort!
       lines = horizontal ? @hLines : @vLines
       # TODO: Remove this check once the code becomes stable.
-      checkLines(lines)
+      #checkLines(lines)
       while collision?(lines[pos], segment)
         pos += delta
         # Check if we have exceded the chart area towards top/left.

data/lib/reports/Navigator.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = Navigator.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 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/ReportContext'
+
+class TaskJuggler
+
+  class Navigator
+
+    attr_reader :id
+    attr_accessor :hideReport
+
+    def initialize(id, project)
+      @id = id
+      @project = project
+      @hideReport = LogicalExpression.new(LogicalOperation.new(0))
+    end
+
+    def to_html
+      reports = filterReports
+      return nil if reports.empty?
+
+      first = true
+      html = []
+      html << (div = XMLElement.new('div'))
+      reports.each do |report|
+        next unless report.get('formats').include?(:html)
+
+        if first
+          first = false
+        else
+          div << XMLText.new('|')
+        end
+        if report == @project.reportContext.report
+          div << (span = XMLElement.new('span',
+                                         'style' => 'class:navbar_current'))
+          span << XMLText.new(report.name)
+        else
+          div << (span = XMLElement.new('span', 'style' => 'class:navbar_other'))
+          span << (a = XMLElement.new('a', 'href' => report.name + '.html'))
+          a << XMLText.new(report.name)
+        end
+      end
+      html
+    end
+
+    private
+
+    def filterReports
+      list = PropertyList.new(@project.reports)
+      list.setSorting([[ 'seqno', true, -1 ]])
+      list.sort!
+      # Remove all reports that the user doesn't want to have include.
+      list.delete_if do |property|
+        @hideReport.eval(property, nil)
+      end
+      list
+    end
+
+  end
+
+end
+

data/lib/reports/Report.rb

@@ -10,71 +10,33 @@
 # published by the Free Software Foundation.
 #
 
-require 'reports/ReportElement'
+require 'PropertyTreeNode'
+require 'reports/TextReport'
 require 'reports/TaskListRE'
 require 'reports/ResourceListRE'
 require 'reports/TjpExportRE'
 require 'reports/CSVFile'
+require 'reports/Navigator'
+require 'reports/ReportContext'
 require 'HTMLDocument'
 
 class TaskJuggler
 
-  # The Report class holds the fundamental description and functionality to turn
-  # the scheduled project into a user readable form. A report consists of one or
-  # more ReportElement objects and some attributes that are global to all
-  # elements.
-  class Report
+  # The Report class holds the fundamental description and functionality to
+  # turn the scheduled project into a user readable form. A report may contain
+  # other reports.
+  class Report < PropertyTreeNode
 
-    attr_reader :name, :project, :start, :end, :userDefinedPeriod,
-                :sourceFileInfo
-    attr_accessor :costAccount, :currencyformat, :loadUnit, :now,
-                  :numberformat, :resourceRoot, :revenueAccount,
-                  :shorttimeformat, :taskRoot, :timeformat, :timezone,
-                  :weekstartsmonday
+    attr_accessor :typeSpec, :content
 
     # Create a new report object.
-    def initialize(project, name, format, sourceFileInfo)
-      @project = project
-      @name = name
-      @project.addReport(self)
-      @outputFormats = [ format ]
-      @sourceFileInfo = sourceFileInfo
+    def initialize(project, id, name, parent)
+      super(project.reports, id, name, parent)
+      project.addReport(self)
 
-      # The following attributes determine the content and look of the report.
-      @costAccount = @project['costAccount']
-      @currencyformat = @project['currencyformat']
-      @loadUnit = @project['loadunit']
-      @end = @project['end']
-      @now = @project['now']
-      @numberformat = @project['numberformat']
-      @resourceRoot = nil
-      @revenueAccount = @project['revenueAccount']
-      @shorttimeformat = @project['shorttimeformat']
-      @start = @project['start']
-      @taskRoot = nil
-      @timeformat = @project['timeformat']
-      @timezone = @project['timezone']
-      @userDefinedPeriod = false
-      @weekstartsmonday = @project['weekstartsmonday']
-
-      @elements = []
-    end
-
-    # Set the start _date_ of the report period and mark it as user defined.
-    def start=(date)
-      @start = date
-      @userDefinedPeriod = true
-    end
-
-    # Set the end _date_ of the report period and mark it as user defined.
-    def end=(date)
-      @end = date
-      @userDefinedPeriod = true
-    end
-
-    # Add new ouput format request.
-    def addFormat(format)
-      @outputFormats << format
+      # The type specifier must be set for every report. It tells whether this
+      # is a task, resource, text or other report.
+      @typeSpec = nil
     end
 
     # The generate function is where the action happens in this class. The
@@ -82,14 +44,26 @@ class TaskJuggler
     # generated according the the requested output format(s).
     def generate
       begin
+        @content = nil
+        case @typeSpec
+        when :export
+          # Does not have an intermediate representation. Nothing to do here.
+        when :resourcereport
+          @content = ResourceListRE.new(self)
+        when :textreport
+          @content = TextReport.new(self)
+        when :taskreport
+          @content = TaskListRE.new(self)
+        else
+          raise "Unknown report type"
+        end
+
         # Most output format can be generated from a common intermediate
         # representation of the elements. We generate that IR first.
-        @elements.each do |element|
-          element.generateIntermediateFormat
-        end
+        @content.generateIntermediateFormat if @content
 
         # Then generate the actual output format.
-        @outputFormats.each do |format|
+        get('formats').each do |format|
           case format
           when :html
             generateHTML
@@ -97,8 +71,6 @@ class TaskJuggler
             generateCSV
           when :export
             generateExport
-          when :gui
-            # TODO: Find a way to hook up the GUI here.
           else
             raise 'Unknown report output format.'
           end
@@ -110,13 +82,17 @@ class TaskJuggler
       end
     end
 
-    # This function should only be called within the library. It's not a user
-    # callable function.
-    def addElement(element) # :nodoc:
-      @elements << element
+    # Render the content of the report as HTML (without the framing).
+    def to_html
+      @content ? @content.to_html : nil
     end
 
+
   private
+    # Convenience function to access a report attribute
+    def a(attribute)
+      get(attribute)
+    end
 
     # Generate an HTML version of the report.
     def generateHTML
@@ -180,6 +156,7 @@ class TaskJuggler
   .tabline { color:#000000 }
   .tabcell {
     white-space:nowrap;
+    overflow:hidden;
     padding:0px;
   }
   .taskcell1 {
@@ -246,7 +223,7 @@ class TaskJuggler
     position:absolute;
   }
   .free {
-    background-color:#a5ffb4;
+    background-color:#a5ffb5;
     position:absolute;
   }
   .busy {
@@ -286,17 +263,22 @@ EOT
                           )
       html << (body = XMLElement.new('body'))
 
-      @elements.each do |element|
-        body << element.to_html
-      end
+      # Make sure we have some margins around the report.
+      body << (frame = XMLElement.new('div',
+                                      'style' => 'margin: 35px 5% 25px 5%; '))
 
-      html.write(@name + '.html')
+      frame << @content.to_html if @content
+
+      html.write((@name[0] == '/' ? '' : @project.outputDir) +
+                 @name + (@name == '.' ? '' : '.html'))
     end
 
     # Generate a CSV version of the report.
     def generateCSV
+      return nil unless @content
+
       # CSV format can only handle the first element.
-      csv = @elements[0].to_csv
+      csv = @content.to_csv
       # Expand nested tables into the outer table.
       columnIdx = 0
       while columnIdx < csv[0].length do
@@ -328,14 +310,17 @@ EOT
 
       # Use the CSVFile class to write the Array of Arrays to a colon
       # separated file. Write to $stdout if the filename was set to '.'.
-      CSVFile.new(csv, ';').write(@name)
+      CSVFile.new(csv, ';').write((@name[0] == '/' ? '' : @project.outputDir) +
+                                  @name + (@name == '.' ? '' : '.csv'))
     end
 
     # Generate an export report
     def generateExport
-      extension = @elements[0].mainFile ? 'tjp' : 'tji'
-      f = @name == '.' ? $stdout : File.new(@name + '.' + extension, 'w')
-      f.puts "#{@elements[0].to_tjp}"
+      @content = TjpExportRE.new(self)
+      f = @name == '.' ? $stdout :
+                         File.new((@name[0] == '/' ? '' : @project.outputDir) +
+                                  @name, 'w')
+      f.puts "#{@content.to_tjp}"
     end
 
   end