taskjuggler 3.1.0 → 3.2.0

data/lib/taskjuggler/TaskScenario.rb

@@ -57,6 +57,7 @@ class TaskJuggler
       @doneEffort = 0.0
 
       @projectionMode = @project.scenario(@scenarioIdx).get('projection')
+      @nowIdx = @project.dateToIdx(@project['now'])
 
       @startIsDetermed = nil
       @endIsDetermed = nil
@@ -367,11 +368,11 @@ class TaskJuggler
         task.finishScheduling(@scenarioIdx)
       end
 
-      if (parent = @property.parent)
-        # Add the assigned resources to the parent task list.
+      @property.parents.each do |pTask|
+        # Add the assigned resources to the parent task's list.
         @assignedresources.each do |resource|
-          unless parent['assignedresources', @scenarioIdx].include?(resource)
-            parent['assignedresources', @scenarioIdx] << resource
+          unless pTask['assignedresources', @scenarioIdx].include?(resource)
+            pTask['assignedresources', @scenarioIdx] << resource
           end
         end
       end
@@ -558,7 +559,7 @@ class TaskJuggler
               "end date.")
       end
 
-      if @effort == 0 && !@milestone && !@allocate.empty? &&
+      if @property.leaf? && @effort == 0 && !@milestone && !@allocate.empty? &&
          @assignedresources.empty?
         # The user used an 'allocate' for the task, but did not specify any
         # 'effort'. Actual allocations will only happen when resources are
@@ -1241,6 +1242,22 @@ class TaskJuggler
       @booking << booking
     end
 
+    def query_activetasks(query)
+      count = activeTasks(query)
+
+      query.sortable = query.numerical = count
+      # For the string output, we only use integer numbers.
+      query.string = "#{count.to_i}"
+    end
+
+    def query_closedtasks(query)
+      count = closedTasks(query)
+
+      query.sortable = query.numerical = count
+      # For the string output, we only use integer numbers.
+      query.string = "#{count.to_i}"
+    end
+
     def query_complete(query)
       # If we haven't calculated the value yet, calculate it first.
       unless @complete
@@ -1337,6 +1354,13 @@ class TaskJuggler
       query.assignList(list)
     end
 
+    def query_gauge(query)
+      # If we haven't calculated the schedule status yet, calculate it first.
+      calcGauge unless @gauge
+
+      query.string = @gauge
+    end
+
     # The number of different resources assigned to the task during the query
     # interval. Each resource is counted based on their mathematically rounded
     # efficiency.
@@ -1350,22 +1374,41 @@ class TaskJuggler
       query.string = query.numberFormat.format(headcount)
     end
 
-    def query_maxend(query)
-      queryDateLimit(query, @maxend)
+    def query_inputs(query)
+      inputList = PropertyList.new(@project.tasks, false)
+      inputs(inputList, true)
+      inputList.delete(@property)
+      inputList.setSorting([['start', true, @scenarioIdx],
+                            ['seqno', true, -1 ]])
+      inputList.sort!
+
+      query.assignList(generateTaskList(inputList, query))
     end
 
-    def query_minend(query)
-      queryDateLimit(query, @minend)
+    def query_maxend(query)
+      queryDateLimit(query, @maxend)
     end
 
     def query_maxstart(query)
       queryDateLimit(query, @maxstart)
     end
 
+    def query_minend(query)
+      queryDateLimit(query, @minend)
+    end
+
     def query_minstart(query)
       queryDateLimit(query, @minstart)
     end
 
+    def query_opentasks(query)
+      count = openTasks(query)
+
+      query.sortable = query.numerical = count
+      # For the string output, we only use integer numbers.
+      query.string = "#{count.to_i}"
+    end
+
     def query_precursors(query)
       list = []
 
@@ -1403,9 +1446,8 @@ class TaskJuggler
       assignedResources(iv).each do |resource|
         if resource.allocated?(@scenarioIdx, iv, @property)
           if query.listItem
