taskjuggler 0.0.4 → 0.0.5

data/lib/TaskScenario.rb

@@ -438,7 +438,7 @@ class TaskJuggler
           error('task_pred_before',
                 "Task #{@property.fullId} must start after " +
                 "#{dependency.onEnd ? 'end' : 'start'} of task " +
-                "#{@property.fullId}.")
+                "#{task.fullId}.")
         end
       end
 
@@ -460,6 +460,33 @@ class TaskJuggler
               "end date.")
       end
 
+      if a('fail') || a('warn')
+        queryAttrs = { 'project' => @project,
+                       'scenarioIdx' => @scenarioIdx,
+                       'property' => @property,
+                       'scopeProperty' => nil,
+                       'start' => @project['start'],
+                       'end' => @project['end'],
+                       'loadUnit' => :days,
+                       'numberFormat' => @project['numberFormat'],
+                       'timeFormat' => @project['timeFormat'],
+                       'currencyFormat' => @project['currencyFormat'] }
+        query = Query.new(queryAttrs)
+        if a('fail') && a('fail').eval(query)
+          error('task_fail_check',
+                "User defined check failed for task #{@property.fullId} \n" +
+                "Condition: #{a('fail').to_s}\n" +
+                "Result:    #{a('fail').to_s(query)}")
+        end
+        if a('warn') && a('warn').eval(query)
+          warning('task_warn_check',
+                  "User defined warning triggered for task " +
+                  "#{@property.fullId} \n" +
+                  "Condition: #{a('warn').to_s}\n" +
+                  "Result:    #{a('warn').to_s(query)}")
+        end
+      end
+
       @errors == 0
     end
 
@@ -654,14 +681,20 @@ class TaskJuggler
     # Determine the criticalness of the individual task. This is a measure for
     # the likelyhood that this task will get the resources that it needs to
     # complete the effort. Tasks without effort are not cricital. The only
-    # exception are milestones which get an arbitrary value of 1.
+    # exception are milestones which get an arbitrary value between 0 and 2
+    # based on their priority.
     def calcCriticalness
       @property['criticalness', @scenarioIdx] = 0.0
       @property['pathcriticalness', @scenarioIdx] = nil
 
       # Users feel that milestones are somewhat important. So we use an
-      # arbitrary value larger than 0 for them.
-      @property['criticalness', @scenarioIdx] = 1.0 if a('milestone')
+      # arbitrary value larger than 0 for them. We make it priority dependent,
+      # so the user has some control over it. Priority 0 is 0, 500 is 1.0 and
+      # 1000 is 2.0. These values are pretty much randomly picked and probably
+      # require some more tuning based on real projects.
+      if a('milestone')
+        @property['criticalness', @scenarioIdx] = a('priority') / 500.0
+      end
 
       # Task without efforts of allocations are not critical.
       return if a('effort') <= 0 || @candidates.empty?
@@ -1125,6 +1158,70 @@ class TaskJuggler
       query.string = query.scaleLoad(work)
     end
 
