taskjuggler 3.3.0 → 3.4.0

data/lib/taskjuggler/Limits.rb

@@ -83,6 +83,20 @@ class TaskJuggler
         end
       end
 
+      # Decrease the counter if the _index_ matches the @interval. The
+      # relationship between @resource and _resource_ is described below.
+      # @r \ _r_  nil    y
+      # nil       inc   inc
+      #  x         -    if x==y inc else -
+      def dec(index, resource)
+        if @interval.contains?(index) &&
+           (@resource.nil? || @resource == resource)
+          # The condition is met, decrement the counter for the interval.
+          @dirty = true
+          @scoreboard[idxToSbIdx(index)] -= 1
+        end
+      end
+
       # Returns true if the counter for the time slot specified by +index+ or
       # all counters are within the limit. If +upper+ is true, only upper
       # limits are checked. If not, only lower limits are checked. The
@@ -237,6 +251,14 @@ class TaskJuggler
       end
     end
 
+    # This function decreases the counters for all limits for a specific
+    # interval identified by _index_.
+    def dec(index, resource = nil)
+      @limits.each do |limit|
+        limit.dec(index, resource)
+      end
+    end
+
     # Check all upper limits and return true if none is exceeded. If an
     # _index_ is specified only the counters for that specific period are
     # tested.  Otherwise all periods are tested. If _resource_ is nil, only

data/lib/taskjuggler/Log.rb

@@ -124,7 +124,7 @@ class TaskJuggler
 
       maxlen = 60
       text = text.ljust(maxlen)
-      text = text[0..maxlen - 1] if text.length > maxlen
+      text = text[0..maxlen - 1] if text.length_utf8 > maxlen
       @@progressMeter = text
       $stdout.print("#{@@progressMeter} ...\r")
     end

data/lib/taskjuggler/MessageHandler.rb

@@ -115,7 +115,7 @@ class TaskJuggler
     include Singleton
 
     attr_reader :messages, :errors
-    attr_accessor :logFile, :appName, :abortOnWarning, :trapSetup, :baselineSFI
+    attr_accessor :logFile, :appName, :abortOnWarning
 
     LogLevels = { :none => 0, :fatal => 1, :error => 2, :critical => 2,
                   :warning => 3, :info => 4, :debug => 5 }
@@ -141,15 +141,25 @@ class TaskJuggler
       # Set to true if program should be exited on warnings.
       @abortOnWarning = false
       # A SourceFileInfo object that will be used to baseline the provided
-      # source file infos of the messages.
-      @baselineSFI = nil
-      # If this is set the true, we only throw a TjRuntimeError instead of
-      # using exit().
-      @trapSetup = false
+      # source file infos of the messages. We use a Hash to keep per Thread
+      # values.
+      @baselineSFI = {}
+      # Each tread can request to only throw a TjRuntimeError instead of
+      # using exit(). This hash keeps a flag for each thread using the
+      # object_id of the Thread object as key.
+      @trapSetup = {}
 
       clear
     end
 
+    def baselineSFI=(line)
+      @baselineSFI[Thread.current.object_id] = line
+    end
+
+    def trapSetup=(enable)
+      @trapSetup[Thread.current.object_id] = enable
+    end
+
     # Clear the error log.
     def clear
       # A counter for messages of type error.
@@ -248,10 +258,10 @@ class TaskJuggler
                    data = nil, scenario = nil)
       # If we have a SourceFileInfo and a baseline SFI, we correct the
       # sourceFileInfo accordingly.
-      if sourceFileInfo && @baselineSFI
+      baselineSFI = @baselineSFI[Thread.current.object_id]
+      if sourceFileInfo && baselineSFI
         sourceFileInfo = TextParser::SourceFileInfo.new(
-          @baselineSFI.fileName,
-          sourceFileInfo.lineNo + @baselineSFI.lineNo - 1,
+          baselineSFI.fileName, sourceFileInfo.lineNo + baselineSFI.lineNo - 1,
           sourceFileInfo.columnNo)
       end
 
@@ -276,7 +286,7 @@ class TaskJuggler
       when :error
         # Increase the error counter.
         @errors += 1
