taskjuggler 0.0.2 → 0.0.3

data/lib/reports/ReportBase.rb

@@ -0,0 +1,241 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = ReportBase.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.
+#
+
+class TaskJuggler
+
+  # This is the abstract base class for all kinds of reports. The derived
+  # classes must implement the generateIntermediateFormat function as well as
+  # the to_* members.
+  class ReportBase
+
+    def initialize(report)
+      @report = report
+      @project = report.project
+    end
+
+    # Convenience function to access a report attribute
+    def a(attribute)
+      @report.get(attribute)
+    end
+
+    def generateIntermediateFormat
+      raise 'This function must be overriden by derived classes.'
+    end
+
+    def to_html
+      raise 'This function must be overriden by derived classes.'
+    end
+
+    def to_csv
+      raise 'This function must be overriden by derived classes.'
+    end
+
+    # Take the complete task list and remove all tasks that are matching the
+    # hide expression, the rollup Expression or are not a descendent of
+    # taskRoot. In case resource is not nil, a task is only included if
+    # the resource is allocated to it in any of the reported scenarios.
+    def filterTaskList(list_, resource, hideExpr, rollupExpr)
+      list = PropertyList.new(list_)
+      if (taskRoot = a('taskRoot'))
+        # Remove all tasks that are not descendents of the taskRoot.
+        list.delete_if { |task| !task.isChildOf?(taskRoot) }
+      end
+
+      if resource
+        # If we have a resource we need to check that the resource is allocated
+        # to the tasks in any of the reported scenarios.
+        list.delete_if do |task|
+          delete = true
+          a('scenarios').each do |scenarioIdx|
+            if task['assignedresources', scenarioIdx].include?(resource)
+              delete = false
+              break;
+            end
+          end
+          delete
+        end
+      end
+
+      # Remove all tasks that don't overlap with the reported interval.
+      list.delete_if do |task|
+        delete = true
+        a('scenarios').each do |scenarioIdx|
+          iv = Interval.new(task['start', scenarioIdx].nil? ?
+                            @project['start'] : task['start', scenarioIdx],
+                            task['end', scenarioIdx].nil? ?
+                            @project['end'] : task['end', scenarioIdx])
+          # Special case to include milestones at the report end.
+          if iv.start == iv.end && iv.end == @end
+            iv.start = iv.end = iv.start - 1
+          end
+          if iv.overlaps?(Interval.new(a('start'), a('end')))
+            delete = false
+            break;
+          end
+        end
+        delete
+      end
+
+      standardFilterOps(list, hideExpr, rollupExpr, resource, taskRoot)
+    end
+
+    # Take the complete resource list and remove all resources that are matching
+    # the hide expression, the rollup Expression or are not a descendent of
+    # resourceRoot. In case task is not nil, a resource is only included if
+    # it is assigned to the task in any of the reported scenarios.
+    def filterResourceList(list_, task, hideExpr, rollupExpr)
+      list = PropertyList.new(list_)
+      if (resourceRoot = a('resourceRoot'))
+        # Remove all resources that are not descendents of the resourceRoot.
+        list.delete_if { |resource| !resource.isChildOf?(resourceRoot) }
+      end
+
+      if task
+        # If we have a task we need to check that the resources are assigned
+        # to the task in any of the reported scenarios.
+        iv = Interval.new(a('start'), a('end'))
+        list.delete_if do |resource|
+          delete = true
+          a('scenarios').each do |scenarioIdx|
+            if resource.allocated?(scenarioIdx, iv, task)
+              delete = false
+              break;
+            end
+          end
+          delete
+        end
+      end
+
+      standardFilterOps(list, hideExpr, rollupExpr, task, resourceRoot)
+    end
+
+    private
+
+    # Convert the RichText object _name_ into a HTML form.
+    def rt_to_html(name)
+      return unless a(name)
+
+      a(name).sectionNumbers = false
+      a(name).to_html
+    end
+
+    # This function implements the generic filtering functionality for all kinds
+    # of lists.
+    def standardFilterOps(list, hideExpr, rollupExpr, scopeProperty, root)
+      # Remove all properties that the user wants to have hidden.
+      if hideExpr
+        list.delete_if do |property|
+          hideExpr.eval(property, scopeProperty)
+        end
+      end
+
+      # Remove all children of properties that the user has rolled-up.
+      if rollupExpr
+        list.delete_if do |property|
+          parent = property.parent
+          delete = false
+          while (parent)
+            if rollupExpr.eval(parent, scopeProperty)
+              delete = true
+              break
+            end
+            parent = parent.parent
+          end
+          delete
+        end
+      end
+
+      # Re-add parents in tree mode
+      if list.treeMode?
+        parents = []
+        list.each do |property|
+          parent = property
+          while (parent = parent.parent)
+            parents << parent unless list.include?(parent) ||
+                                     parents.include?(parent)
+            break if parent == root
+          end
+        end
+        list.append(parents)
+      end
+
+      list
+    end
+
+    # This function converts number to strings that may include a unit. The
+    # unit is determined by @loadUnit. In the automatic modes, the shortest
+    # possible result is shown and the unit is always appended. _value_ is the
+    # value to convert. _factors_ determines the conversion factors for the
+    # different units.
+    # TODO: Delete when all users have been migrated to use Query!
+    def scaleValue(value, factors)
+      loadUnit = a('loadUnit')
+      numberFormat = a('numberFormat')
+
+      if loadUnit == :shortauto || loadUnit == :longauto
+        # We try all possible units and store the resulting strings here.
+        options = []
+        # For each of the units we can define a maximum value that the value
+        # should not exceed. A maximum of 0 means no limit.
+        max = [ 60, 48, 0, 8, 24, 0 ]
+
+        i = 0
+        shortest = nil
+        factors.each do |factor|
+          scaledValue = value * factor
+          str = numberFormat.format(scaledValue)
+          # We ignore results that are 0 or exceed the maximum. To ensure that
+          # we have at least one result the unscaled value is always taken.
+          if (factor != 1.0 && scaledValue == 0) ||
+             (max[i] != 0 && scaledValue > max[i])
+            options << nil
+          else
+            options << str
+          end
+          i += 1
+        end
+
+        # Default to days in case they are all the same.
+        shortest = 2
+        # Find the shortest option.
+        6.times do |j|
+          shortest = j if options[j] &&
+                          options[j].length < options[shortest].length
+        end
+
+        str = options[shortest]
+        if loadUnit == :longauto
+          # For the long units we handle singular and plural properly. For
+          # English we just need to append an 's', but this code will work for
+          # other languages as well.
+          units = []
+          if str == "1"
+            units = %w( minute hour day week month year )
+          else
+            units = %w( minutes hours days weeks months years )
+          end
+          str += ' ' + units[shortest]
+        else
+          str += %w( min h d w m y )[shortest]
+        end
+      else
+        # For fixed units we just need to do the conversion. No unit is
+        # included.
+        units = [ :minutes, :hours, :days, :weeks, :months, :years ]
+        str = numberFormat.format(value * factors[units.index(loadUnit)])
+      end
+      str
+    end
+
+  end
+
+end

