taskjuggler 0.2.1 → 0.2.2

data/lib/taskjuggler/Attributes.rb

@@ -306,6 +306,18 @@ class TaskJuggler
     end
 
   end
+  class JournalSortListAttribute < ListAttributeBase
+
+    def initialize(property, type, container)
+      super
+    end
+
+    def JournalSortListAttribute ::tjpId
+      'journalsorting'
+    end
+
+  end
+
 
   class TimeIntervalListAttribute < ListAttributeBase
     def initialize(property, type, container)
@@ -577,6 +589,16 @@ class TaskJuggler
     end
   end
 
+  class SymbolListAttribute < ListAttributeBase
+    def initialize(property, type, container)
+      super
+    end
+
+    def SymbolListAttribute::tjpId
+      'symbollist'
+    end
+  end
+
   class TaskDepListAttribute < ListAttributeBase
     def initialize(property, type, container)
       super

data/lib/taskjuggler/Journal.rb

@@ -56,6 +56,125 @@ class TaskJuggler
       @journal.addEntry(self)
     end
 
+    # Convert the entry into a RichText string. The formatting is controlled
+    # by the Query parameters.
+    def to_rText(query)
+      # We use the alert level a sortable and numerical result.
+      if query.journalAttributes.include?('alert')
+        levelRecord = query.project['alertLevels'][alertLevel]
+        if query.selfContained
+          alertName = "<nowiki>[#{levelRecord[1]}]</nowiki> "
+        else
+          alertName = "[[File:icons/flag-#{levelRecord[0]}.png|" +
+          "alt=[#{levelRecord[1]}]|text-bottom]] "
+        end
+      else
+        alertName = ''
+      end
+
+      # The String that will hold the result as RichText markup.
+      rText = ''
+
+      # Markup to use for headlines.
+      hlMark = '==='
+
+      if query.journalAttributes.include?('property') && @property
+        if @property.is_a?(Task)
+          # Include the alert level, task name and ID.
+          rText += "#{hlMark} #{alertName} <nowiki>#{@property.name}</nowiki>"
+          if query.journalAttributes.include?('propertyid')
+            rText += " (ID: #{@property.fullId})"
+          end
+          rText += " #{hlMark}\n\n"
+
+          if query.journalAttributes.include?('timesheet') && @timeSheetRecord
+            # Include the reported time sheet data for this task.
+            rText += "'''Work:''' #{@timeSheetRecord.actualWorkPercent.to_i}% "
+            if @timeSheetRecord.actualWorkPercent !=
+               @timeSheetRecord.planWorkPercent
+              rText += "(#{@timeSheetRecord.planWorkPercent.to_i}%) "
+            end
+            if @timeSheetRecord.remaining
+              rText += "'''Remaining:''' #{@timeSheetRecord.actualRemaining}d "
+              if @timeSheetRecord.actualRemaining !=
+                 @timeSheetRecord.planRemaining
+                rText += "(#{@timeSheetRecord.planRemaining}d) "
+              end
+            else
+              rText += "'''End:''' " +
+                "#{@timeSheetRecord.actualEnd.to_s(query.timeFormat)} "
+              if @timeSheetRecord.actualEnd != @timeSheetRecord.planEnd
+                rText += "(#{@timeSheetRecord.planEnd.to_s(query.timeFormat)}) "
+              end
+            end
+            rText += "\n\n"
+          end
+        elsif !(@timeSheetRecord = @timeSheetRecord).nil? &&
+              @timeSheetRecord.task.is_a?(String)
+          # There is only an entry in the timesheet, but we don't have a
+          # corresponding Task in the Project. This must be a new task created
+          # by the timesheet submitter.
+          rText += "#{hlMark} #{alertName} <nowiki>[New Task] " +
+                   "#{@timeSheetRecord.name}</nowiki>"
+          if query.journalAttributes.include?('propertyid')
+            rText += " (ID: #{@timeSheetRecord.task})"
+          end
+          rText += " #{hlMark}\n\n"
+
+          if query.journalAttributes.include?('timesheet') && @timeSheetRecord
+            # We don't have any plan data since it's a new task. Just include
+            # the reported time sheet actuals.
+            rText += "'''Work:''' #{@timeSheetRecord.actualWorkPercent}% "
+            if @timeSheetRecord.remaining
+              rText += "'''Remaining:''' #{@timeSheetRecord.actualRemaining}d "
+            else
+              rText += "'''End:''' " +
+                       "#{@timeSheetRecord.actualEnd.to_s(query.timeFormat)} "
+            end
+            rText += "\n\n"
+          end
+        else
+          # Property must be a Resource
+          rText += "#{hlMark} #{alertName} Personal Notes #{hlMark}\n\n"
+        end
+
+        # We've shown the alert now. Don't show it again with the headline.
+        alertName = ''
+        # Increase level for subsequent headlines.
+        hlMark += '='
+      end
+
+      if query.journalAttributes.include?('headline')
+        rText += "#{hlMark} #{alertName}<nowiki>" + @headline +
+                 "</nowiki> #{hlMark}\n\n"
+      end
+
+      showDate = query.journalAttributes.include?('date')
+      showAuthor = query.journalAttributes.include?('author') && @author
+      if showDate || showAuthor
+        rText += "''Reported "
+      end
+      if showDate
+        rText += "on #{@date.to_s(query.timeFormat)} "
+      end
+      if showAuthor
+        rText += "by <nowiki>#{@author.name}</nowiki>"
+      end
+      rText += "''\n\n" if showDate || showAuthor
+
+      if query.journalAttributes.include?('flags') && !@flags.empty?
+        rText += "''Flags:'' #{@flags.join(', ')}\n\n"
+      end
+
+      if query.journalAttributes.include?('summary') && @summary
+        rText += @summary.richText.inputText + "\n\n"
+      end
+      if query.journalAttributes.include?('details') && @details
+        rText += @details.richText.inputText + "\n\n"
+      end
+      rText
+    end
+
     # Just for debugging
     def to_s # :nodoc:
       "Headline: #{@headline}\nProperty: #{@property.class}: #{@property.fullId}"
