taskjuggler 0.0.6 → 0.0.7

data/lib/KeywordArray.rb

@@ -12,6 +12,10 @@
 
 class TaskJuggler
 
+  # This class is a specialized version of Array. It stores a list of
+  # keywords as String objects. The entry '*' is special. It means all
+  # keywords of a particular set are included. '*' must be the first entry if
+  # it is present.
   class KeywordArray < Array
 
     alias a_include? include?

data/lib/KeywordDocumentation.rb

@@ -30,7 +30,7 @@ class TaskJuggler
   # specific or not.
   class KeywordDocumentation
 
-    attr_reader :keyword, :pattern, :references
+    attr_reader :keyword, :names, :pattern, :references, :optionalAttributes
     attr_accessor :contexts, :scenarioSpecific, :inheritedFromProject,
                   :inheritedFromParent, :predecessor, :successor
 
@@ -41,15 +41,21 @@ class TaskJuggler
     # _pattern_.  _optAttrPatterns_ is an Array with references to
     # TextParser::Patterns that are optional attributes to this keyword.
     def initialize(rule, pattern, syntax, args, optAttrPatterns, manual)
+      @messageHandler = MessageHandler.new(true)
       @rule = rule
       @pattern = pattern
+      # The unique identifier. Usually the attribute or property name. To
+      # disambiguate a .<scope> can be added.
       @keyword = pattern.keyword
+      # Similar to @keyword, but without the scope. Since there could be
+      # several, this is an Array of String objects.
+      @names = []
       @syntax = syntax
       @args = args
+      @manual = manual
       # Hash that maps patterns of optional attributes to a boolean value. It
       # is true if the pattern is a scenario specific attribute.
       @optAttrPatterns = optAttrPatterns
-      @manual = manual
       # The above hash is later converted into a list that points to the
       # keyword documentation of the optional attribute.
       @optionalAttributes = []
@@ -66,9 +72,39 @@ class TaskJuggler
       @references = []
     end
 
+    # Returns true of the KeywordDocumentation is documenting a TJP property
+    # (task, resources, etc.). A TJP property can be nested.
+    def isProperty?
+      # I haven't found a good way to automatically detect all the various
+      # report types as properties. The non-nestable ones need to be added
+      # manually here.
+      return true if %w( export nikureport timesheetreport statussheetreport).
+                     include?(keyword)
+      @optionalAttributes.include?(self)
+    end
+
+    # Returns true of the keyword can be used outside of any other keyword
+    # context.
+    def globalScope?
+      return true if @contexts.empty?
+      @contexts.each do |context|
+        return true if context.keyword == 'properties'
+      end
+      false
+    end
+
     # Post process the class member to set cross references to other
     # KeywordDocumentation items.
     def crossReference(keywords, rules)
+      # Get the attribute or property name of the Keyword. This is not unique
+      # like @keyword since it's got no scope.
+      @pattern.terminalTokens(rules).each do |tok|
+        # Ignore patterns that don't have a real name.
+        break if tok[0] == '{'
+
+        @names << tok[0]
+      end
+
       # Some arguments are references to other patterns. The current keyword
       # is added as context to such patterns.
       @args.each do |arg|
@@ -498,15 +534,12 @@ class TaskJuggler
     # catches all RichTextScanner processing problems and converts the exception
     # data into an error message.
     def newRichText(text)
-      begin
-        rText = RichText.new(text)
-        rti = rText.generateIntermediateFormat
-        @references += rti.internalReferences
-      rescue RichTextException => msg
-        $stderr.puts "Error in RichText of rule #{@keyword}\n" +
-                     "Line #{msg.lineNo}: #{msg.text}\n" +
-                     "#{msg.line}"
+      rText = RichText.new(text, [], @messageHandler)
+      unless (rti = rText.generateIntermediateFormat)
+        @messageHandler.error('rich_text',
+                              "Error in RichText of rule #{@keyword}")
       end
+      @references += rti.internalReferences
       rti
     end
 
@@ -515,7 +548,8 @@ class TaskJuggler
     # table cell element. _list_ is the KeywordDocumentation list. _width_ is
     # the percentage width of the cell.
     def listHTMLAttributes(list, width)
-      td = XMLElement.new('td', 'class' => 'descr', 'style' => "width:#{width}%")
+      td = XMLElement.new('td', 'class' => 'descr',
+                          'style' => "width:#{width}%")
       first = true
       list.each do |attr|
         if first

data/lib/Limits.rb

@@ -236,7 +236,6 @@ class TaskJuggler
       else
         raise "Limit period undefined"
       end