data/lib/reports/ReportContext.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = ReportContext.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.
+#
+
+class TaskJuggler
+
+  # Each Project has a single ReportContext object that is used during the
+  # report generation. It is a container for global state.
+  class ReportContext
+
+    attr_reader :project, :report
+    attr_accessor :start, :end, :tasks, :resources
+
+    def initialize(project, report)
+      @project = project
+      @report = report
+
+      if (parent = @project.reportContext)
+        # If the new ReportContext is created from within an existing context,
+        # this is used as parent context and all attribute values are copied
+        # as default initial values.
+        @start = parent.start
+        @end = parent.end
+        @tasks = parent.tasks
+        @resources = parent.resources
+      else
+        @start = @end = nil
+        @tasks = @resources = nil
+      end
+    end
+
+  end
+end

data/lib/reports/ReportTable.rb

@@ -21,6 +21,10 @@ class TaskJuggler
   # appropriate format.
   class ReportTable
 
+    # 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
+
     attr_reader :maxIndent, :headerLineHeight, :headerFontSize
     attr_accessor :equiLines
 
@@ -93,9 +97,10 @@ class TaskJuggler
 
       # In case we have columns with scrollbars, we generate an extra line with
       # cells for all columns that don't have a scrollbar. The scrollbar must
-      # have a height of 18 pixels or less.
+      # have a height of SCROLLBARHEIGHT pixels or less.
       if hasScrollbar?