@@ -70,11 +189,27 @@ class TaskJuggler
 
     attr_reader :entries
 
+    JournalEntryList::SortingAttributes = [ :alert, :date, :seqno ]
+
     def initialize
       @entries = []
       @sorted = false
+      @sortBy = [ [ :date, 1 ], [ :alert, 1 ], [ :seqno, 1 ] ]
+    end
+
+    def setSorting(by)
+      by.each do |attr, direction|
+        unless SortingAttributes.include?(attr)
+          raise ArgumentError, "Unknown attribute #{attr}"
+        end
+        if (direction != 1) && (direction != -1)
+          raise ArgumentError, "Unknown direction #{direction}"
+        end
+      end
+      @sortBy = by
     end
 
+
     # Return the number of entries.
     def count
       @entries.length
@@ -167,12 +302,21 @@ class TaskJuggler
       else
         return self if @sorted
 
-        @entries.sort! { |a, b| a.date != b.date ?
-                                a.date <=> b.date :
-                                (a.alertLevel != b.alertLevel ?
-                                 a.alertLevel <=> b.alertLevel :
-                                 a.property.sequenceNo <=>
-                                 b.property.sequenceNo) }
+        @entries.sort! do |a, b|
+          res = 0
+          @sortBy.each do |attr, direction|
+            res = case attr
+                  when :date
+                    a.date <=> b.date
+                  when :alert
+                    a.alertLevel <=> b.alertLevel
+                  when :seqno
+                    a.property.sequenceNo <=> b.property.sequenceNo
+                  end * direction
+            break if res != 0
+          end
+          res
+        end
       end
       @sorted = true
       self
@@ -211,6 +355,124 @@ class TaskJuggler
       @propertyToEntries[entry.property] << entry
     end
 