+    def query_followers(query)
+      str = ''
+
+      # First gather the task that depend on the start of this task.
+      a('startsuccs').each do |task, onEnd|
+        str += "* <nowiki>#{task.name}</nowiki> (#{task.fullId}) "
+        if onEnd
+          taskEnd = task['end', query.scenarioIdx].to_s(query.timeFormat)
+          str += "[->[ #{taskEnd}"
+        else
+          taskStart = task['start', query.scenarioIdx].to_s(query.timeFormat)
+          str += "[->] #{taskStart}"
+        end
+        str += "\n"
+      end
+      # Than add the tasks that depend on the end of this task.
+      a('endsuccs').each do |task, onEnd|
+        str += "* <nowiki>#{task.name}</nowiki> (#{task.fullId}) "
+        if onEnd
+          taskEnd = task['end', query.scenarioIdx].to_s(query.timeFormat)
+          str += "]->[ #{taskEnd}"
+        else
+          taskStart = task['start', query.scenarioIdx].to_s(query.timeFormat)
+          str += "]->] #{taskStart}"
+        end
+        str += "\n"
+      end
+
+      rText = RichText.new(str)
+      query.rti = rText.generateIntermediateFormat
+    end
+
+    def query_precursors(query)
+      str = ''
+
+      # First gather the task that depend on the start of this task.
+      a('startpreds').each do |task, onEnd|
+        str += "* <nowiki>#{task.name}</nowiki> (#{task.fullId}) "
+        if onEnd
+          taskEnd = task['end', query.scenarioIdx].to_s(query.timeFormat)
+          str += "]->[ #{taskEnd}"
+        else
+          taskStart = task['start', query.scenarioIdx].to_s(query.timeFormat)
+          str += "[->[ #{taskStart}"
+        end
+        str += "\n"
+      end
+      # Than add the tasks that depend on the end of this task.
+      a('endpreds').each do |task, onEnd|
+        str += "* <nowiki>#{task.name}</nowiki> (#{task.fullId}) "
+        if onEnd
+          taskEnd = task['end', query.scenarioIdx].to_s(query.timeFormat)
+          str += "[->] #{taskEnd}"
+        else
+          taskStart = task['start', query.scenarioIdx].to_s(query.timeFormat)
+          str += "]->] #{taskStart}"
+        end
+        str += "\n"
+      end
+
+      rText = RichText.new(str)
+      query.rti = rText.generateIntermediateFormat
+    end
+
     # A list of the resources that have been allocated to work on the task in
     # the report time frame.
     def query_resources(query)
@@ -1314,6 +1411,7 @@ class TaskJuggler
         # The doneDuration counts the number of scheduled slots. It is increased
         # by one with every scheduled slot. The doneLength is only increased for
         # global working time slots.
+        bookResources(slot, slotDuration)
         @doneDuration += 1
         if @project.isWorkingTime(slot, slot + slotDuration)
           @doneLength += 1
@@ -1391,13 +1489,15 @@ class TaskJuggler
     end
 
     def bookResources(date, slotDuration)
+      # If there are no allocations defined, we can't do any bookings.
       # In projection mode we do not allow bookings prior to the current date
       # for any task (in strict mode) or tasks which have user specified
       # bookings (sloppy mode).
-      if @project.scenario(@scenarioIdx).get('projection') &&
-         date < @project['now'] &&
-         (@project.scenario(@scenarioIdx).get('strict') ||
-          a('assignedresources').empty?)
+      if a('allocate').empty? ||
+         (@project.scenario(@scenarioIdx).get('projection') &&
+          date < @project['now'] &&
+          (@project.scenario(@scenarioIdx).get('strict') ||
+           a('assignedresources').empty?))
         return
       end
 
@@ -1472,6 +1572,10 @@ class TaskJuggler
     def bookResource(resource, sbIdx, date)
       booked = false
       resource.allLeaves.each do |r|
+        # Prevent overbooking when multiple resources are allocated and
+        # available.
+        break if a('effort') > 0 && @doneEffort >= a('effort')
+
         if r.book(@scenarioIdx, sbIdx, @property)
 
           if a('assignedresources').empty?
@@ -1741,18 +1845,8 @@ class TaskJuggler
           @property['end', @scenarioIdx] <= @project['now'] ? 100.0 : 0.0
         @property['status', @scenarioIdx] =
           a('end') <= @project['now'] ? 'done' : 'not reached'
-      elsif @property.container?
-        #TODO
-        @property['status', @scenarioIdx] =
-          if a('end') < @project['now']
-            'done'
-          elsif a('start') > @project['now']
-            'not started'
-          else
-            'in progress'
-          end
       else
-        # Normal leaf task
+        completion = 0.0
         if a('end') <= @project['now']
           # The task has ended already. It's 100% complete.
           completion = 100.0
@@ -1760,9 +1854,24 @@ class TaskJuggler
           # The task has not started yet. Its' 0% complete.
           completion = 0.0
         else
-          # The task is in progress. Calculate the current completion degree.
-          completion = ((@project['now'] - a('start')) /
-                        (a('end') - a('start'))) * 100.0
+          # The task is in progress. Calculate the current completion
+          # degree.
+          if @property.leaf? && a('effort') > 0
+            # Effort based leaf tasks. The completion degree is the percantage
+            # of effort that has been done already.
+            done = getEffectiveWork(@project.dateToIdx(a('start')),
+                                    @project.dateToIdx(@project['now']))
+            total = @project.convertToDailyLoad(
+              a('effort') * @project['scheduleGranularity'])
+            completion = done / total * 100.0
+          else
+            # Container tasks and length/duration leaf tasks. There is no way
+            # we can compute the completion degree of a container task with a
+            # mix of effort and duration task in a meaningful way.  So, we
+            # just go by duration.
+            completion = ((@project['now'] - a('start')) /
+                          (a('end') - a('start'))) * 100.0
+          end
         end
         @property['complete', @scenarioIdx] = completion
         calcStatus