-        tbody << (tr = XMLElement.new('tr', 'style' => 'height:18px'))
+        tbody << (tr = XMLElement.new('tr',
+                                      'style' => "height:#{SCROLLBARHEIGHT}px"))
         @columns.each do |column|
           unless column.scrollbar
             tr << XMLElement.new('td')

data/lib/reports/ReportTableCell.rb

@@ -13,10 +13,10 @@
 class TaskJuggler
 
   # This class models the output format independent version of a cell in a
-  # ReportTableElement. It belongs to a certain ReportTableLine and
+  # TableReport. It belongs to a certain ReportTableLine and
   # ReportTableColumn. Normally a cell contains text on a colored background.
-  # By help of the @special variable it can alternatively contain any object the
-  # provides the necessary output methods such as to_html.
+  # By help of the @special variable it can alternatively contain any object
+  # the provides the necessary output methods such as to_html.
   class ReportTableCell
 
     attr_reader :line

data/lib/reports/ResourceListRE.rb

@@ -10,58 +10,51 @@
 # published by the Free Software Foundation.
 #
 
-require 'reports/ReportTableElement'
+require 'reports/TableReport'
 require 'reports/ReportTable'
 require 'TableColumnDefinition'
 require 'LogicalExpression'
 
 class TaskJuggler
 
-  # This specialization of ReportTableElement implements a resource listing. It
+  # This specialization of TableReport implements a resource listing. It
   # generates a list of resources that can optionally have the assigned tasks
   # nested underneath each resource line.
-  class ResourceListRE < ReportTableElement
+  class ResourceListRE < TableReport
 
     # Create a new object and set some default values.
     def initialize(report)
       super
-      # Set the default columns for this report.
-      %w( no name ).each do |col|
-        @columns << TableColumnDefinition.new(col, defaultColumnTitle(col))
-      end
-      # Show all resources, sorted by tree and id-up.
-      @hideResource = LogicalExpression.new(LogicalOperation.new(0))
-      @sortResources = [ [ 'tree', true, -1 ],
-                         [ 'id', true, -1 ] ]
-      # Hide all resources, but set sorting to tree, start-up, seqno-up.
-      @hideTask = LogicalExpression.new(LogicalOperation.new(1))
-      @sortTasks = [ [ 'tree', true, -1 ],
-                     [ 'start', true, 0 ],
-                     [ 'seqno', true, -1 ] ]
-
       @table = ReportTable.new
     end
 
     # Generate the table in the intermediate format.
     def generateIntermediateFormat
-      # Generate the table header.
-      @columns.each do |columnDescr|
-        generateHeaderCell(columnDescr)
-      end
+      setReportPeriod
 
       # Prepare the resource list.
       resourceList = PropertyList.new(@project.resources)
-      resourceList.setSorting(@sortResources)
-      resourceList = filterResourceList(resourceList, nil, @hideResource,
-                                        @rollupResource)
+      resourceList.setSorting(@report.get('sortResources'))
+      resourceList = filterResourceList(resourceList, nil,
+                                        @report.get('hideResource'),
+                                        @report.get('rollupResource'))
       resourceList.sort!
 
       # Prepare the task list.
       taskList = PropertyList.new(@project.tasks)
-      taskList.setSorting(@sortTasks)
-      taskList = filterTaskList(taskList, nil, @hideTask, @rollupTask)
+      taskList.setSorting(@report.get('sortTasks'))
+      taskList = filterTaskList(taskList, nil, @report.get('hideTask'),
+                                @report.get('rollupTask'))
       taskList.sort!
 
+      adjustReportPeriod(taskList, @report.get('scenarios'),
+                         @report.get('columns'))
+
+      # Generate the table header.
+      @report.get('columns').each do |columnDescr|
+        generateHeaderCell(columnDescr)
+      end
+
       # Generate the list.
       generateResourceList(resourceList, taskList, nil)
     end