+    def to_rti(query)
+      entries = JournalEntryList.new
+
+      case query.journalMode
+      when :journal
+        # This is the regular journal. It contains all journal entries that
+        # are dated in the query interval. If a property is given, only
+        # entries of this property are included.
+        if query.property
+          if query.property.is_a?(Task)
+            entries = entriesByTask(query.property, query.start, query.end,
+                                    query.hideJournalEntry)
+          elsif query.property.is_a?(Resource)
+            entries = entriesByResource(query.property, query.start, query.end,
+                                        query.hideJournalEntry)
+          end
+        else
+          entries = self.entries(query.start, query.end, query.hideJournalEntry)
+        end
+      when :journal_sub
+        # This mode also contains all journal entries that are dated in the
+        # query interval. A property must be given and only entries of this
+        # property and all its children are included.
+        if query.property.is_a?(Task)
+          entries = entriesByTaskR(query.property, query.start, query.end,
+                                   query.hideJournalEntry)
+        end
+      when :status_up
+        # In this mode only the last entries before the query end date for
+        # each task are included. An entry is not included if any of the
+        # parent tasks has a more recent entry that is still before the query
+        # end date.
+        if query.property
+          if query.property.is_a?(Task)
+            entries += currentEntries(query.end, query.property, 0, query.start,
+                                      query.hideJournalEntry)
+          end
+        else
+          query.project.tasks.each do |task|
+            # We only care about top-level tasks.
+            next if task.parent
+
+            entries += currentEntries(query.end, task, 0, query.start,
+                                      query.hideJournalEntry)
+            # Eliminate duplicates due to entries from adopted tasks
+            entries.uniq!
+          end
+        end
+      when :status_down
+        # In this mode only the last entries before the query end date for
+        # each task (incl. sub tasks) are included.
+        if query.property
+          if query.property.is_a?(Task)
+            entries += currentEntriesR(query.end, query.property, 0, query.start,
+                                       query.hideJournalEntry)
+          end
+        else
+          query.project.tasks.each do |task|
+            # We only care about top-level tasks.
+            next if task.parent
+
+            entries += currentEntriesR(query.end, task, 0, query.start,
+                                       query.hideJournalEntry)
+            # Eliminate duplicates due to entries from adopted tasks
+            entries.uniq!
+          end
+        end
+      when :alerts_down
+        # In this mode only the last entries before the query end date for
+        # each task (incl. sub tasks) and only the ones with the highest alert
+        # level are included.
+        if query.property
+          if query.property.is_a?(Task)
+            entries += alertEntries(query.end, query.property, 1, query.start,
+                                    query.hideJournalEntry)
+          end
+        else
+          query.project.tasks.each do |task|
+            # We only care about top-level tasks.
+            next if task.parent
+
+            entries += alertEntries(query.end, task, 1, query.start,
+                                    query.hideJournalEntry)
+            # Eliminate duplicates due to entries from adopted tasks
+            entries.uniq!
+          end
+        end
+      else
+        raise "Unknown jourmal mode: #{query.journalMode}"
+      end
+      # Sort entries according to the user specified sorting criteria.
+      entries.setSorting(query.sortJournalEntries)
+      entries.sort!
+
+      # The components of the message are either UTF-8 text or RichText. For
+      # the RichText components, we use the originally provided markup since
+      # we compose the result as RichText markup first.
+      rText = ''
+      entries.each do |entry|
+        rText += entry.to_rText(query)
+      end
+
+      # Now convert the RichText markup String into RichTextIntermediate
+      # format.
+      unless (rti = RichText.new(rText, RTFHandlers.create(query.project),
+                                 query.project.messageHandler).
+                                 generateIntermediateFormat)
+        query.project.warning('ptn_journal',
+                              "Syntax error in journal: #{rText}")
+        return nil
+      end
+      # No section numbers, please!
+      rti.sectionNumbers = false
+      # We use a special class to allow CSS formating.
+      rti.cssClass = 'tj_journal'
+      query.rti = rti
+    end
+
     # Return a list of all JournalEntry objects for the given _resource_ that
     # are dated between _startDate_ and _endDate_, are not hidden by their
     # flags matching _logExp_, are for Task _task_ and have at least the alert
@@ -218,7 +480,7 @@ class TaskJuggler
     # the entry.
     def entriesByResource(resource, startDate = nil, endDate = nil,
                           logExp = nil, task = nil, alertLevel = nil)
-      list = []
+      list = JournalEntryList.new
       @entries.each do |entry|
         if entry.author == resource &&
            (startDate.nil? || entry.date > startDate) &&
@@ -239,7 +501,7 @@ class TaskJuggler
     # nil, it always matches the entry.
     def entriesByTask(task, startDate = nil, endDate = nil, logExp = nil,
                       resource = nil, alertLevel = nil)
-      list = []
+      list = JournalEntryList.new
       @entries.each do |entry|
         if entry.property == task &&
            (startDate.nil? || entry.date >= startDate) &&
@@ -273,7 +535,7 @@ class TaskJuggler
 
     def entries(startDate = nil, endDate = nil, logExp = nil, property = nil,
                 alertLevel = nil)