data/lib/TextFormatter.rb

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = RichTextElement.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009, 2010 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 'UTF8String'
+
+class TaskJuggler
+
+  # This class provides a simple text block formatting function. Plain text
+  # can be indented and limited to a given text width.
+  class TextFormatter
+
+    attr_accessor :indentation, :width, :firstLineIndent
+
+    def initialize(width = 80, indentation = 0, firstLineIndent = nil)
+      # The width of the text including the indent.
+      @width = width
+      # The indent for the first line of a paragraph
+      @firstLineIndent = firstLineIndent || indentation
+      # The indent for other lines.
+      @indentation = indentation
+    end
+
+    # Add @indentation number of spaces at the beginning of each line. The
+    # first line will be indented by @firstLineIndent. Lines that are longer
+    # than @width will be clipped.
+    def indent(str)
+      out = ''
+      # Indentation to be used for the currently processed line. It will be
+      # set to nil if it was inserted already.
+      indentBuf = ' ' * @firstLineIndent
+      linePos = 0
+      # Process the input String from start to finish.
+      str.each_utf8_char do |c|
+        if c == "\n"
+          # To prevent trailing white spaces we only insert a line break
+          # instead of the indent buffer.
+          if indentBuf
+            out += "\n"
+          end
+          # The indent buffer for the next line.
+          indentBuf = "\n" + ' ' * @indentation
+        else
+          # If we still have a indent buffer, we need to insert it first.
+          if indentBuf
+            out += indentBuf
+            linePos = indentBuf.delete("\n").length
+            indentBuf = nil
+          end
+          # Discard all characters that extend of the requested line width.
+          if linePos < @width
+            out << c
+            linePos += 1
+          end
+        end
+      end
+
+      # Always end with a line break
+      out += "\n" unless out[-1] == "\n"
+
+      out
+    end
+
+    # Format the String _str_ according to the class settings.
+    def format(str)
+      # The resulting String.
+      @out = ''
+      # The column of the last character of the current line.
+      @linePos = 0
+      # A buffer for the currently processed word.
+      @wordBuf = ''
+      # True of we are at the beginning of a line.
+      @beginOfLine = true
+      # A buffer for the indentation to be used for the next line.
+      @indentBuf = ' ' * @firstLineIndent
+      # The status of the state machine.
+      state = :beginOfParagraph
+
+      # Process the input String from start to finish.
+      str.each_utf8_char do |c|
+        case state
+        when :beginOfParagraph
+          # We are currently a the beginning of a new paragraph.
+          if c == ' ' || c == "\n"
+            # ignore it
+          else
+            # A new word started.
+            @wordBuf << c
+            state = :inWord
+          end
+        when :inWord
+          # We are in the middle of processing a word.
+          if c == ' ' || c == "\n"
+            # The word has ended.
+            appendWord
+            state = c == ' ' ? :betweenWords : :betweenWordsOrLines
+          else
+            # Add the character to the word buffer.
+            @wordBuf << c
+          end
+        when :betweenWords
+          # We are in between words.
+          if c == ' '
+            # ignore it
+          elsif c == "\n"
+            state = :betweenWordsOrLines
+          else
+            # A new word started.
+            @wordBuf << c
+            state = :inWord
+          end
+        when :betweenWordsOrLines
+          if c == "\n"
+            # The word break is really a paragraph break.
+            @indentBuf = "\n\n" + ' ' * @firstLineIndent
+            @beginOfLine = true
+            state = :beginOfParagraph
+          elsif c == ' '
+            state = :betweenWords
+          else
+            @wordBuf << c
+            state = :inWord
+          end
+        else
+          raise "Unknown state in state machine: #{state}"
+        end
+      end
+      # Add any still pending word.
+      appendWord
+
+      # Always end with a line break
+      @out += "\n" unless @out[-1] == "\n"
+
+      @out
+    end
+
+    private
+
+    def appendWord
+      # Ignore empty words.
+      wordLength = @wordBuf.length
+      return unless wordLength > 0
+
+      # If the word does not fit into the current line anymore, we have to
+      # start a new line.
+      @beginOfLine = true if @linePos + 1 + wordLength > @width
+
+      if @beginOfLine
+        # Insert the content of the @indentBuf and reset @linePos and
+        # @indentBuf.
+        @out += @indentBuf
+        @linePos = @indentBuf.delete("\n").length
+        @indentBuf = "\n" + ' ' * @indentation
+      else
+        # Insert a space to separate the words.
+        @out += ' '
+        @linePos += 1
+      end
+
+      # Append the word and reset the @wordBuf.
+      @out += @wordBuf
+      @wordBuf = ''
+      @linePos += wordLength
+      @beginOfLine = false if @beginOfLine
+    end
+
+  end
+
+end