-      endDate = @project['end']
 
       @limits << Limit.new(name, interval, period, value, upper, resource)
     end

data/lib/LogicalExpression.rb

@@ -51,7 +51,7 @@ class TaskJuggler
       if @sourceFileInfo.nil?
         "#{@operation.to_s(query)}"
       else
-        str = "#{@sourceFileInfo} #{@operation.to_s(query)}"
+        "#{@sourceFileInfo} #{@operation.to_s(query)}"
       end
     end
 

data/lib/LogicalFunction.rb

@@ -69,7 +69,6 @@ class TaskJuggler
 
     # Evaluate the function by calling it with the arguments.
     def eval(expr)
-      args = []
       # Call the function and return the result.
       send(name, expr, @arguments)
     end
@@ -92,10 +91,9 @@ class TaskJuggler
     end
 
     def hasalert(expr, args)
-      property, scopeProperty = properties(expr)
+      property = properties(expr)[0]
       query = expr.query
       project = property.project
-      date = project.reportContexts.last.report.get('end')
       !project['journal'].currentEntries(query.end, property,
                                          args[0], query.start).empty?
     end
@@ -117,7 +115,7 @@ class TaskJuggler
     end
 
     def isdependencyof(expr, args)
-      property, scopeProperty = properties(expr)
+      property = properties(expr)[0]
       # The result can only be true when called for a Task property.
       return false unless property.is_a?(Task)
       project = property.project
@@ -132,7 +130,7 @@ class TaskJuggler
     end
 
     def isdutyof(expr, args)
-      property, scopeProperty = properties(expr)
+      property = properties(expr)[0]
       # The result can only be true when called for a Task property.
       return false unless (task = property).is_a?(Task)
       project = task.project
@@ -145,7 +143,7 @@ class TaskJuggler
     end
 
     def isfeatureof(expr, args)
-      property, scopeProperty = properties(expr)
+      property = properties(expr)[0]
       # The result can only be true when called for a Task property.
       return false unless property.is_a?(Task)
       project = property.project
@@ -158,19 +156,20 @@ class TaskJuggler
     end
 
     def isleaf(expr, args)
-      property, scopeProperty = properties(expr)
+      property = properties(expr)[0]
       return false unless property
       property.leaf?
     end
 
     def isongoing(expr, args)
-      property, scopeProperty = properties(expr)
+      property = properties(expr)[0]
       # The result can only be true when called for a Task property.
       return false unless (task = property).is_a?(Task)
       project = task.project
       # 1st arg must be a scenario index.
       if (scenarioIdx = project.scenarioIdx(args[0])).nil?
-        expr.error("Unknown scenario '#{args[0]}' used for function isongoing()")
+        expr.error("Unknown scenario '#{args[0]}' used for function " +
+                   "isongoing()")
       end
 
       query = expr.query
@@ -185,17 +184,20 @@ class TaskJuggler
     end
 
     def isresource(expr, args)
-      property, scopeProperty = properties(expr)
+      property = properties(expr)[0]
+      return false unless property
       property.is_a?(Resource)
     end
 
     def istask(expr, args)
-      property, scopeProperty = properties(expr)
+      property = properties(expr)[0]
+      return false unless property
       property.is_a?(Task)
     end
 
     def treelevel(expr, args)
-      property, scopeProperty = properties(expr)
+      property = properties(expr)[0]
+      return 0 unless property
       property.level + 1
     end
 

data/lib/MacroTable.rb

@@ -12,7 +12,6 @@
 
 require 'SourceFileInfo'
 require 'MessageHandler'
-require 'Message'
 require 'TjException'
 
 class TaskJuggler
@@ -62,6 +61,8 @@ class TaskJuggler
     # unchanged. No error is generated.
     def resolve(args, sourceFileInfo)
       name = args[0]
+      return nil unless @macros[name]
+
       resolved = @macros[name].value.dup
       i = 0
       args.each do |arg|
@@ -73,9 +74,7 @@ class TaskJuggler
 
     # This function sends an error message to the message handler.
     def error(id, text, sourceFileInfo)
-      message = Message.new(id, 'error', text, nil, nil, sourceFileInfo)
-      @messageHandler.send(message)
-      raise TjException.new, 'Macro expasion error'
+      @messageHandler.error(id, text, sourceFileInfo)
     end
 
   end

data/lib/MessageHandler.rb

@@ -12,26 +12,155 @@
 
 class TaskJuggler
 