-      list = []
+      list = JournalEntryList.new
       @entries.each do |entry|
         if (startDate.nil? || startDate <= entry.date) &&
            (endDate.nil? || endDate >= entry.date) &&
@@ -304,7 +566,8 @@ class TaskJuggler
 
     # Return the list of JournalEntry objects that are dated at or before
     # _date_, are for _property_ or any of its childs, have at least _level_
-    # alert and are after _minDate_.
+    # alert and are after _minDate_. We only return those entries with the
+    # highest overall alert level.
     def alertEntries(date, property, minLevel, minDate, logExp)
       maxLevel = 0
       entries = []

data/lib/taskjuggler/Log.rb

@@ -42,7 +42,7 @@ class TaskJuggler
     # into the shown segments will be shown for the next @@level nested
     # segments.
     def Log.segments=(s)
-      @@segments = []
+      @@segments = s
     end
 
     # if +s+ is true, progress information will not be shown.
@@ -61,7 +61,7 @@ class TaskJuggler
       return if @@level == 0
 
       @@stack << segment
-      Log.<< ">> [#{segment}] #{message}"
+      Log.msg { ">> [#{segment}] #{message}" }
     end
 
     # This function is used to close an open segment. To make this mechanism a
@@ -70,7 +70,7 @@ class TaskJuggler
     def Log.exit(segment, message = nil)
       return if @@level == 0
 
-      Log.<< "<< [#{segment}] #{message}" if message
+      Log.msg { "<< [#{segment}] #{message}" } if message
       if @@stack.include?(segment)
         loop do
           m = @@stack.pop
@@ -80,8 +80,9 @@ class TaskJuggler
     end
 
     # Use this function to show a log message within the currently active
-    # segment.
-    def Log.<<(message)
+    # segment. The message is the result of the passed block. The block will
+    # only be evaluated if the message will actually be shown.
+    def Log.msg(&block)
       return if @@level == 0
 
       offset = 0
@@ -91,8 +92,8 @@ class TaskJuggler
           # If a segment list is used to filter the output, we look for the
           # first listed segments on the stack. This and all nested segments
           # will be shown.
-          if @@segments.include?(segment) &&
-            (offset = @@stack.length - @@stack.index(segment)) >= @@level
+          if @@segments.include?(segment)
+            offset = @@stack.index(segment)
             showMessage = true
             break
           end
@@ -100,7 +101,7 @@ class TaskJuggler
         return unless showMessage
       end
       if @@stack.length - offset < @@level
-        $stderr.puts ' ' * (@@stack.length - offset) + message
+        $stderr.puts ' ' * (@@stack.length - offset) + yield(block)
       end
     end
 

data/lib/taskjuggler/Project.rb

@@ -368,6 +368,10 @@ class TaskJuggler
               false, false,   false, -1 ],
         [ 'interactive', 'Interactive', BooleanAttribute,
               false, false,   false, false ],
+        [ 'journalAttributes', 'Journal Attributes', SymbolListAttribute,
+              true,  false,   false, KeywordArray.new([ '*' ]) ],
+        [ 'journalMode', 'Journal Mode', SymbolAttribute,
+              true,  false,   false, :journal ],
         [ 'left',      'Left',         RichTextAttribute,
               true,  false,   false, nil ],
         [ 'loadUnit',  'Load Unit',    StringAttribute,
@@ -402,6 +406,8 @@ class TaskJuggler
               false, false,   false, nil ],
         [ 'shortTimeFormat', 'Short Time Format', StringAttribute,
               true,  true,    false, nil ],