data/lib/TextParser.rb

@@ -170,6 +170,15 @@ class TaskJuggler
       result
     end
 
+    # Return true if the scanner has processed all files.
+    def checkForEnd
+      token = @scanner.nextToken
+      unless token[0] == '.'
+        error('junk_at_expected_eof',
+              "Found garbage at expected end of file: #{token[1]}")
+      end
+    end
+
     # Return the SourceFileInfo of the TextScanner at the beginning of the
     # currently processed TextParser::Rule. Or return nil if we don't have a
     # current position.
@@ -243,7 +252,7 @@ class TaskJuggler
         transitions.each do |key, value|
           rule.transitions.each do |trans|
             if trans.has_key?(key)
-              raise "Fatal Error: Rule #{rule.name} has ambigeous " +
+              raise "Fatal Error: Rule #{rule.name} has ambiguous " +
                     "transitions for target #{key}"
             end
           end

data/lib/TextScanner.rb

@@ -56,35 +56,46 @@ class TaskJuggler
 
       def initialize(fileName)
         super()
-        @fileName = fileName
-        @file = File.new(fileName, 'r')
+        @fileName = fileName.dup.untaint
+        @file = fileName == '.' ? $stdin : File.new(@fileName, 'r')
         @bytes = 0
         Log << "Parsing file #{@fileName} ..."
         Log.startProgressMeter("Reading file #{fileName}")
       end
 
       def close
-        @file.close
+        @file.close unless @file == $stdin
       end
 
       def getc19
         Log.activity if @bytes & 0x3FFF == 0
-        @bytes += 1
+
         begin
-          @file.getc
+          # This function converts CR+LF or CR into LF on the fly.
+          if (c1 = @file.getc) == ?\r
+            @bytes += 1
+            # CR or CR/LF linebreaks
+            if (c2 = @file.getc) == ?\n
+              @bytes += 1
+              # Ok, CR, LF
+              return c2
+            else
+              # Just CR
+              @file.ungetc(c2)
+              return ?\n
+            end
+          else
+            # This is for LF linebreaks and all other characters
+            @bytes += 1
+            return c1
+          end
         rescue
-          nil
+          return nil
         end
       end
 
       def getc18
-        Log.activity if @bytes & 0x3FFF == 0
-        @bytes += 1
-        begin
-          c = @file.getc
-        rescue
-          return nil
-        end
+        c = getc19
         return nil if c.nil?
         '' << c
       end
@@ -114,16 +125,18 @@ class TaskJuggler
 
       def getc18
         return nil if @pos >= @length
-
-        c = @buffer[@pos]
-        @pos += 1
-        '' << c
+        '' << getc19
       end
 
       def getc19
         return nil if @pos >= @length
 
-        c = @buffer[@pos]
+        # This function converts CR+LF or CR into LF on the fly.
+        if (c = @buffer[@pos]) == "\r"
+          # CR or CR+LF
+          @pos += 1 if @buffer[@pos + 1] == "\n"
+          c = "\n"
+        end
         @pos += 1
         c
       end
@@ -193,7 +206,7 @@ class TaskJuggler
     def include(fileName)
       if fileName[0] != '/'
         if @fileStack.empty?