+  # The Message object can store several classes of messages that the
+  # application can send out.
+  class Message
+
+    attr_reader :type, :id, :message, :sourceFileInfo, :line
+
+    # Create a new Message object.  The _type_ specifies what tpye of message
+    # this is. The following types are supported: fatal, error, warning, info
+    # and debug. _id_ is a String that must uniquely identify the source of
+    # the Message. _message_ is a String with the actual message.
+    # _sourceLineInfo_ is a SourceLineInfo object that can reference a
+    # location in a specific file. _line_ is a String of that file. _data_ can
+    # be any context sensitive data. _sceneario_ specifies the Scenario in
+    # which the message originated.
+    def initialize(type, id, message, sourceFileInfo, line, data, scenario)
+      unless [ :fatal, :error, :warning, :info, :debug ].
+             include?(type)
+        raise "Unknown message type: #{type}"
+      end
+      @type = type
+
+      @id = id
+
+      if message && !message.is_a?(String)
+        raise "String object expected as message but got #{message.class}"
+      end
+      @message = message
+
+      if sourceFileInfo && !sourceFileInfo.is_a?(SourceFileInfo)
+        raise "SourceFileInfo object expected but got #{sourceFileInfo.class}"
+      end
+      @sourceFileInfo = sourceFileInfo
+
+      if line && !line.is_a?(String)
+        raise "String object expected as line but got #{line.class}"
+      end
+      @line = line
+
+      @data = data
+
+      if scenario && !scenario.is_a?(Scenario)
+        raise "Scenario object expected by got #{scenario.class}"
+      end
+      @scenario = scenario
+    end
+
+    # Convert the Message into a String.
+    def to_s
+      str = ""
+      # The SourceFileInfo is printed as <fileName>:line:
+      if @sourceFileInfo
+        str += "#{@sourceFileInfo.fileName}:#{sourceFileInfo.lineNo}: "
+      end
+      if @scenario
+        str += "#{@type.to_s.capitalize} in scenario #{@scenario.id}: "
+      else
+        str += "#{@type.to_s.capitalize}: "
+      end
+      str += @message
+      str += "\n" + @line if @line
+      str
+    end
+
+  end
+
+  # The MessageHandler can display and store application messages. Depending
+  # on the type of the message, a TjExeption can be raised (:error), or the
+  # program can be immedidately aborted (:fatal). Other types will just
+  # continue the program flow.
   class MessageHandler
 
     attr_reader :messages, :errors
+    attr_accessor :scenario
 
+    # Initialize the MessageHandler. _console_ specifies if the messages
+    # should be printed to $stderr.
     def initialize(console = false)
       @messages = []
       @console = console
-
+      # We count the errors.
       @errors = 0
     end
 
-    def send(message)
-      @errors += 1 if message.level == 'error' || message.level == 'fatal'
-      @messages << message
-      if @console
-        # The to_s call is necessary to support remote prints via DRb.
-        $stderr.puts message.to_s
+    # Generate a fatal message that will abort the application.
+    def fatal(id, message, sourceFileInfo = nil, line = nil, data = nil,
+              scenario = nil)
+      addMessage(:fatal, id, message, sourceFileInfo, line, data, scenario)
+    end
+
+    # Generate an error message.
+    def error(id, message, sourceFileInfo = nil, line = nil, data = nil,
+              scenario = nil)
+      addMessage(:error, id, message, sourceFileInfo, line, data, scenario)
+    end
+
+    # Generate an critical message.
+    def critical(id, message, sourceFileInfo = nil, line = nil, data = nil,
+                 scenario = nil)
+      addMessage(:critical, id, message, sourceFileInfo, line, data, scenario)
+    end
+
+    # Generate a warning.
+    def warning(id, message, sourceFileInfo = nil, line = nil, data = nil,
+                scenario = nil)
+      addMessage(:warning, id, message, sourceFileInfo, line, data, scenario)
+    end
+
+    # Generate an info message.
+    def info(id, message, sourceFileInfo = nil, line = nil, data = nil,
+             scenario = nil)
+      addMessage(:info, id, message, sourceFileInfo, line, data, scenario)
+    end
+
+    # Generate a debug message.
+    def debug(id, message, sourceFileInfo = nil, line = nil, data = nil,
+              scenario = nil)
+      addMessage(:info, id, message, sourceFileInfo, line, data, scenario)
+    end
+
+    # Generate a message by specifying the _type_.
+    def addMessage(type, id, message, sourceFileInfo = nil, line = nil,
+                   data = nil, scenario = nil)
+      abortOnError = type == :error
+      # Treat criticals like errors but without generating another
+      # exception.
+      type = :error if type == :critical
+
+      msg = Message.new(type, id, message, sourceFileInfo, line, data, scenario)
+      @messages << msg
+      # Print the message to $stderr if requested by the user.
+      $stderr.puts msg.to_s if @console
+
+      case type
+      when :error
+        # Increase the error counter.
+        @errors += 1
+        raise TjException.new, '' if abortOnError
+      when :fatal
+        raise RuntimeError
       end
     end
 