+        [ 'sortJournalEntries', 'Sort Journal Entries', JournalSortListAttribute,
+              true,  false,   false, [[ :alert, 1 ], [ :date, 1 ], [ :seqno, 1 ]] ],
         [ 'sortResources', 'Sort Resources', SortListAttribute,
               true,  false,   false, [[ 'seqno', true, -1 ]] ],
         [ 'sortTasks', 'Sort Tasks',   SortListAttribute,
@@ -989,61 +995,9 @@ class TaskJuggler
     end
 
     def journal(query)
-      entries = JournalEntryList.new
-      @tasks.each do |task|
-        # We only care about top-level tasks.
-        next if task.parent
-
-        entries += (e = @attributes['journal'].
-          currentEntriesR(query.end, task, 0, query.start,
-                          query.hideJournalEntry))
-      end
-
-      # Eliminate duplicates due to entries from adopted tasks
-      entries.uniq!
-
-      journalMessages(entries, query, true)
-    end
-
-    # Create a blog-style list of all alert messages that match the Query.
-    def journalMessages(entries, query, longVersion)
-      # The components of the message are either UTF-8 text or RichText. For
-      # the RichText components, we use the originally provided markup since
-      # we compose the result as RichText markup first.
-      rText = ''
-      entries.each do |entry|
-        rText += "==== <nowiki>" + entry.headline + "</nowiki> ====\n"
-        #rText += "''Reported on #{entry.date.to_s(query.timeFormat)}'' "
-        #if entry.author
-        #  rText += "''by <nowiki>#{entry.author.name}</nowiki>''"
-        #end
-        #rText += "\n\n"
-        #unless entry.flags.empty?
-        #  rText += "''Flags:'' #{entry.flags.join(', ')}\n\n"
-        #end
-        if entry.summary
-          rText += entry.summary.richText.inputText + "\n\n"
-        end
-        if longVersion && entry.details
-          rText += entry.details.richText.inputText + "\n\n"
-        end
-      end
-      # Now convert the RichText markup String into RichTextIntermediate
-      # format.
-      unless (rti = RichText.new(rText, RTFHandlers.create(self),
-                                 @messageHandler).
-                                 generateIntermediateFormat)
-        warning('ptn_journal', "Syntax error in journal message: #{rText}")
-        return nil
-      end
-      # No section numbers, please!
-      rti.sectionNumbers = false
-      # We use a special class to allow CSS formating.
-      rti.cssClass = 'tj_journal'
-      query.rti = rti
+      @attributes['journal'].to_rti(query)
     end
 
-
     # Print the attribute values. It's used for debugging only.
     def to_s
       #raise "STOP!"
@@ -1071,6 +1025,8 @@ class TaskJuggler
   protected
 
     def prepareScenario(scIdx)
+      Log.enter('prepareScenario',
+                "Finishing scenario #{scenario(scIdx).get('name')}")
       Log.startProgressMeter("Preparing scenario " +
                              "#{scenario(scIdx).get('name')}")
       resources = PropertyList.new(@resources)
@@ -1141,9 +1097,13 @@ class TaskJuggler
           puts "#{task}"
         end
       end
+      Log.exit('prepareScenario',
+               "Preparing scenario #{scenario(scIdx).get('name')} completed")
     end
 
     def finishScenario(scIdx)
+      Log.enter('finishScenario',
+                "Finishing scenario #{scenario(scIdx).get('name')}")
       Log.startProgressMeter("Checking scenario #{scenario(scIdx).get('name')}")
       @tasks.each do |task|
         # Recursively traverse the top-level tasks to finish all tasks.
@@ -1164,6 +1124,8 @@ class TaskJuggler
       end
 
       Log.stopProgressMeter
+      Log.exit('finishScenario',
+               "Finishing scenario #{scenario(scIdx).get('name')} completed")
     end
 
     # Schedule all tasks for the given Scenario with index +scIdx+.
@@ -1208,13 +1170,10 @@ class TaskJuggler
           # Task not ready? Ignore it.
           next unless task.readyForScheduling?(scIdx)
 
-          if task.schedule(scIdx)
-            Log << "Task #{task.fullId}: #{task['start', scIdx]} -> " +
-                   "#{task['end', scIdx]}"
-          else
+          unless task.schedule(scIdx)
             failedTasks << task
           end
-          # The tasks has been completed or failed. But we can remove it from
+          # The task has been completed or failed. But we can remove it from
           # the todo list.
           taskToRemove = task
           # The scheduling of this task may cause other higher priority tasks
@@ -1227,9 +1186,18 @@ class TaskJuggler
         # has found a set of tasks that deadlock each other.
         if taskToRemove
           tasks.delete(taskToRemove)
+        elsif failedTasks.empty?
+          warning('deadlock',
+                  'Some tasks reference each other but don\'t provide ' +
+                  'enough information to start the scheduling. The ' +
+                  'scheduler does not know where to start scheduling ' +
+                  'these tasks. You need to provide more fixed dates ' +
+                  'or dependencies on already scheduled tasks.')
+          failedTasks = tasks
+          break
         else
-          tasks.each { |t| puts t.fullId }
-          raise 'Scheduler deadlock: Cannot schedule any further tasks'
+          # We have some tasks that cannot be scheduled.
+          break
         end
       end