-          path = @masterPath
+          path = @masterPath == './' ? '' : @masterPath
         else
           pathOfCallingFile = @fileStack.last[0].dirname
           path = pathOfCallingFile.empty? ? '' : pathOfCallingFile + '/'
@@ -708,7 +721,7 @@ class TaskJuggler
           if (c = nextChar) == '-'
             state = 3
           elsif c.nil?
-            error('eof_in_istring1', 'Unexpected end of file in string')
+            errorEOF(1, token)
           elsif c == "\n"
             token << c
             state = 6
@@ -717,19 +730,26 @@ class TaskJuggler
             state = 2
           end
         when 2 # reading content line
-          while (c = nextChar) != "\n"
-            error('eof_in_istring2',
-                  'Unexpected end of file in string') if c.nil?
+          # The '->8-' is only valid if no other content preceded it on this
+          # line.
+          onlyBlanks = true
+          while (c = nextChar) != "\n" && !(c == '-' && onlyBlanks)
+            onlyBlanks = false if c != ' ' && c != "\t"
+            errorEOF(2, token) if c.nil?
             token << c
           end
-          token << c
-          state = 6
+          if c == '-'
+            # we may have found the start of '->8-'
+            state = 3
+          else
+            token << c
+            state = 6
+          end
         when 3 # reading '>' of '->8-'
           if (c = nextChar) == '>'
             state = 4
           else
-            error('eof_in_istring3',
-                  'Unexpected end of file in string') if c.nil?
+            errorEOF(3, token) if c.nil?
             token << '-'
             token << c
             state = 2
@@ -738,8 +758,7 @@ class TaskJuggler
           if (c = nextChar) == '8'
             state = 5
           else
-            error('eof_in_istring4',
-                  'Unexpected end of file in string') if c.nil?
+            errorEOF(4, token) if c.nil?
             token << c
             state = 2
           end
@@ -747,8 +766,7 @@ class TaskJuggler
           if (c = nextChar) == '-'
             return [ 'STRING', token ]
           else
-            error('eof_in_istring5',
-                  'Unexpected end of file in string') if c.nil?
+            errorEOF(5, token) if c.nil?
             token << c
             state = 2
           end
@@ -763,8 +781,14 @@ class TaskJuggler
                 returnChar(c)
                 break
               else
-                error('bad_indent',
-                      'All string lines must have the exact same indentation.')
+                warning('bad_indent',
+                        "Not all lines of string have same indentation. " +
+                        "The first line of the string determines the " +
+                        "indentation for all subsequent lines of the same " +
+                        "string.")
+                token << c
+                state = 2
+                break
               end
             end
           end
@@ -867,6 +891,12 @@ class TaskJuggler
       token
     end
 
+    def errorEOF(no, token)
+      error("eof_in_istring#{no}",
+            "Unexpected end of file in string '#{token[0,20]}...'" +
+            "starting in line #{@startOfToken.lineNo}.")
+    end
+
   end
 
 end

data/lib/TimeSheetReceiver.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = TimeSheetReceiver.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009, 2010 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 'SheetReceiver'
+
+class TaskJuggler
+
+  # This class specializes SheetReceiver to process time sheets.
+  class TimeSheetReceiver < SheetReceiver
+
+    def initialize(appName)
+      super(appName, 'time')
+
+      @tj3clientOption = 'check-ts'
+
+      # File name and directory settings.
+      @sheetDir = 'TimeSheets'
+      @templateDir = 'TimeSheetTemplates'
+      @failedMailsDir = "#{@sheetDir}/FailedMails"
+      @failedSheetsDir = "#{@sheetDir}/FailedSheets"
+      @signatureFile = "#{@templateDir}/acceptable_intervals"
+      @logFile = 'timesheets.log'
+
+      # Regular expression to identify time sheets.
+      @sheetHeader = /^[ ]*timesheet\s([a-z][a-z0-9_]*)\s[0-9\-:+]*\s-\s([0-9]*-[0-9]*-[0-9]*)/
+      # Regular expression to extract the sheet signature (time period).
+      @signatureFilter = /^[ ]*timesheet\s[a-z][a-z0-9_]*\s([0-9:\-+]*\s-\s[0-9:\-+]*)/
+    end
+
+  end
+
+end
+