taskjuggler 0.2.2 → 3.0.0

data/examples/Fedora-20/reports.tji

@@ -43,9 +43,7 @@ navigator menu
 macro all_navbar [
   header -8<-
 == [[File:icons/fedoralogo.png|bottom]] ${content_title}-${major} Project Plan ==
-----
 <[navigator id="menu"]>
-----
 ->8-
 ]
 macro FilePrefix [${content}-${major}-]

data/examples/tutorial.tjp

@@ -315,9 +315,7 @@ macro TaskTip [
 textreport frame "" {
   header -8<-
     == Accounting Software Project ==
-    ----
     <[navigator id="navbar"]>
-    ----
   ->8-
   footer "----"
   textreport index "Overview" {

data/lib/taskjuggler/Attributes.rb

@@ -547,7 +547,20 @@ class TaskJuggler
     end
 
     def to_tjp
-      'This code is still missing!'
+      v = get
+      first = true
+      str = 'shifts '
+      v.assignments.each do |sa|
+        if first
+          first = false
+        else
+          str += ",\n"
+        end
+
+        str += "#{sa.shiftScenario.property.fullId} #{sa.interval}"
+      end
+
+      str
     end
 
   end

data/lib/taskjuggler/Project.rb

@@ -202,8 +202,6 @@ class TaskJuggler
               false, false,   false,  [] ],
         [ 'flags',     'Flags',        FlagListAttribute,
               true,  false,   true,  [] ],
-        [ 'fte',       'FTE',          FloatAttribute,
-              false, false,   true,  1.0 ],
         [ 'headcount', 'Headcount',    FixnumAttribute,
               false, false,   true,  1 ],
         [ 'index',     'Index',        FixnumAttribute,
@@ -955,6 +953,19 @@ class TaskJuggler
       slotsToDays(slots)
     end
 
+    # Return the number of global working slots during the given time interval
+    # specified by _startIdx_ and _endIdx_. This method takes global vacations
+    # into account.
+    def getWorkSlots(startIdx, endIdx)
+      slots = 0
+      startIdx.upto(endIdx) do |idx|
+        slots += 1 unless @scoreboard[idx]
+      end
+
+      slots
+    end
+
+
     # Return true if for the date specified by the global scoreboard index
     # _sbIdx_ there is any resource that is available.
     def anyResourceAvailable?(sbIdx)

data/lib/taskjuggler/ProjectFileScanner.rb

@@ -184,7 +184,7 @@ class TaskJuggler
       begin
         [ type, TjTime.new(match) ]
       rescue TjException => msg
-        error('time_error', msg)
+        error('time_error', msg.message)
       end
     end
 

data/lib/taskjuggler/ResourceScenario.rb

@@ -278,6 +278,27 @@ class TaskJuggler
       query.string = query.scaleLoad(work)
     end
 
+    # The the Full-time equivalent for the resource or group.
+    def query_fte(query)
+      fte = 0.0
+      if @property.container?
+        # Accumulate the FTEs of all sub-resources.
+        @property.kids.each do |resource|
+          resource.query_fte(@scenarioIdx, query)
+          fte += query.to_num
+        end
+      else
+        # TODO: Getting the globalWorkSlots is relatively expensive. We
+        # probably don't need to compute this for every resource.
+        globalWorkSlots = @project.getWorkSlots(query.startIdx, query.endIdx)
+        workSlots = getWorkSlots(query.startIdx, query.endIdx)
+        fte = workSlots.to_f / globalWorkSlots if globalWorkSlots > 0
+      end
+
+      query.sortable = query.numerical = fte
+      query.string = query.numberFormat.format(fte)
+    end
+
     # Get the rate of the resource.
     def query_rate(query)
       query.sortable = query.numerical = r = rate
@@ -557,6 +578,23 @@ class TaskJuggler
       bookedSlots
     end
 
+    # Count the number of slots betweend the _startIdx_ and _endIdx_ that can
+    # be used for work
+    def getWorkSlots(startIdx, endIdx)
+      return 0 if startIdx >= endIdx
+
+      initScoreboard unless @scoreboard
+
+      workSlots = 0
+      startIdx.upto(endIdx - 1) do |idx|
+        slot = @scoreboard[idx]
+        # We count free slots and assigned slots.
+        workSlots += 1 if slot.nil? || slot.is_a?(Task)
+      end
+
+      workSlots
+    end
+
     # Count the free slots between the start and end index.
     def getFreeSlots(startIdx, endIdx)
       return 0 if startIdx >= endIdx

data/lib/taskjuggler/SheetReceiver.rb

@@ -146,14 +146,16 @@ EOT
 
     # Isolate the actual syntax from _sheet_ and process it.
     def processSheet(sheet)
-      @sheet = @sheetWasAttached ? cutOut(sheet) : sheet
-
       begin
-        @sheet = @sheet.forceUTF8Encoding
+        @sheet = sheet.forceUTF8Encoding
       rescue
         error($!)
       end
 
+      # If the sheet contains special cut markers, we extract only the content
+      # within those markers.
+      @sheet = cutOut(@sheet)
+
       # A valid sheet must have the poper header line.
       if @sheetHeader.match(@sheet)
         checkSignature(@sheet)

data/lib/taskjuggler/SimpleQueryExpander.rb

@@ -38,7 +38,6 @@ class TaskJuggler
       str = @inputStr.dup
       # Replace all occurences of <-name->.
       str.gsub!(/<-[a-zA-Z][_a-zA-Z]*->/) do |match|
-        len = match.size
         attribute = match[2..-3]
         @query.attributeId = attribute
         @query.process

data/lib/taskjuggler/TaskScenario.rb

@@ -1761,8 +1761,8 @@ class TaskJuggler
         # Prevent overbooking when multiple resources are allocated and
         # available. If the task has allocation limits we need to make sure
         # that none of them is already exceeded.
-        break if @effort > 0 && @doneEffort >= @effort ||
-                 !limitsOk?(@currentSlotIdx, resource)
+        break if (@effort > 0 && r['efficiency', @scenarioIdx] > 0.0 &&
+                  @doneEffort >= @effort) || !limitsOk?(@currentSlotIdx, r)
 
         if r.book(@scenarioIdx, @currentSlotIdx, @property)
           # For effort based task we adjust the the start end (as defined by

data/lib/taskjuggler/TextParser.rb

@@ -318,8 +318,6 @@ 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.
-            function = state.index == state.pattern.tokens.length - 1 ?
-                       state.pattern.function : nil
             @stack.push(TextParser::StackElement.new(state.pattern.function,
                                                      state))
           end

data/lib/taskjuggler/TextParser/Pattern.rb

@@ -136,7 +136,7 @@ class TaskJuggler::TextParser
         end
 
         # The token descriptor tells us where the transition(s) need to go to.
-        tokenType, tokenName = token = @tokens[destIndex]
+        tokenType, tokenName = @tokens[destIndex]
 
         case tokenType
         when :reference

data/lib/taskjuggler/TextParser/Scanner.rb

@@ -70,8 +70,6 @@ class TaskJuggler::TextParser
       # Inject the String _text_ into the input stream at the current cursor
       # position.
       def injectText(text, callLength)
-        # Current scanner position in _bytes_ form start
-        pos = @scanner.pos
         # Remove the macro call from the end of the already parsed input.
         preCall = @scanner.pre_match[0..-(callLength + 1)]
         # Store the end position of the inserted macro in bytes.

data/lib/taskjuggler/TimeSheets.rb

@@ -95,7 +95,8 @@ class TaskJuggler
 
       if @work >= @timeSheet.daysToSlots(1) && @status.nil?
         error('ts_no_status_work',
-              "You must specify a status for task #{taskId}.")
+              "You must specify a status for task #{taskId}. It was worked " +
+              "on for a day or more.")
       end
 
       if @status

data/lib/taskjuggler/Tj3AppBase.rb

@@ -80,7 +80,7 @@ class TaskJuggler
         files = @opts.parse(argv)
       rescue OptionParser::ParseError => msg
         puts @opts.to_s + "\n"
-        error(msg, 2)
+        error(msg.message, 2)
       end
 
       files

data/lib/taskjuggler/Tj3Config.rb

@@ -14,7 +14,7 @@
 require 'taskjuggler/UTF8String'
 require 'taskjuggler/AppConfig'
 
-AppConfig.version = '0.2.2'
+AppConfig.version = '3.0.0'
 AppConfig.packageName = 'taskjuggler'
 AppConfig.softwareName = 'TaskJuggler III'
 AppConfig.packageInfo = 'A Project Management Software'

data/lib/taskjuggler/TjpSyntaxRules.rb

@@ -1767,6 +1767,11 @@ EOT
     listRule('moreIntervals', '!intervalOrDate')
   end
 
+  def rule_intervalOptional
+    optional
+    singlePattern('!interval')
+  end
+
   def rule_intervalsOptional
     optional
     singlePattern('!intervals')
@@ -3360,7 +3365,13 @@ EOT
          )
 
     singlePattern('_fte')
-    descr('The Full-Time-Equivalent of a resource or group')
+    descr(<<'EOT'
+The Full-Time-Equivalent of a resource or group. This is the ratio of the
+resource working time and the global working time. Working time is defined by
+working hours and vacations. The FTE value can vary over time and is
+calculated for the report interval or the user specified interval.
+EOT
+         )
 
     singlePattern('_headcount')
     descr('The headcount number of the resource or group')
@@ -4431,23 +4442,21 @@ EOT
   end
 
   def rule_shiftAssignment
-    pattern(%w( !shiftId !intervalsOptional ), lambda {
+    pattern(%w( !shiftId !intervalOptional ), lambda {
       # Make sure we have a ShiftAssignment for the property.
       sa = @property['shifts', @scenarioIdx] || ShiftAssignments.new
       sa.project = @project
 
       if @val[1].nil?
-        intervals = [ TimeInterval.new(@project['start'], @project['end']) ]
+        interval = TimeInterval.new(@project['start'], @project['end'])
       else
-        intervals = @val[1]
+        interval = @val[1]
       end
-      intervals.each do |interval|
-        if !sa.addAssignment(ShiftAssignment.new(@val[0].scenario(@scenarioIdx),
-                                                 interval))
-          error('shift_assignment_overlap',
-                'Shifts may not overlap each other.',
-                @sourceFileInfo[0], @property)
-        end
+      if !sa.addAssignment(ShiftAssignment.new(@val[0].scenario(@scenarioIdx),
+                                               interval))
+        error('shift_assignment_overlap',
+              'Shifts may not overlap each other.',
+              @sourceFileInfo[0], @property)
       end
       # Set same value again to set the 'provided' state for the attribute.
       begin
@@ -4798,7 +4807,7 @@ EOT
 
   def rule_statusSheetHeader
     pattern(%w( _statussheet !resourceId !valIntervalOrDate ), lambda {
-      unless (scenarioIdx = @project['trackingScenarioIdx'])
+      unless @project['trackingScenarioIdx']
         error('ss_no_tracking_scenario',
               'No trackingscenario defined.')
       end
@@ -4975,7 +4984,7 @@ EOT
                   LogicalExpression.new(LogicalOperation.new(0)))
       report.set('sortResources', [ [ 'seqno', true, -1 ] ])
     })
-    arg(1, 'file name', <<'EOT'
+    arg(2, 'file name', <<'EOT'
 The name of the tagfile to generate. You can leave it empty and it will
 default to the commonly used name ''''tags''''.
 EOT
@@ -6198,6 +6207,8 @@ EOT
     doc('status.timesheet', <<'EOT'
 The status attribute can be used to describe the current status of the task or
 resource. The content of the status messages is added to the project journal.
+The status section is optional for tasks that have been worked on less than
+one day during the report interval.
 EOT
        )
     arg(2, 'headline', <<'EOT'
@@ -6518,7 +6529,11 @@ EOT
         end
       end
       wh.timezone = @project['timezone']
-      7.times { |i| wh.setWorkingHours(i, @val[2]) if @val[1][i] }
+      begin
+        7.times { |i| wh.setWorkingHours(i, @val[2]) if @val[1][i] }
+      rescue
+        error('bad_workinghours', $!.message)
+      end
     })
   end
 

data/lib/taskjuggler/WorkingHours.rb

@@ -112,9 +112,10 @@ class TaskJuggler
         raise "dayOfWeek out of range: #{dayOfWeek}"
       end
       intervals.each do |iv|
-        if iv[0] < 0 || iv[0] >= 24 * 60 * 60 ||
-           iv[1] < 0 || iv[1] >= 24 * 60 * 60
-          raise "Time interval has illegal values: #{iv[0]} - #{iv[1]}"
+        if iv[0] < 0 || iv[0] > 24 * 60 * 60 ||
+           iv[1] < 0 || iv[1] > 24 * 60 * 60
+          raise "Time interval has illegal values: " +
+                "#{time_to_s(iv[0])} - #{time_to_s(iv[1])}"
         end
         if iv[0] >= iv[1]
           raise "Interval end time must be larger than start time"
@@ -180,9 +181,7 @@ class TaskJuggler
           else
             str += ', '
           end
-          str += "#{iv[0] / 3600}:" +
-                 "#{iv[0] % 3600 == 0 ? '00' : iv[0] % 3600} - " +
-                 "#{iv[1] / 3600}:#{iv[1] % 3600 == 0 ? '00' : iv[1] % 3600}"
+          str += "#{time_to_s(iv[0])} - #{time_to_s(iv[0])}"
         end
         str += "\n" if day < 6
       end
@@ -191,6 +190,10 @@ class TaskJuggler
 
   private
 
+    def time_to_s(t)
+      "#{t >= 24 * 60 * 60 ? '24:00' : "#{t / 3600}:#{t % 3600}"}"
+    end
+
     def initScoreboard
       # The scoreboard is an Array of True/False values. It spans a certain
       # time period with one entry per time slot.

data/lib/taskjuggler/apps/Tj3.rb

@@ -87,7 +87,7 @@ EOT
           begin
             @freezeDate = TjTime.new(arg).align(3600)
           rescue TjException => msg
-            error("Invalid freeze date: #{msg}")
+            error("Invalid freeze date: #{msg.message}")
           end
         end
         @opts.on('--freezebytask',

data/lib/taskjuggler/reports/GanttLine.rb

@@ -351,7 +351,7 @@ class TaskJuggler
         title = ''
       end
       trigger['onclick'] = "TagToTip('ID#{trigger.object_id}', " +
-                           "TITLE, '#{title}')"
+                           "TITLE, '#{title.gsub(/'/, ''')}')"
       trigger['style'] += 'cursor:help; '
       hook = trigger unless hook
       hook << (ltDiv = XMLElement.new('div', 'class' => 'tj_tooltip_box',

data/lib/taskjuggler/reports/Navigator.rb

@@ -30,48 +30,54 @@ class TaskJuggler
       @current = false
     end
 
-    def to_html
+    def to_html(html = nil)
       first = true
-      html = (div = XMLElement.new('div'))
 
-      @elements.each do |element|
-        next unless label
+      topLevel = html.nil?
+
+      # If we don't have a container yet, to put all the menus into, create one.
+      html ||= XMLElement.new('div', 'class' => 'navbar_container')
 
+      html << XMLElement.new('hr', 'class' => 'navbar_topruler') if topLevel
+
+      # Create a container for this (sub-)menu.
+      html << (div = XMLElement.new('div', 'class' => 'navbar'))
+
+      @elements.each do |element|
+        # Separate the menu entries by vertical bars. Prepend them for all but
+        # the first entry.
         if first
           first = false
         else
           div << XMLText.new('|')
         end
 
-        url = element.url
-        if !url
-          nEl = element
-          while nEl.elements[0]
-            break if nEl.current
-
-            if nEl.elements[0].url
-              url = nEl.elements[0].url
-              break
-            end
-            nEl = nEl.elements[0]
-          end
-        end
-        if url && url != currentUrl
-          div << (span = XMLElement.new('span', 'class' => 'navbar_other'))
-          span << (a = XMLElement.new('a', 'href' => url))
-          a << XMLText.new(element.label)
-        else
+        if element.current
+          # The navbar entry is referencing this page. Highlight is as the
+          # currently selected page.
           div << (span = XMLElement.new('span',
                                         'class' => 'navbar_current'))
           span << XMLText.new(element.label)
+        else
+          # The navbar entry is refencing another page. Show the link to it.
+          div << (span = XMLElement.new('span', 'class' => 'navbar_other'))
+          span << (a = XMLElement.new('a', 'href' => element.url))
+          a << XMLText.new(element.label)
         end
       end
+
+      # Now see if the current menu entry is actually just holding another sub
+      # menu and generate that menue in another line after an HR.
       @elements.each do |element|
         if element.current && !element.elements.empty?
-          html << XMLElement.new('hr', {}, true) unless first
-          html << element.to_html
+          html << XMLElement.new('hr', 'class' => 'navbar_midruler') unless first
+          element.to_html(html)
+          break
         end
       end
+
+      html << XMLElement.new('hr', 'class' => 'navbar_bottomruler') if topLevel
+
       html
     end
 
@@ -85,27 +91,6 @@ class TaskJuggler
       end
     end
 
-    # Store the URL for the current report. Since the URL entry in the root
-    # node of the NavigatorElement tree is never used, we use it to store the
-    # current URL there.
-    def currentUrl=(url)
-      root.url = url
-    end
-
-    # Get the URL of the current report from the root node.
-    def currentUrl
-      root.url
-    end
-
-    # Traverse the tree all the way to the top and return the root element.
-    def root
-      p = self
-      while p.parent
-        p = p.parent
-      end
-      p
-    end
-
   end
 
   # A Navigator is an automatically generated menu to navigate a list of
@@ -115,67 +100,79 @@ class TaskJuggler
   class Navigator
 
     attr_reader :id
-    attr_accessor :hideReport, :reportRoot
+    attr_accessor :hideReport
 
     def initialize(id, project)
       @id = id
       @project = project
       @hideReport = LogicalExpression.new(LogicalOperation.new(0))
-      @reportRoot = nil
       @elements = []
     end
 
     # Generate an output format independant version of the navigator. This is
     # a tree of NavigatorElement objects.
-    def generate(reports, reportRoot, parentElement)
-      reportDef = @project.reportContexts.last.report
-      raise "Report context missing" unless reportDef
-
-      interactive = false
-      reports.each do |report|
-        # The outermost (top-level) report determines whether the report
-        # should be rendered interactive or not.
-        interactive = report.interactive?  unless interactive
-
+    def generate(allReports, currentReports, reportDef, parentElement)
+      element = nextParentElement = nextParentReport = nil
+      currentReports.each do |report|
         hasURL = report.get('formats').include?(:html)
-        # Only generate menu entries for reports that are not the reportRoot,
-        # that are leaf reports and have an HTML output format.
-        next if (report.parent != reportRoot) ||
-                (report.leaf? && !hasURL)
+        # Only generate menu entries for container reports or leaf reports
+        # have a HTML output format.
+        next if (report.leaf? && !hasURL) || !allReports.include?(report)
 
+        # What label should be used for the menu entry? It's either the name
+        # of the report or the user specified title.
         label = report.get('title') || report.name
-        # Determine the URL for this element.
-        if hasURL
-          if interactive
-            url = "/taskjuggler?project=#{report.project['projectid']};" +
-                  "report=#{report.fullId}"
-          else
-            url = report.name + '.html'
-            url = normalizeURL(url, reportDef.name)
-          end
-        end
+
+        url = findReportURL(report, allReports, reportDef)
+
+        # Now we have all data so we can create the actual menu entry.
         parentElement.elements <<
           (element =  NavigatorElement.new(parentElement, label, url))
 
-        if report == reportDef
-          element.currentUrl = url
-          # Mark this element and all its parents as current.
-          nEl = element
-          while nEl
-            nEl.current = true
-            nEl = nEl.parent
-          end
+        # Check if 'report' matches the 'reportDef' report or is a child of
+        # it.
+        if reportDef == report || reportDef.isChildOf?(report)
+          nextParentReport = report
+          nextParentElement = element
+          element.current = true
         end
+      end
 
-        generate(reports, report, element)
+      if nextParentReport && nextParentReport.container?
+        generate(allReports, nextParentReport.kids, reportDef,
+                 nextParentElement)
       end
     end
 
     def to_html
+      # The the Report object that contains this Navigator.
+      reportDef ||= @project.reportContexts.last.report
+      raise "Report context missing" unless reportDef
+
+      # Compile a list of all reports that the user wants to include in the
+      # menu.
       reports = filterReports
       return nil if reports.empty?
 
-      generate(reports, nil, content = NavigatorElement.new(nil))
+      # Make sure the report is actually in the filtered list.
+      unless reports.include?(reportDef)
+        @project.warning('nav_in_hidden_rep',
+                         "Navigator requested for a report that is not " +
+                         "included in the navigator list.",
+                         reportDef.sourceFileInfo)
+        return nil
+      end
+
+      # Find the list of reports that become the top-level menu entries.
+      topLevelReports = [ reportDef ]
+      report = reportDef
+      while report.parent
+        report = report.parent
+        topLevelReports = report.kids
+      end
+
+      generate(reports, topLevelReports, reportDef,
+               content = NavigatorElement.new(nil))
       content.to_html
     end
 
@@ -208,6 +205,31 @@ class TaskJuggler
       url1
     end
 
+    # Find the URL to be used for the current Navigator menu entry.
+    def findReportURL(report, allReports, reportDef)
+      return nil unless allReports.include?(report)
+
+      if report.get('formats').include?(:html)
+        # The element references an HTML report. Point to it.
+        if @project.reportContexts.last.report.interactive?
+          url = "/taskjuggler?project=#{report.project['projectid']};" +
+                "report=#{report.fullId}"
+        else
+          url = report.name + '.html'
+          url = normalizeURL(url, reportDef.name)
+        end
+        return url
+      else
+        # The menu element is just a entry for another sub-menu. The the URL
+        # from the first kid of the report that has a URL.
+        report.kids.each do |r|
+          if (url = findReportURL(r, allReports, reportDef))
+            return url
+          end
+        end
+      end
+    end
+
   end
 
 end