-            rti = RichText.new(query.listItem, RTFHandlers.create(@project),
-                               @project.messageHandler).
-                               generateIntermediateFormat
+            rti = RichText.new(query.listItem, RTFHandlers.create(@project)).
+              generateIntermediateFormat
             unless rti
               error('bad_resource_ts_query',
                     "Syntax error in query statement for task attribute " +
@@ -1444,24 +1486,6 @@ class TaskJuggler
       query.string = @status
     end
 
-    def query_gauge(query)
-      # If we haven't calculated the schedule status yet, calculate it first.
-      calcGauge unless @gauge
-
-      query.string = @gauge
-    end
-
-    def query_inputs(query)
-      inputList = PropertyList.new(@project.tasks, false)
-      inputs(inputList, true)
-      inputList.delete(@property)
-      inputList.setSorting([['start', true, @scenarioIdx],
-                            ['seqno', true, -1 ]])
-      inputList.sort!
-
-      query.assignList(generateTaskList(inputList, query))
-    end
-
     def query_targets(query)
       targetList = PropertyList.new(@project.tasks, false)
       targets(targetList, true)
@@ -1507,10 +1531,13 @@ class TaskJuggler
     # interval specified by _startIdx_ and _endIdx_. The effective work is the
     # actual work multiplied by the efficiency of the resource.
     def getEffectiveWork(startIdx, endIdx, resource = nil)
+      # Make sure we have the real Resource and not a proxy.
+      resource = resource.ptn if resource
       return 0.0 if @milestone || startIdx >= endIdx ||
                     (resource && !@assignedresources.include?(resource))
 
-      @dCache.cached(self, :TaskScenarioEffectiveWork, startIdx, endIdx, resource) do
+      @dCache.cached(self, :TaskScenarioEffectiveWork, startIdx, endIdx,
+                     resource) do
         workLoad = 0.0
         if @property.container?
           @property.kids.each do |task|
@@ -1519,8 +1546,8 @@ class TaskJuggler
           end
         else
           if resource
-            workLoad += resource.getEffectiveWork(@scenarioIdx, startIdx, endIdx,
-                                                  @property)
+            workLoad += resource.getEffectiveWork(@scenarioIdx, startIdx,
+                                                  endIdx, @property)
           else
             @assignedresources.each do |r|
               workLoad += r.getEffectiveWork(@scenarioIdx, startIdx, endIdx,
@@ -1538,7 +1565,8 @@ class TaskJuggler
       # This function is often called recursively for the same parameters. We
       # store the results in the cache to avoid repeated computations of the
       # same results.
-      @dCache.cached(self, :TaskScenarioCollectTimeOffIntervals, iv, minDuration) do
+      @dCache.cached(self, :TaskScenarioCollectTimeOffIntervals, iv,
+                     minDuration) do
         il = IntervalList.new
         il << TimeInterval.new(@project['start'], @project['end'])
         if @property.leaf?
@@ -1567,31 +1595,41 @@ class TaskJuggler
     # Check if the Task _task_ depends on this task. _depth_ specifies how
     # many dependent task are traversed at max. A value of 0 means no limit.
     # TODO: Change this to a non-recursive implementation.
-    def isDependencyOf(task, depth)
+    def isDependencyOf(task, depth, list = [])
       return true if task == @property
 
+      # If this task is already in the list of traversed task, we can ignore
+      # it.
+      return false if list.include?(@property)
+      list << @property
+
+      @startsuccs.each do |t, onEnd|
+        unless onEnd
+          # must be a start->start dependency
+          return true if t.isDependencyOf(@scenarioIdx, task, depth, list)
+        end
+      end
+
+      # For task to depend on this task, the start of task must be after the
+      # end of this task.
+      if task['start', @scenarioIdx] && @end
+        return false if task['start', @scenarioIdx] < @end
+      end
+
       # Check if any of the parent tasks is a dependency of _task_.
       t = @property.parent
       while t
         # If the parent is a dependency, than all childs are as well.
-        return true if t.isDependencyOf(@scenarioIdx, task, depth)
+        return true if t.isDependencyOf(@scenarioIdx, task, depth, list)
         t = t.parent
       end
 
-
-      @startsuccs.each do |dep|
-        unless dep[1]
-          # must be a start->start dependency
-          return true if dep[0].isDependencyOf(@scenarioIdx, task, depth)
-        end
-      end
-
       return false if depth == 1
 
-      @endsuccs.each do |dep|
-        unless dep[1]
+      @endsuccs.each do |ta, onEnd|
+        unless onEnd
           # must be an end->start dependency
-          return true if dep[0].isDependencyOf(@scenarioIdx, task, depth - 1)
+          return true if ta.isDependencyOf(@scenarioIdx, task, depth - 1, list)
         end
       end
 
@@ -1726,7 +1764,9 @@ class TaskJuggler
 
     def bookResources
       # First check if there is any resource at all for this slot.
-      return true unless @project.anyResourceAvailable?(@currentSlotIdx)
+      return if !@project.anyResourceAvailable?(@currentSlotIdx) ||
+                (@projectionMode && (@nowIdx > @currentSlotIdx))
+
 
       # If the task has resource independent allocation limits we need to make
       # sure that none of them is already exceeded.
@@ -2290,27 +2330,74 @@ class TaskJuggler
       end
     end
 
+    def activeTasks(query)
+      return 0 unless TimeInterval.new(@start, @end).
+        overlaps?(TimeInterval.new(query.start, query.end))
+
+      if @property.leaf?
+        now = @project['now']
+        return @start <= now && now < @end ? 1 : 0
+      else
+        cnt = 0
+        @property.kids.each do |task|
+          cnt += task.closedTasks(@scenarioIdx, query)
+        end
+        return cnt
+      end
+    end
+
+    def closedTasks(query)
+      return 0 unless TimeInterval.new(@start, @end).
+        overlaps?(TimeInterval.new(query.start, query.end))
+
+      if @property.leaf?
+        return @end <= @project['now'] ? 1 : 0
+      else
+        cnt = 0
+        @property.kids.each do |task|
+          cnt += task.closedTasks(@scenarioIdx, query)
+        end
+        return cnt
+      end
+    end
+
+    def openTasks(query)
+      return 0 unless TimeInterval.new(@start, @end).
+        overlaps?(TimeInterval.new(query.start, query.end))
+
+      if @property.leaf?
+        return @end > @project['now'] ? 1 : 0
+      else
+        cnt = 0
+        @property.kids.each do |task|
+          cnt += task.openTasks(@scenarioIdx, query)
+        end
+        return cnt
+      end
+    end
+
     # Recursively compile a list of Task properties which depend on the
     # current task.
-    def inputs(list, includeChildren)
-      # Ignore tasks that we have already included in the list.
-      return if list.include?(@property)
+    def inputs(foundInputs, includeChildren, checkedTasks = [])
+      # Ignore tasks that we have already included in the checked tasks list.
+      return if checkedTasks.include?(@property)
+      checkedTasks << @property
 
       # A target must be a leaf function that has no direct or indirect
       # (through parent) following tasks. Only milestones are recognized as
       # targets.
       if @property.leaf? && !hasPredecessors && @milestone
-        list << @property
+        foundInputs << @property
         return
       end
 
       @startpreds.each do |t, onEnd|
-        t.inputs(@scenarioIdx, list, false)
+        t.inputs(@scenarioIdx, foundInputs, false, checkedTasks)
       end
 
       # Check for indirect predecessors.
       if @property.parent
-        @property.parent.inputs(@scenarioIdx, list, false)
+        @property.parent.inputs(@scenarioIdx, foundInputs, false, checkedTasks)
       end
 
       # Also include targets of child tasks. The recursive iteration of child
@@ -2318,32 +2405,33 @@ class TaskJuggler
       # iterated.
       if includeChildren
         @property.kids.each do |child|
-          child.inputs(@scenarioIdx, list, true)
+          child.inputs(@scenarioIdx, foundInputs, true, checkedTasks)
         end
       end
     end
 
     # Recursively compile a list of Task properties which depend on the
     # current task.
-    def targets(list, includeChildren)
-      # Ignore tasks that we have already included in the list.
-      return if list.include?(@property)
+    def targets(foundTargets, includeChildren, checkedTasks = [])
+      # Ignore tasks that we have already included in the checked tasks list.
+      return if checkedTasks.include?(@property)
+      checkedTasks << @property
 
       # A target must be a leaf function that has no direct or indirect
       # (through parent) following tasks. Only milestones are recognized as
       # targets.
       if @property.leaf? && !hasSuccessors && @milestone
-        list << @property
+        foundTargets << @property
         return
       end
 
       @endsuccs.each do |t, onEnd|
-        t.targets(@scenarioIdx, list, false)
+        t.targets(@scenarioIdx, foundTargets, false, checkedTasks)
       end
 
       # Check for indirect followers.
       if @property.parent
-        @property.parent.targets(@scenarioIdx, list, false)
+        @property.parent.targets(@scenarioIdx, foundTargets, false, checkedTasks)
       end
 
       # Also include targets of child tasks. The recursive iteration of child
@@ -2351,7 +2439,7 @@ class TaskJuggler
       # iterated.
       if includeChildren
         @property.kids.each do |child|
-          child.targets(@scenarioIdx, list, true)
+          child.targets(@scenarioIdx, foundTargets, true, checkedTasks)
         end
       end
     end
@@ -2416,8 +2504,8 @@ class TaskJuggler
 
     def generateDepencyListItem(query, task, dep, date)
       if query.listItem
-        rti = RichText.new(query.listItem, RTFHandlers.create(@project),
-                           @project.messageHandler).generateIntermediateFormat
+        rti = RichText.new(query.listItem, RTFHandlers.create(@project)).
+          generateIntermediateFormat
         q = query.dup
         q.property = task
         q.setCustomData('dependency', { :string => dep })
@@ -2435,8 +2523,8 @@ class TaskJuggler
         date = task['start', @scenarioIdx].
                to_s(@property.project['timeFormat'])
         if query.listItem
-          rti = RichText.new(query.listItem, RTFHandlers.create(@project),
-                             @project.messageHandler).generateIntermediateFormat
+          rti = RichText.new(query.listItem, RTFHandlers.create(@project)).
+            generateIntermediateFormat
           q = query.dup
           q.property = task
           q.setCustomData('date', { :string => date })

data/lib/taskjuggler/TextParser.rb

@@ -50,6 +50,8 @@ class TaskJuggler
   # with the name of the start rule.
   class TextParser
 
+    include MessageHandler
+
     # Utility class so that we can distinguish Array results from the Array
     # containing the results of a repeatable rule. We define some merging
     # method with a slightly different behaviour.
@@ -72,12 +74,10 @@ class TaskJuggler
       end
     end
 
-    attr_reader :rules, :messageHandler
+    attr_reader :rules
 
     # Create a new TextParser object.
-    def initialize(messageHandler)
-      # The message handler will collect all error messages.
-      @messageHandler = messageHandler
+    def initialize
       # This Hash will store the ruleset that the parser is operating on.
       @rules = { }
       # Array to hold the token types that the scanner can return.
@@ -201,7 +201,7 @@ class TaskJuggler
         result = parseFSM(@rules[ruleName])
       rescue TjException => msg
         if msg.message && !msg.message.empty?
-          @messageHandler.critical('parse', msg.message)
+          critical('parse', msg.message)
         end
         return false
       end
@@ -224,7 +224,7 @@ class TaskJuggler
         # on to the TextScanner.
         @scanner.error(id, text, sfi, data)
       else
-        @messageHandler.error(id, text, sfi, data)
+        error(id, text, sfi, data)
       end
     end
 
@@ -235,7 +235,7 @@ class TaskJuggler
         # warning on to the TextScanner.
         @scanner.warning(id, text, sfi, data)
       else
-        @messageHandler.warning(id, text, sfi, data)
+        warning(id, text, sfi, data)
       end
     end
 
@@ -298,6 +298,7 @@ class TaskJuggler
           stackElement = @stack.last
           first = true
           transition.stateStack.each do |s|
+            checkForOldSyntax(s, token)
             if first && s.pattern == stackElement.state.pattern
               # The first state in the list may just be another state of the
               # current pattern. In this case, we already have the
@@ -318,16 +319,7 @@ class TaskJuggler
             # stores the result of the pattern and keeps the State that we
             # need to return to in case we jump to other patterns from this
             # pattern.
-            if state.pattern.supportLevel == :deprecated
-              warning('deprecated_keyword',
-                      "The keyword '#{token[1]}' has been deprecated! " +
-                      "See the reference manual for details.")
-            end
-            if state.pattern.supportLevel == :removed
-              error('removed_keyword',
-                    "The keyword '#{token[1]}' is no longer supported! " +
-                    "See the reference manual for details.")
-            end
+            checkForOldSyntax(state, token)
             @stack.push(TextParser::StackElement.new(state.pattern.function,
                                                      state))
           end
@@ -441,6 +433,21 @@ class TaskJuggler
       end
     end
 
+    # Check if the current token matches a deprecated or removed syntax
+    # element.
+    def checkForOldSyntax(state, token)
+      if state.pattern.supportLevel == :deprecated
+        warning('deprecated_keyword',
+                "The keyword '#{token[1]}' has been deprecated! " +
+                "See the reference manual for details.")
+      end
+      if state.pattern.supportLevel == :removed
+        error('removed_keyword',
+              "The keyword '#{token[1]}' is no longer supported! " +
+              "See the reference manual for details.")
+      end
+    end
+
     # Convert the FSM stack state entries from State objects into [ rule,
     # pattern, index ] equivalents.
     def saveFsmStack