taskjuggler 3.3.0 → 3.4.0

data/lib/taskjuggler/RichText/Parser.rb

@@ -36,7 +36,7 @@ class TaskJuggler
       @variables = [ :LINEBREAK, :SPACE, :WORD,
                      :BOLD, :ITALIC, :CODE, :BOLDITALIC, :PRE,
                      :HREF, :HREFEND, :REF, :REFEND, :HLINE,
-                     :FCOLSTART, :FCOLEND,
+                     :HTMLBLOB, :FCOLSTART, :FCOLEND,
                      :QUERY,
                      :INLINEFUNCSTART, :INLINEFUNCEND,
                      :BLOCKFUNCSTART, :BLOCKFUNCEND, :ID, :STRING,

data/lib/taskjuggler/RichText/RTFReportLink.rb

@@ -31,20 +31,14 @@ class TaskJuggler
 
     # Not supported for this function
     def to_s(args)
-      ''
+      report = checkArgs(args)
+
+      report.name
     end
 
     # Return a HTML tree for the report.
     def to_html(args)
-      if args.nil? || (id = args['id']).nil?
-        error('rtp_report_id',
-              "Argument 'id' missing to specify the report to be used.")
-        return nil
-      end
-      unless (report = @project.report(id))
-        error('rtp_report_unknown_id', "Unknown report #{id}")
-        return nil
-      end
+      report = checkArgs(args)
 
       # The URL for interactive reports is different than for static reports.
       if report.interactive?
@@ -71,6 +65,22 @@ class TaskJuggler
       nil
     end
 
+    private
+
+    def checkArgs(args)
+      if args.nil? || (id = args['id']).nil?
+        error('rtp_report_id',
+              "Argument 'id' missing to specify the report to be used.")
+        return nil
+      end
+      unless (report = @project.report(id))
+        error('rtp_report_unknown_id', "Unknown report #{id}")
+        return nil
+      end
+
+      report
+    end
+
   end
 
 end

data/lib/taskjuggler/RichText/Scanner.rb

@@ -25,6 +25,7 @@ class TaskJuggler
   # :bol :     at the begining of a line.
   # :inline :  in the middle of a line
   # :nowiki :  ignoring all MediaWiki special tokens
+  # :html   :  read anything until </html>
   # :ref :     inside of a REF [[ .. ]]
   # :href :    inside of an HREF [ .. ]
   # :func :    inside of a block <[ .. ]> or inline <- .. -> function
@@ -33,66 +34,71 @@ class TaskJuggler
     def initialize(masterFile, log)
       tokenPatterns = [
         # :bol mode rules
-        [ :LINEBREAK, '\s*\n', /\s*\n/, :bol, method('linebreak') ],
-        [ nil, '\s+', /\s+/, :bol, method('inlineMode') ],
+        [ :LINEBREAK, /\s*\n/, :bol, method('linebreak') ],
+        [ nil, /\s+/, :bol, method('inlineMode') ],
 
         # :bop mode rules
-        [ :PRE, ' [^\n]+\n?', / [^\n]+\n?/, :bop, method('pre') ],
-        [ nil, '\s*\n', /\s*\n/, :bop, method('linebreak') ],
+        [ :PRE, / [^\n]+\n?/, :bop, method('pre') ],
+        [ nil, /\s*\n/, :bop, method('linebreak') ],
 
         # :inline mode rules
-        [ :SPACE, '[ \t\n]+', /[ \t\n]+/, :inline, method('space') ],
+        [ :SPACE, /[ \t\n]+/, :inline, method('space') ],
 
         # :bop and :bol mode rules
-        [ :INLINEFUNCSTART, '<-', /<-/, [ :bop, :bol, :inline ],
+        [ :INLINEFUNCSTART, /<-/, [ :bop, :bol, :inline ],
           method('functionStart') ],
-        [ :BLOCKFUNCSTART, '<\[', /<\[/, [ :bop, :bol ], method('functionStart') ],
-        [ ':TITLE*', '={2,5}', /={2,5}/, [ :bop, :bol ], method('titleStart') ],
-        [ 'TITLE*END', '={2,5}', /={2,5}/, :inline, method('titleEnd') ],
-        [ 'BULLET*', '\*{1,4}[ \t]+', /\*{1,4}[ \t]+/, [ :bop, :bol ], method('bullet') ],
-        [ 'NUMBER*', '\#{1,4}[ \t]+', /\#{1,4}[ \t]+/, [ :bop, :bol ], method('number') ],
-        [ :HLINE, '----', /----/, [ :bop, :bol ], method('inlineMode') ],
+        [ :BLOCKFUNCSTART, /<\[/, [ :bop, :bol ], method('functionStart') ],
+        [ ':TITLE*', /={2,5}/, [ :bop, :bol ], method('titleStart') ],
+        [ 'TITLE*END', /={2,5}/, :inline, method('titleEnd') ],
+        [ 'BULLET*', /\*{1,4}[ \t]+/, [ :bop, :bol ], method('bullet') ],
+        [ 'NUMBER*', /\#{1,4}[ \t]+/, [ :bop, :bol ], method('number') ],
+        [ :HLINE, /----/, [ :bop, :bol ], method('inlineMode') ],
 
         # :bop, :bol and :inline mode rules
         # The <nowiki> token puts the scanner into :nowiki mode.
-        [ nil, '<nowiki>', /<nowiki>/, [ :bop, :bol, :inline ], method('nowikiStart') ],
-        [ :FCOLSTART, '<fcol:([a-z]+|#[0-9A-Fa-f]{3,6})>', /<fcol:([a-z]+|#[0-9A-Fa-f]{3,6})>/, [ :bop, :bol,
+        [ nil, /<nowiki>/, [ :bop, :bol, :inline ], method('nowikiStart') ],
+        [ nil, /<html>/, [ :bop, :bol, :inline ], method('htmlStart') ],
+        [ :FCOLSTART, /<fcol:([a-z]+|#[0-9A-Fa-f]{3,6})>/, [ :bop, :bol,
           :inline ],
           method('fontColorStart') ],
-        [ :FCOLEND, '<\/fcol>', /<\/fcol>/, [ :bop, :bol, :inline ],
+        [ :FCOLEND, /<\/fcol>/, [ :bop, :bol, :inline ],
           method('fontColorEnd') ],
-        [ :QUOTES, '\'{2,5}', /'{2,5}/, [ :bop, :bol, :inline ], method('quotes') ],
-        [ :REF, '\[\[', /\[\[/, [ :bop, :bol, :inline ], method('refStart') ],
-        [ :HREF, '\[', /\[/, [ :bop, :bol, :inline], method('hrefStart') ],
-        [ :WORD, '.[^ \n\t\[<\']*', /.[^ \n\t\[<']*/, [ :bop, :bol, :inline ],
+        [ :QUOTES, /'{2,5}/, [ :bop, :bol, :inline ], method('quotes') ],
+        [ :REF, /\[\[/, [ :bop, :bol, :inline ], method('refStart') ],
+        [ :HREF, /\[/, [ :bop, :bol, :inline], method('hrefStart') ],
+        [ :WORD, /.[^ \n\t\[<']*/, [ :bop, :bol, :inline ],
           method('inlineMode') ],
 
         # :nowiki mode rules
-        [ nil, '<\/nowiki>', /<\/nowiki>/, :nowiki, method('nowikiEnd') ],
-        [ :WORD, '(<(?!\/nowiki>)|[^ \t\n<])+', /(<(?!\/nowiki>)|[^ \t\n<])+/, :nowiki ],
-        [ :SPACE, '[ \t]+', /[ \t]+/, :nowiki ],
-        [ :LINEBREAK, '\s*\n', /\s*\n/, :nowiki ],
+        [ nil, /<\/nowiki>/, :nowiki, method('nowikiEnd') ],
+        [ :WORD, /(<(?!\/nowiki>)|[^ \t\n<])+/, :nowiki ],
+        [ :SPACE, /[ \t]+/, :nowiki ],
+        [ :LINEBREAK, /\s*\n/, :nowiki ],
+
+        # :html mode rules
+        [ :HTMLBLOB, /(.|\n)*<\/html>/ , :html, method('htmlEnd') ],
+        [ :HTMLBLOB, /.*\n/ , :html ],
 
         # :ref mode rules
-        [ :REFEND, '\]\]', /\]\]/, :ref, method('refEnd') ],
-        [ :WORD, '(<(?!-)|(\](?!\])|[^|<\]]))+', /(<(?!-)|(\](?!\])|[^|<\]]))+/, :ref ],
-        [ :QUERY, '<-\w+->', /<-\w+->/, :ref, method('query') ],
-        [ :LITERAL, '.', /./, :ref ],
+        [ :REFEND, /\]\]/, :ref, method('refEnd') ],
+        [ :WORD, /(<(?!-)|(\](?!\])|[^|<\]]))+/, :ref ],
+        [ :QUERY, /<-\w+->/, :ref, method('query') ],
+        [ :LITERAL, /./, :ref ],
 
         # :href mode rules
-        [ :HREFEND, '\]', /\]/, :href, method('hrefEnd') ],
-        [ :WORD, '(<(?!-)|[^ \t\n\]<])+', /(<(?!-)|[^ \t\n\]<])+/, :href ],
-        [ :QUERY, '<-\w+->', /<-\w+->/, :href, method('query') ],
-        [ :SPACE, '[ \t\n]+', /[ \t\n]+/, :href ],
+        [ :HREFEND, /\]/, :href, method('hrefEnd') ],
+        [ :WORD, /(<(?!-)|[^ \t\n\]<])+/, :href ],
+        [ :QUERY, /<-\w+->/, :href, method('query') ],
+        [ :SPACE, /[ \t\n]+/, :href ],
 
         # :func mode rules
-        [ :INLINEFUNCEND, '->' , /->/ , :func, method('functionEnd') ],
-        [ :BLOCKFUNCEND, '\]>', /\]>/, :func, method('functionEnd') ],
-        [ :ID, '[a-zA-Z_]\w*', /[a-zA-Z_]\w*/, :func ],
-        [ :STRING, '"(\\\\"|[^"])*"', /"(\\"|[^"])*"/, :func, method('dqString') ],
-        [ :STRING, '\'(\\\\\'|[^\'])*\'', /'(\\'|[^'])*'/, :func, method('sqString') ],
-        [ nil, '[ \t\n]+', /[ \t\n]+/, :func ],
-        [ :LITERAL, '.', /./, :func ]
+        [ :INLINEFUNCEND, /->/ , :func, method('functionEnd') ],
+        [ :BLOCKFUNCEND, /\]>/, :func, method('functionEnd') ],
+        [ :ID, /[a-zA-Z_]\w*/, :func ],
+        [ :STRING, /"(\\"|[^"])*"/, :func, method('dqString') ],
+        [ :STRING, /'(\\'|[^'])*'/, :func, method('sqString') ],
+        [ nil, /[ \t\n]+/, :func ],
+        [ :LITERAL, /./, :func ]
       ]
       super(masterFile, log, tokenPatterns, :bop)
     end
@@ -166,6 +172,16 @@ class TaskJuggler
       [ types[match.length], match ]
     end
 
+    def htmlStart(type, match)
+      self.mode = :html
+      [ type, match ]
+    end
+
+    def htmlEnd(type, match)
+      self.mode = :inline
+      [ type, match[0..-8] ]
+    end
+
     def nowikiStart(type, match)
       self.mode = :nowiki
       [ type, match ]

data/lib/taskjuggler/RichText/SyntaxRules.rb

@@ -371,6 +371,11 @@ class TaskJuggler
     def rule_plainText
       repeatable
       optional
+      pattern(%w( !htmlBlob !space ), lambda {
+        el = RichTextElement.new(@richTextI, :htmlblob, @val[0].join)
+        el.appendSpace = !@val[1].nil?
+        el
+      })
       pattern(%w( $WORD !space ), lambda {
         el = RichTextElement.new(@richTextI, :text, @val[0])
         el.appendSpace = !@val[1].nil?
@@ -387,6 +392,13 @@ class TaskJuggler
       })
     end
 
+    def rule_htmlBlob
+      repeatable
+      pattern(%w( $HTMLBLOB ), lambda {
+        @val[0]
+      })
+    end
+
     def rule_space
       optional
       repeatable

data/lib/taskjuggler/SheetReceiver.rb

@@ -149,7 +149,7 @@ EOT
       begin
         @sheet = sheet.forceUTF8Encoding
       rescue
-        error($!)
+        error($!.message)
       end
 
       # If the sheet contains special cut markers, we extract only the content

data/lib/taskjuggler/TableColumnDefinition.rb

@@ -60,7 +60,7 @@ class TaskJuggler
 
     attr_reader :id, :cellText, :tooltip, :hAlign, :cellColor, :fontColor
     attr_accessor :title, :start, :end, :scale, :listItem, :listType,
-                  :width, :content, :column
+                  :width, :content, :column, :timeformat1, :timeformat2
 
     def initialize(id, title)
       # The column ID. It must be unique within the report.
@@ -99,6 +99,10 @@ class TaskJuggler
       @scale = 'week'
       # The width of columns.
       @width = nil
+      # Format of the upper calendar header line
+      @timeformat1 = nil
+      # Format of the lower calendar header line
+      @timeformat2 = nil
 
       # Reference to the ReportTableColumn object that was created based on this
       # definition.

data/lib/taskjuggler/TaskJuggler.rb

@@ -218,13 +218,13 @@ class TaskJuggler
       # Check the master file is really a file and not stdin.
       unless (masterFile = @project.inputFiles.masterFile)
         error('cannot_freeze_stdin',
-              "The project freeze feature only when the " +
+              "The project freeze feature can only be used when the " +
               "master file is a real file, not standard input.")
       end
 
       # Derive the file names for the header and bookings file from the base
       # name of the master file.
-      masterFileBase = File.basename(masterFile, '.tjp')
+      masterFileBase = Dir.pwd + '/' + File.basename(masterFile, '.tjp')
       headerFile = masterFileBase + '-header.tji'
       bookingsFileBase = masterFileBase + '-bookings'
       bookingsFile = bookingsFileBase + '.tji'

data/lib/taskjuggler/TaskScenario.rb

@@ -27,7 +27,8 @@ class TaskJuggler
       # time. So make sure some needed attributes really exist so we don't
       # have to check for existance each time we access them.
       %w( allocate assignedresources booking charge chargeset complete
-          criticalness depends duration effort end forward gauge length
+          competitors criticalness depends duration
+          effort end forward gauge length
           maxend maxstart minend minstart milestone pathcriticalness
           precedes priority scheduled shifts start status ).each do |attr|
         @property[attr, @scenarioIdx]
@@ -38,6 +39,20 @@ class TaskJuggler
       @dCache = DataCache.instance
     end
 
+    def markAsScheduled
+      return if @scheduled
+      @scheduled = true
+      if @milestone
+        typename = 'Milestone'
+      elsif @property.leaf?
+        typename = 'Task'
+      else
+        typename = 'Container'
+      end
+
+      Log.msg { "#{typename} #{@property.fullId} has been scheduled." }
+    end
+
     # Call this function to reset all scheduling related data prior to
     # scheduling.
     def prepareScheduling
@@ -78,18 +93,17 @@ class TaskJuggler
           @hasDurationSpec = true
           :durationTask
         else
-          # If the task is set as milestone is has a duration spec.
+          # If the task is set as milestone it has a duration spec.
           @hasDurationSpec = @milestone
           :startEndTask
         end
 
-      markMilestone
+      markAsMilestone
 
       # For start-end-tasks without allocation, we don't have to do
       # anything but to set the 'scheduled' flag.
       if @durationType == :startEndTask && @start && @end && @allocate.empty?
-        @scheduled = true
-        Log.msg { "Task #{@property.fullId}: #{period_to_s}" }
+        markAsScheduled
       end
 
       # Collect the limits of this task and all parent tasks into a single
@@ -575,6 +589,21 @@ class TaskJuggler
                 "to ensure allocations or use a higher 'priority'.")
       end
 
+      thieves = []
+      @competitors.each do |t|
+        thieves << t if t['priority', @scenarioIdx] < @priority
+      end
+      unless thieves.empty?
+        warning('priority_inversion',
+                "Due to a mix of ALAP and ASAP scheduled tasks or a " +
+                "dependency on a lower priority tasks the following " +
+                "task#{thieves.length > 1 ? 's' : ''} stole resources from " +
+                "#{@property.fullId} despite having a lower priority:")
+        thieves.each do |t|
+          info('priority_inversion_info', "Task #{t.fullId}", t.sourceFileInfo)
+        end
+      end
+
       @errors == 0
     end
 
@@ -966,25 +995,27 @@ class TaskJuggler
       # are only set in scheduleContainer().
       if @property.leaf?
         instance_variable_set(('@' + thisEnd).intern, date)
+        typename = 'Task'
         if @durationType == :startEndTask
           instance_variable_set(('@' + thisEnd + 'Idx').intern,
                                 @project.dateToIdx(date))
+          if @milestone
+            typename = 'Milestone'
+          end
         end
-        Log.msg { "Task #{@property.fullId}: #{period_to_s}" }
+        Log.msg { "Update #{typename} #{@property.fullId}: #{period_to_s}" }
       end
 
       if @milestone
         # Start and end date of a milestone are identical.
-        @scheduled = true
+        markAsScheduled
         if a(otherEnd).nil?
           propagateDate(a(thisEnd), !atEnd)
         end
-        Log.msg { "Milestone #{@property.fullId}: #{period_to_s}" }
       elsif !@scheduled && @start && @end &&
             !(@length == 0 && @duration == 0 && @effort == 0 &&
               !@allocate.empty?)
-        @scheduled = true
-        Log.msg { "Task #{@property.fullId} has been scheduled" }
+        markAsScheduled
       end
 
       # Propagate date to all dependent tasks. Don't do this for start
@@ -1115,8 +1146,8 @@ class TaskJuggler
       unless @start && @end
         raise "Start (#{@start}) and end (#{@end}) must be set"
       end
-      @scheduled = true
       Log.msg { "Container task #{@property.fullId} completed: #{period_to_s}" }
+      markAsScheduled
 
       # If we have modified the start or end date, we need to communicate this
       # new date to surrounding tasks.
@@ -1260,6 +1291,11 @@ class TaskJuggler
       query.string = "#{count.to_i}"
     end
 
+    def query_competitorcount(query)
+      query.sortable = query.numerical = @competitors.length
+      query.string = "#{@competitors.length}"
+    end
+
     def query_complete(query)
       # If we haven't calculated the value yet, calculate it first.
       unless @complete
@@ -1481,6 +1517,10 @@ class TaskJuggler
       end
     end
 
+    def query_scheduling(query)
+      query.string = @forward ? 'ASAP' : 'ASAP' if @property.leaf?
+    end
+
     def query_status(query)
       # If we haven't calculated the completion yet, calculate it first.
       calcStatus if @status.empty?
@@ -1751,7 +1791,7 @@ class TaskJuggler
         # scheduled once we have reached the other end.
         if (@forward && @currentSlotIdx >= @endIdx) |
            (!@forward && @currentSlotIdx <= @startIdx)
-          @scheduled = true
+          markAsScheduled
           @property.parents.each do |parent|
             parent.scheduleContainer(@scenarioIdx)
           end
@@ -1821,16 +1861,35 @@ class TaskJuggler
 
         # In case we have a persistent allocation we need to check if there
         # is already a locked resource and use it.
-        if allocation.lockedResource
-          bookResource(allocation.lockedResource)
-        else
-          # If not, we create a list of candidates in the proper order and
-          # assign the first one available.
-          allocation.candidates(@scenarioIdx).each do |candidate|
-            if bookResource(candidate)
-              allocation.lockedResource = candidate if allocation.persistent
-              break
-            end
+        locked_candidate = allocation.lockedResource
+        if locked_candidate
+          next if bookResource(locked_candidate)
+
+          if allocation.atomic &&
+             locked_candidate.bookedTask(@scenarioIdx, @currentSlotIdx)
+            rollbackBookings
+            return
+          end
+
+          if @forward
+            next if @currentSlotIdx < locked_candidate.getMaxSlot(@scenarioIdx)
+          else
+            next if @currentSlotIdx > locked_candidate.getMinSlot(@scenarioIdx)
+          end
+          # Persistent candidate is gone for the rest of the project!
+          # Warn and assign somebody else, if available!
+          warning('broken_persistence',
+                  "Persistence broken for Task #{@property.fullId} " +
+                  "- resource #{locked_candidate.name} is gone")
+          allocation.lockedResource = nil
+        end
+
+        # Create a list of candidates in the proper order and
+        # assign the first one available.
+        allocation.candidates(@scenarioIdx).each do |candidate|
+          if bookResource(candidate)
+            allocation.lockedResource = candidate if allocation.persistent
+            break
           end
         end
       end
@@ -1846,6 +1905,10 @@ class TaskJuggler
                   @doneEffort >= @effort) || !limitsOk?(@currentSlotIdx, r)
 
         if r.book(@scenarioIdx, @currentSlotIdx, @property)
+          # This method is _very_ performance sensitive. Uncomment this log
+          # message only if you really need it.
+          #Log.msg { "Book #{resource.name} on task #{@property.fullId}" }
+
           # For effort based task we adjust the the start end (as defined by
           # the scheduling direction) to align with the first booked time
           # slot.
@@ -1878,6 +1941,11 @@ class TaskJuggler
             @assignedresources << r
           end
           booked = true
+        elsif (competitor = r.bookedTask(@scenarioIdx, @currentSlotIdx))
+          # Keep a list of all the Tasks that have successfully competed for
+          # the same resources and are potentially delaying the progress of
+          # this Task.
+          @competitors << competitor unless @competitors.include?(competitor)
         end
       end
 
@@ -1966,7 +2034,7 @@ class TaskJuggler
         if @effort > 0
           if @doneEffort >= @effort
             @end = tentativeEnd
-            @scheduled = true
+            markAsScheduled
           end
         elsif @length > 0
           @doneLength = 0
@@ -1980,7 +2048,7 @@ class TaskJuggler
             if @doneLength >= @length && date >= tentativeEnd
               endDate = @project.idxToDate(idx + 1)
               @end = [ endDate, tentativeEnd ].max
-              @scheduled = true
+              markAsScheduled
               break
             end
           end
@@ -1988,13 +2056,13 @@ class TaskJuggler
           @doneDuration = ((tentativeEnd - @start) / slotDuration).to_i
           if @doneDuration >= @duration
             @end = tentativeEnd
-            @scheduled = true
+            markAsScheduled
           elsif @duration * slotDuration < (@project['now'] - @start)
             # This handles the case where the bookings don't provide enough
             # @doneDuration to reach @duration, but the now date would be
             # after the @start + @duration date.
             @end = @start + @duration * slotDuration
-            @scheduled = true
+            markAsScheduled
           end
         end
       end
@@ -2041,6 +2109,19 @@ class TaskJuggler
       end
     end
 
+    def rollbackBookings
+      @doneEffort = 0.0
+
+      @allocate.each do |allocation|
+        allocation.lockedResource = nil
+        allocation.candidates(@scenarioIdx).each do |resource|
+          resource.allLeaves.each do |r|
+            r.rollbackBookings(@scenarioIdx, @property)
+          end
+        end
+      end
+    end
+
     # This function checks if the task has a dependency on another task or
     # fixed date for a certain end. If +atEnd+ is true, the task end will be
     # checked.  Otherwise the start.
@@ -2096,7 +2177,7 @@ class TaskJuggler
 
     # This function determines if a task is a milestones and marks it
     # accordingly.
-    def markMilestone
+    def markAsMilestone
       return if @property.container? || @hasDurationSpec ||
         !@booking.empty? || !@allocate.empty?
 
@@ -2123,6 +2204,7 @@ class TaskJuggler
         @hasDurationSpec = true
         @end = @start if @start && !@end
         @start = @end if !@start && @end
+        Log.msg { "Mark as milestone #{@property.fullId}" }
       end
     end
 
@@ -2390,10 +2472,11 @@ class TaskJuggler
 
     # Recursively compile a list of Task properties which depend on the
     # current task.
-    def inputs(foundInputs, includeChildren, checkedTasks = [])
+    def inputs(foundInputs, includeChildren, checkedTasks = {})
       # Ignore tasks that we have already included in the checked tasks list.
-      return if checkedTasks.include?([ @property, includeChildren ])
-      checkedTasks << [ @property, includeChildren ]
+      taskSignature = [ @property, includeChildren ]
+      return if checkedTasks.include?(taskSignature)
+      checkedTasks[taskSignature] = true
 
       # An "input" must be a leaf task that has no direct or indirect (through
       # parent) following tasks. Only milestones are recognized as inputs.
@@ -2424,10 +2507,11 @@ class TaskJuggler
 
     # Recursively compile a list of Task properties which depend on the
     # current task.
-    def targets(foundTargets, includeChildren, checkedTasks = [])
+    def targets(foundTargets, includeChildren, checkedTasks = {})
       # Ignore tasks that we have already included in the checked tasks list.
-      return if checkedTasks.include?([ @property, includeChildren ])
-      checkedTasks << [ @property, includeChildren ]
+      taskSignature = [ @property, includeChildren ]
+      return if checkedTasks.include?(taskSignature)
+      checkedTasks[taskSignature] = true
 
       # A target must be a leaf function that has no direct or indirect
       # (through parent) following tasks. Only milestones are recognized as