+    # Convert all messages into a single String.
+    def to_s
+      text = ''
+      @messages.each { |msg| text += msg.to_s }
+      text
+    end
+
   end
 
 end

data/lib/Project.rb

@@ -11,7 +11,8 @@
 #
 
 require 'TjException'
-require 'Message'
+require 'MessageHandler'
+require 'FileList'
 require 'TjTime'
 require 'Booking'
 require 'PropertySet'
@@ -49,7 +50,7 @@ class TaskJuggler
   class Project
 
     attr_reader :accounts, :shifts, :tasks, :resources, :scenarios,
-                :timeSheets, :reports, :messageHandler
+                :timeSheets, :reports, :messageHandler, :inputFiles
     attr_accessor :reportContexts, :outputDir, :warnTsDeltas
 
     # Create a project with the specified +id+, +name+ and +version+.
@@ -394,6 +395,9 @@ class TaskJuggler
 
       Scenario.new(self, 'plan', 'Plan Scenario', nil)
 
+      # A list of files that contained the project data.
+      @inputFiles = FileList.new
+
       @timeSheets = TimeSheets.new
 
       # The ReportContext provides additional settings to the report that can
@@ -412,12 +416,6 @@ class TaskJuggler
       self
     end
 
-    # Pass a message (error or warning) to the message handler. _message_ is a
-    # String that contains the message.
-    def sendMessage(message)
-      @messageHandler.send(message)
-    end
-
     # Query the value of a Project attribute. _name_ is the ID of the attribute.
     def [](name)
       if !@attributes.has_key?(name)
@@ -574,36 +572,30 @@ class TaskJuggler
       end
 
       if @tasks.empty?
-        message = Message.new('no_tasks', 'error', "No tasks defined")
-        sendMessage(message)
-        return false
+        @messageHandler.error('no_tasks', "No tasks defined")
       end
 
-      begin
-        @scenarios.each do |sc|
-          # Skip disabled scenarios
-          next unless sc.get('enabled')
-
-          scIdx = scenarioIdx(sc)
-
-          # All user provided values are set now. The next step is to
-          # propagate inherited values. These values must be marked as
-          # inherited by setting the mode to 1. As we always call
-          # PropertyTreeNode#inherit this is just a safeguard.
-          AttributeBase.setMode(1)
-          prepareScenario(scIdx)
-
-          # Now change to mode 2 so all values that are modified are marked
-          # as computed.
-          AttributeBase.setMode(2)
-          # Schedule the scenario.
-          scheduleScenario(scIdx)
-
-          # Complete the data sets, and check the result.
-          finishScenario(scIdx)
-        end
-      rescue TjException
-        return false
+      @scenarios.each do |sc|
+        # Skip disabled scenarios
+        next unless sc.get('enabled')
+
+        scIdx = scenarioIdx(sc)
+
+        # All user provided values are set now. The next step is to
+        # propagate inherited values. These values must be marked as
+        # inherited by setting the mode to 1. As we always call
+        # PropertyTreeNode#inherit this is just a safeguard.
+        AttributeBase.setMode(1)
+        prepareScenario(scIdx)
+
+        # Now change to mode 2 so all values that are modified are marked
+        # as computed.
+        AttributeBase.setMode(2)
+        # Schedule the scenario.
+        scheduleScenario(scIdx)
+
+        # Complete the data sets, and check the result.
+        finishScenario(scIdx)
       end
 
       @timeSheets.warnOnDelta if @warnTsDeltas
@@ -613,47 +605,43 @@ class TaskJuggler
     # Call this function to generate the reports based on the scheduling result.
     # This function may only be called after Project#schedule has been called.
     def generateReports(maxCpuCores)