-        if @trapSetup
+        if @trapSetup[Thread.current.object_id]
           raise TjRuntimeError
         else
           exit 1

data/lib/taskjuggler/PTNProxy.rb

@@ -41,7 +41,12 @@ class TaskJuggler
       if @ptn.propertySet.flatNamespace
         @ptn.id
       else
-        @parent.logicalId + '.' + @ptn.id[(@ptn.id.rindex('.') + 1).. -1]
+        if (dotPos = @ptn.id.rindex('.'))
+          id = @ptn.id[(dotPos + 1)..-1]
+        else
+          id = @ptn.id
+        end
+        @parent.logicalId + '.' + id
       end
     end
 

data/lib/taskjuggler/Project.rb

@@ -253,6 +253,8 @@ class TaskJuggler
               true,  false,   true,  [] ],
         [ 'complete',  'Completion',   FloatAttribute,
               false, false,   true,  nil ],
+        [ 'competitors', 'Competitors', TaskListAttribute,
+              false, false,   true,  [] ],
         [ 'criticalness', 'Criticalness', FloatAttribute,
               false, false,   true,  0.0 ],
         [ 'depends',   'Preceding tasks', DependencyListAttribute,
@@ -334,8 +336,10 @@ class TaskJuggler
         #     Inh.   Inh.Prj  Scen.  Default
         [ 'accountroot',  'Account Root',    PropertyAttribute,
               true,  false,   false, nil ],
+        [ 'auxdir', 'Auxiliary files directory', StringAttribute,
+              true,  false,   false, '' ],
         [ 'bsi',       'BSI',          StringAttribute,
-              false, false,   false, "" ],
+              false, false,   false, '' ],
         [ 'caption',   'Caption',      RichTextAttribute,
               true,  false,   false, nil ],
         [ 'center',    'Center',       RichTextAttribute,
@@ -397,7 +401,9 @@ class TaskJuggler
         [ 'openNodes', 'Open Nodes',   NodeListAttribute,
               false, false,   false, nil ],
         [ 'prolog',    'Prolog',       RichTextAttribute,
-              true, false,   false, nil],
+              true, false,   false, nil ],
+        [ 'rawHtmlHead', 'Raw HTML Header', StringAttribute,
+              true, false,   false, nil ],
         [ 'resourceAttributes', 'Resource Attributes', FormatListAttribute,
               true,  false,   false, KeywordArray.new([ '*' ]) ],
         [ 'resourceroot',  'resource Root', PropertyAttribute,
@@ -1150,8 +1156,8 @@ class TaskJuggler
     # Schedule all tasks for the given Scenario with index +scIdx+.
     def scheduleScenario(scIdx)
       tasks = PropertyList.new(@tasks)
-      # Only care about leaf tasks that are not milestones are aren't
-      # scheduled already (due to bookings).
+      # Only care about leaf tasks that are not milestones and aren't
+      # scheduled already (marked with the 'scheduled' attribute).
       tasks.delete_if { |task| !task.leaf? ||
                                task['milestone', scIdx] ||
                                task['scheduled', scIdx] }

data/lib/taskjuggler/ProjectFileParser.rb

@@ -466,8 +466,7 @@ class TaskJuggler
     # Pop the last stack entry from the @fileStack and restore the class
     # variables according to the now top-entry.
     def popFileStack
-      @fileStack.pop
-      stackEntry = @fileStack.last
+      stackEntry = @fileStack.pop
       @fileStackVariables.each do |var|
         instance_variable_set('@' + var, stackEntry[var])
       end

data/lib/taskjuggler/ProjectFileScanner.rb

@@ -22,26 +22,26 @@ class TaskJuggler
     def initialize(masterFile)
       tokenPatterns = [
         # Any white spaces
-        [ nil, '\s+', /\s+/, :tjp, method('newPos') ],
+        [ nil, /\s+/, :tjp, method('newPos') ],
 
         # Single line comments starting with #
-        [ nil, '#.*\n?', /#.*\n?/, :tjp, method('newPos') ],
+        [ nil, /#.*\n?/, :tjp, method('newPos') ],
 
         # C++ style single line comments starting with //
-        [ nil, '//.*\n?', /\/\/.*\n?/, :tjp, method('newPos') ],
+        [ nil, /\/\/.*\n?/, :tjp, method('newPos') ],
 
         # C style single line comment /* .. */.
-        [ nil, '/\*.*\*/', /\/\*.*\*\//, :tjp, method('newPos') ],
+        [ nil, /\/\*.*\*\//, :tjp, method('newPos') ],
 
         # C style multi line comment: We need three patterns here. The first
         # one is for the start of the string. It switches the scanner mode to
         # the :cppComment mode.
-        [ nil, '/\*([^*]*[^/]|.*)\n', /\/\*([^*]*[^\/]|.*)\n/, :tjp, method('startComment') ],
+        [ nil, /\/\*([^*]*[^\/]|.*)\n/, :tjp, method('startComment') ],
         # This is the string end pattern. It switches back to tjp mode.
-        [ nil, '.*\*/', /.*\*\//, :cppComment, method('endComment') ],
+        [ nil, /.*\*\//, :cppComment, method('endComment') ],
         # This pattern matches string lines that contain neither the start,
         # nor the end of the string.
-        [ nil, '^.*\n', /^.*\n/, :cppComment ],
+        [ nil, /^.*\n/, :cppComment ],
 
         # Macro Call: This case is more complicated because we want to replace
         # macro calls inside of numbers, strings and identifiers. For this to
@@ -54,102 +54,100 @@ class TaskJuggler
         # with neither start nor end. Macro calls inside of strings need a
         # special start pattern that is active in the string modes. Both
         # patterns switch the scanner to macroCall mode.
-        [ nil, '([-a-zA-Z_0-9>:.+]*|"(\\\\"|[^"])*?|\'(\\\\\'|[^\'])*?)?\$\{\s*([a-zA-Z_]\w*)(\s*"(\\\\"|[^"])*")*', /([-a-zA-Z_0-9>:.+]*|"(\\"|[^"])*?|'(\\'|[^'])*?)?\$\{\s*([a-zA-Z_]\w*)(\s*"(\\"|[^"])*")*/,
+        [ nil, /([-a-zA-Z_0-9>:.+]*|"(\\"|[^"])*?|'(\\'|[^'])*?)?\$\{\s*(\??[a-zA-Z_]\w*)(\s*"(\\"|[^"])*")*/,
           :tjp, method('startMacroCall') ],
         # This pattern is similar to the previous one, but is active inside of
         # multi-line strings. The corresponding rule for sizzors strings
         # can be found below.
-        [ nil, '(\\\\"|[^"])*?\$\{\s*([a-zA-Z_]\w*)(\s*"(\\\\"|[^"])*")*',
-/(\\"|[^"])*?\$\{\s*([a-zA-Z_]\w*)(\s*"(\\"|[^"])*")*/,
+        [ nil, /(\\"|[^"])*?\$\{\s*(\??[a-zA-Z_]\w*)(\s*"(\\"|[^"])*")*/,
           :dqString, method('startMacroCall') ],
-        [ nil, '(\\\\\'|[^\'])*?\$\{\s*([a-zA-Z_]\w*)(\s*"(\\\\"|[^"])*")*',
-/(\\'|[^'])*?\$\{\s*([a-zA-Z_]\w*)(\s*"(\\"|[^"])*")*/,
+        [ nil, /(\\'|[^'])*?\$\{\s*(\??[a-zA-Z_]\w*)(\s*"(\\"|[^"])*")*/,
           :sqString, method('startMacroCall') ],
         # This pattern matches the end of a macro call. It injects the prefix
         # and the expanded macro into the scanner again. The mode is restored
         # to the previous mode.
-        [ nil, '(\s*"(\\\\"|[^"])*")*\s*\}', /(\s*"(\\"|[^"])*")*\s*\}/, :macroCall, method('endMacroCall') ],
+        [ nil, /(\s*"(\\"|[^"])*")*\s*\}/, :macroCall, method('endMacroCall') ],
         # This pattern collects macro call arguments in lines that contain
         # neither the start nor the end of the macro.
-        [ nil, '.*\n', /.*\n/, :macroCall, method('midMacroCall') ],
+        [ nil, /.*\n/, :macroCall, method('midMacroCall') ],
 
         # Environment variable reference. This is similar to the macro call,
         # but the it can only extend within the starting line.
-        [ nil, '([-a-zA-Z_0-9>:.+]*|"(\\\\"|[^"])*?|\'(\\\\\'|[^\'])*?)?\$\([A-Z_][A-Z_0-9]*\)', /([-a-zA-Z_0-9>:.+]*|"(\\"|[^"])*?|'(\\'|[^'])*?)?\$\([A-Z_][A-Z_0-9]*\)/,
+        [ nil, /([-a-zA-Z_0-9>:.+]*|"(\\"|[^"])*?|'(\\'|[^'])*?)?\$\([A-Z_][A-Z_0-9]*\)/,
           :tjp, method('environmentVariable') ],
         # An ID with a colon suffix: foo:
-        [ :ID_WITH_COLON, '[a-zA-Z_]\w*:', /[a-zA-Z_]\w*:/, :tjp, method('chop') ],
+        [ :ID_WITH_COLON, /[a-zA-Z_]\w*:/, :tjp, method('chop') ],
 
         # An absolute ID: a.b.c
-        [ :ABSOLUTE_ID, '[a-zA-Z_]\w*(\.[a-zA-Z_]\w*)+', /[a-zA-Z_]\w*(\.[a-zA-Z_]\w*)+/ ],
+        [ :ABSOLUTE_ID, /[a-zA-Z_]\w*(\.[a-zA-Z_]\w*)+/ ],
 
         # A normal ID: bar
-        [ :ID, '[a-zA-Z_]\w*', /[a-zA-Z_]\w*/ ],
+        [ :ID, /[a-zA-Z_]\w*/ ],
 
         # A date
-        [ :DATE, '\d{4}-\d{1,2}-\d{1,2}(-\d{1,2}:\d{1,2}(:\d{1,2})?(-[-+]?\d{4})?)?', /\d{4}-\d{1,2}-\d{1,2}(-\d{1,2}:\d{1,2}(:\d{1,2})?(-[-+]?\d{4})?)?/, :tjp, method('to_date') ],
+        [ :DATE, /\d{4}-\d{1,2}-\d{1,2}(-\d{1,2}:\d{1,2}(:\d{1,2})?(-[-+]?\d{4})?)?/, :tjp, method('to_date') ],
 
         # A time of day
-        [ :TIME, '\d{1,2}:\d{2}', /\d{1,2}:\d{2}/, :tjp, method('to_time') ],
+        [ :TIME, /\d{1,2}:\d{2}/, :tjp, method('to_time') ],
 
         # A floating point number (e. g. 3.143)
-        [ :FLOAT, '\d*\.\d+', /\d*\.\d+/, :tjp, method('to_f') ],
+        [ :FLOAT, /\d*\.\d+/, :tjp, method('to_f') ],
 
         # An integer number
-        [ :INTEGER, '\d+', /\d+/, :tjp, method('to_i') ],
+        [ :INTEGER, /\d+/, :tjp, method('to_i') ],
 
         # Multi line string enclosed with double quotes. The string may
         # contain double quotes prefixed by a backslash. The first rule
         # switches the scanner to dqString mode.
-        [ 'nil', '"(\\\\"|[^"])*', /"(\\"|[^"])*/, :tjp, method('startStringDQ') ],
+        [ 'nil', /"(\\"|[^"])*/, :tjp, method('startStringDQ') ],
         # Any line not containing the start or end.
-        [ 'nil', '^(\\\\"|[^"])*\n', /^(\\"|[^"])*\n/, :dqString, method('midStringDQ') ],
+        [ 'nil', /^(\\"|[^"])*\n/, :dqString, method('midStringDQ') ],
         # The end of the string.
-        [ :STRING, '(\\\\"|[^"])*"', /(\\"|[^"])*"/, :dqString, method('endStringDQ') ],
+        [ :STRING, /(\\"|[^"])*"/, :dqString, method('endStringDQ') ],
 
         # Multi line string enclosed with single quotes.
-        [ 'nil', '\'(\\\\\'|[^\'])*', /'(\\'|[^'])*/, :tjp, method('startStringSQ') ],
+        [ 'nil', /'(\\'|[^'])*/, :tjp, method('startStringSQ') ],
         # Any line not containing the start or end.
-        [ 'nil', '^(\\\\\'|[^\'])*\n', /^(\\'|[^'])*\n/, :sqString, method('midStringSQ') ],
+        [ 'nil', /^(\\'|[^'])*\n/, :sqString, method('midStringSQ') ],
         # The end of the string.
-        [ :STRING, '(\\\\\'|[^\'])*\'', /(\\'|[^'])*'/, :sqString, method('endStringSQ') ],
+        [ :STRING, /(\\'|[^'])*'/, :sqString, method('endStringSQ') ],
 
         # Scizzors marked string -8<- ... ->8-: The opening mark must be the
         # last thing in the line. The indentation of the first line after the
         # opening mark determines the indentation for all following lines. So,
         # we first switch the scanner to szrString1 mode.
-        [ 'nil', '-8<-.*\n', /-8<-.*\n/, :tjp, method('startStringSZR') ],
+        [ 'nil', /-8<-.*\n/, :tjp, method('startStringSZR') ],
         # Since the first line can be the last line (empty string case), we
         # need to detect the end in szrString1 and szrString mode. The
         # patterns switch the scanner back to tjp mode.
-        [ :STRING, '\s*->8-', /\s*->8-/, :szrString1, method('endStringSZR') ],
-        [ :STRING, '\s*->8-', /\s*->8-/, :szrString, method('endStringSZR') ],
+        [ :STRING, /\s*->8-/, :szrString1, method('endStringSZR') ],
+        [ :STRING, /\s*->8-/, :szrString, method('endStringSZR') ],
         # This rule handles macros inside of sizzors strings.
-        [ nil, '.*?\$\{\s*([a-zA-Z_]\w*)(\s*"(\\\\"|[^"])*")*', /.*?\$\{\s*([a-zA-Z_]\w*)(\s*"(\\"|[^"])*")*/,
+        [ nil, /.*?\$\{\s*(\??[a-zA-Z_]\w*)(\s*"(\\"|[^"])*")*/,
           [ :szrString, :szrString1 ], method('startMacroCall') ],
         # Any line not containing the start or end.
-        [ 'nil', '.*\n', /.*\n/, :szrString1, method('firstStringSZR') ],
-        [ 'nil', '.*\n', /.*\n/, :szrString, method('midStringSZR') ],
+        [ 'nil', /.*\n/, :szrString1, method('firstStringSZR') ],
+        [ 'nil', /.*\n/, :szrString, method('midStringSZR') ],
 
         # Single line macro definition
-        [ :MACRO, '\[.*\](\n|$)', /\[.*\]\n/, :tjp, method('chop2nl') ],
+        [ :MACRO, /\[.*\]\n/, :tjp, method('chop2nl') ],
 
         # Multi line macro definition: The pattern switches the scanner into
         # macroDef mode.
-        [ nil, '\[.*\n', /\[.*\n/, :tjp, method('startMacroDef') ],
+        [ nil, /\[.*\n/, :tjp, method('startMacroDef') ],
         # The end of the macro is marked by a ']' that is immediately followed
         # by a line break. It switches the scanner back to tjp mode.
-        [ :MACRO, '.*\](\n|$)', /.*\]\n/, :macroDef, method('endMacroDef') ],
+        [ :MACRO, /.*\]\n/, :macroDef, method('endMacroDef') ],
         # Any line not containing the start or end.
-        [ nil, '.*\n', /.*\n/, :macroDef, method('midMacroDef') ],
+        [ nil, /.*\n/, :macroDef, method('midMacroDef') ],
 
         # Some multi-char literals.
-        [ :LITERAL, '<=?', /<=?/ ],
-        [ :LITERAL, '>=?', />=?/ ],
-        [ :LITERAL, '!=?', /!=?/ ],
+        [ :LITERAL, /<=?/ ],
+        [ :LITERAL, />=?/ ],
+        [ :LITERAL, /!=?/ ],
 
         # Everything else is returned as a single-char literal.
-        [ :LITERAL, '.', /./ ]
+        [ :LITERAL, /./ ]
       ]
 
       super(masterFile, Log, tokenPatterns, :tjp)
@@ -375,6 +373,7 @@ class TaskJuggler
       macroCallLength = @macroCall.length
       # Remove '${' and '}' and white spaces at begin and end
       argsStr = @macroCall[2..-2].sub(/^[ \t\n]*(.*?)[ \t\n]*$/, '\1')
+
       # Extract the macro name.
       if argsStr.index(' ').nil?
         expandMacro(prefix, [ argsStr ], macroCallLength)

data/lib/taskjuggler/ResourceScenario.rb

@@ -51,6 +51,11 @@ class TaskJuggler
       # Same but for each assigned resource.
       @lastBookedSlots = {}
 
+      # First available slot of the resource.
+      @minslot = nil
+      # Last available slot of the resource.
+      @maxslot = nil
+
       # Attributed are only really created when they are accessed the first
       # time. So make sure some needed attributes really exist so we don't
       # have to check for existance each time we access them.
@@ -170,6 +175,13 @@ class TaskJuggler
       @scoreboard[sbIdx].is_a?(Task)
     end
 
+    # Return the Task that this resource is booked for at the time specified
+    # by _sbIdx_. If not booked to a task, nil is returned.
+    def bookedTask(sbIdx)
+      return nil unless (sb = @scoreboard[sbIdx]).is_a?(Task)
+      sb
+    end
+
     # Book the slot indicated by the scoreboard index +sbIdx+ for Task +task+.
     # If +force+ is true, overwrite the existing booking for this slot. The
     # method returns true if the slot was available.
@@ -677,7 +689,7 @@ class TaskJuggler
     # Count the booked slots between the start and end index. If _task_ is not
     # nil count only those slots that are assigned to this particular task or
     # any of its sub tasks.
-    def getAllocatedSlots(startIdx, endIdx, task)
+    def getAllocatedSlots(startIdx, endIdx, task = nil)
       # If there is no scoreboard, we don't have any allocations.
       return 0 unless @scoreboard
 
@@ -728,6 +740,16 @@ class TaskJuggler
       end
     end
 
+    # Get the first available slot of the resource.
+    def getMinSlot
+      @minslot
+    end
+
+    # Get the last available slot of the resource.
+    def getMaxSlot
+      @maxslot
+    end
+
   private
 
     def initScoreboard
@@ -792,6 +814,24 @@ class TaskJuggler
           end
         end
       end
+
+      # Set minimum and maximum availability
+      idx = 0
+      while idx < @scoreboard.size
+        if available?(idx)
+          @minslot = idx
+          break
+        end
+        idx += 1
+      end
+      idx = @scoreboard.size - 1
+      while idx >= 0
+        if available?(idx)
+          @maxslot = idx
+          break
+        end
+        idx -= 1
+      end
     end
 
     def countSlots(startIdx, endIdx)

data/lib/taskjuggler/RichText/Element.rb

@@ -224,6 +224,8 @@ class TaskJuggler
       when :fontCol
       when :code
       when :text
+      when :htmlblob
+        return ''
       else
         raise "Unknown RichTextElement category #{@category}"
       end
@@ -348,6 +350,9 @@ class TaskJuggler
       when :code
         pre = '<code>'
         post = '</code>'
+      when :htmlblob
+        pre = '<html>'
+        post = '</html>'
       when :text
         pre = '['
         post = ']'
@@ -460,6 +465,9 @@ class TaskJuggler
         XMLElement.new('span', 'style' => "color:#{@data}")
       when :code
         XMLElement.new('code', attrs)
+      when :htmlblob
+        noChilds = true
+        XMLBlob.new(@children[0])
       when :text
         noChilds = true
         XMLText.new(@children[0])