-      begin
-        @reports.index
-        if maxCpuCores == 1
-          @reports.each do |report|
-            next if report.get('formats').empty?
-            Log.startProgressMeter("Report #{report.name}")
+      @reports.index
+      if maxCpuCores == 1
+        @reports.each do |report|
+          next if report.get('formats').empty?
+          Log.startProgressMeter("Report #{report.name}")
+          @reportContexts.push(ReportContext.new(self, report))
+          report.generate
+          @reportContexts.pop
+          Log.stopProgressMeter
+        end
+      else
+        # Kickoff the generation of all reports by pushing the jobs into the
+        # BatchProcessor queue.
+        bp = BatchProcessor.new(maxCpuCores)
+        @reports.each do |report|
+          next if report.get('formats').empty?
+          bp.queue(report) {
             @reportContexts.push(ReportContext.new(self, report))
-            report.generate
+            res = report.generate
             @reportContexts.pop
-            Log.stopProgressMeter
-          end
-        else
-          bp = BatchProcessor.new(maxCpuCores)
-          @reports.each do |report|
-            next if report.get('formats').empty?
-            bp.queue(report) {
-              @reportContexts.push(ReportContext.new(self, report))
-              res = report.generate
-              @reportContexts.pop
-              res
-            }
+            res
+          }
+        end
+        # Now wait for all the jobs to finish.
+        bp.wait do |report|
+          Log.startProgressMeter("Report #{report.tag.name}")
+          $stdout.print(report.stdout)
+          $stderr.print(report.stderr)
+          if report.retVal.signaled?
+            @messageHandler.error('rg_signal', "Signal raised")
           end
-          bp.wait do |report|
-            Log.startProgressMeter("Report #{report.tag.name}")
-            $stdout.print(report.stdout)
-            $stderr.print(report.stderr)
-            if report.retVal.signaled?
-              raise TjException.new, "Signal raised"
-            end
-            unless report.retVal.success?
-              raise TjException.new, "Process aborted"
-            end
-            Log.stopProgressMeter
+          unless report.retVal.success?
+            @messageHandler.error('rg_abort', "Process aborted")
           end
+          Log.stopProgressMeter
         end
-      rescue TjException
-        $stderr.puts "Report Generation Error: #{$!}"
-        return false
       end
-
-      true
     end
 
     def generateReport(reportId, regExpMode, dynamicAttributes = nil)
@@ -667,7 +655,6 @@ class TaskJuggler
         Log.startProgressMeter("Report #{report.name}")
         @reportContexts.push(context = ReportContext.new(self, report))
 
-        name = nil
         # If we have dynamic attributes we need to backup the old attributes
         # first, then parse the dynamicAttributes String replacing the
         # original values.
@@ -848,25 +835,26 @@ class TaskJuggler
     # Print the attribute values. It's used for debugging only.
     def to_s
       raise "STOP!"
+      str = ''
       @attributes.each do |attribute, value|
         if value
-          puts "#{attribute}: " +
-               "#{value.is_a?(PropertyTreeNode) ? value.fullId : value}"
+          str += "#{attribute}: " +
+                 "#{value.is_a?(PropertyTreeNode) ? value.fullId : value}"
         end
       end
+      str
     end
 
     # This function sends an error message to the message handler.
     def error(id, text)
-      message = Message.new(id, 'error', text)
-      @messageHandler.send(message)
-      raise TjException
+      @messageHandler.error(id, text)
     end
 
   protected
 
     def prepareScenario(scIdx)
-      Log.startProgressMeter("Preparing scenario #{scenario(scIdx).get('name')}")
+      Log.startProgressMeter("Preparing scenario " +
+                             "#{scenario(scIdx).get('name')}")
       resources = PropertyList.new(@resources)
       tasks = PropertyList.new(@tasks)
 
@@ -1012,19 +1000,17 @@ class TaskJuggler
       # Check for unscheduled tasks and report the first 10 of them as
       # warnings.
       unless unscheduledTasks.empty?
-        message = Message.new('unscheduled_tasks', 'warning',
-                              "#{unscheduledTasks.length} tasks could not be " +
-                              "scheduled")
-        sendMessage(message)
+        @messageHandler.warning(
+          'unscheduled_tasks',
+          "#{unscheduledTasks.length} tasks could not be scheduled")
         i = 0
         unscheduledTasks.each do |t|
-          message = Message.new(
-            'unscheduled_task', 'warning',
+          @messageHandler.warning(
+            'unscheduled_task',
             "Task #{t.fullId}: " +
             "#{t['start', scIdx] ? t['start', scIdx] : '<?>'} -> " +
-            "#{t['end', scIdx] ? t['end', scIdx] : '<?>'}", t,
+            "#{t['end', scIdx] ? t['end', scIdx] : '<?>'}", nil, nil, t,
             scenario(scIdx))
-          sendMessage(message)
 
           i += 1
           break if i >= 10