taskjuggler 0.0.6 → 0.0.7

data/lib/TextParser.rb

@@ -13,6 +13,7 @@
 require 'TextParser/Pattern'
 require 'TextParser/Rule'
 require 'TextParser/StackElement'
+require 'MessageHandler'
 require 'TjException'
 require 'Log'
 
@@ -64,10 +65,13 @@ class TaskJuggler
 
     end
 
-    attr_reader :rules
+    attr_reader :rules, :messageHandler
 
     # Create a new TextParser object.
-    def initialize
+    def initialize(messageHandler)
+      # The message handler will collect all error messages.
+      @messageHandler = messageHandler
+      # This Hash will store the ruleset that the parser is operating on.
       @rules = { }
       # Array to hold the token types that the scanner can return.
       @variables = []
@@ -155,16 +159,19 @@ class TaskJuggler
 
     # To parse the input this function needs to be called with the name of the
     # rule to start with. It returns the result of the processing function of
-    # the top-level parser rule that was specified by _ruleName_.
+    # the top-level parser rule that was specified by _ruleName_. In case of
+    # an error, the result is false.
     def parse(ruleName)
       @stack = []
       @@expectedTokens = []
       updateParserTables
       begin
         result = parseRuleR(@rules[ruleName])
-      rescue TjException
-        # error('parse_error', $!.message)
-        return nil
+      rescue TjException => msg
+        if msg.message && !msg.message.empty?
+          @messageHandler.critical('parse', msg.message)
+        end
+        return false
       end
 
       result
@@ -174,7 +181,7 @@ class TaskJuggler
     # currently processed TextParser::Rule. Or return nil if we don't have a
     # current position.
     def sourceFileInfo
-      return nil if @stack.empty?
+      return nil if @stack.nil? || @stack.empty?
       @stack.last.sourceFileInfo[0]
     end
 
@@ -187,18 +194,26 @@ class TaskJuggler
       matches
     end
 
-    def error(id, text, property = nil, sfi = nil)
+    def error(id, text, sfi = nil, data = nil)
+      sfi ||= sourceFileInfo
       if @scanner
-        @scanner.error(id, text, property, sfi)
+        # The scanner has some more context information, so we pass the error
+        # on to the TextScanner.
+        @scanner.error(id, text, sfi, data)
       else
-        message = Message.new(id, 'error', text, property, sfi)
-        @messageHandler.send(message)
-        raise TjException.new, ''
+        @messageHandler.error(id, text, sfi, data)
       end
     end
 
-    def warning(id, text, property = nil, sfi = nil)
-      @scanner.warning(id, text, property, sfi)
+    def warning(id, text, sfi = nil, data = nil)
+      sfi ||= sourceFileInfo
+      if @scanner
+        # The scanner has some more context information, so we pass the
+        # warning on to the TextScanner.
+        @scanner.warning(id, text, sfi, data)
+      else
+        @messageHandler.warning(id, text, sfi, data)
+      end
     end
 
   private
@@ -234,7 +249,6 @@ class TaskJuggler
             res.each do |pat_i|
               pat_i.each { |tok, r| transitions[tok] = r }
             end
-            optional = true if refRule.optional
           elsif '_$.'.include?(token[0])
             transitions[token] = rule
             allTokensOptional = false
@@ -249,6 +263,7 @@ class TaskJuggler
         transitions.each do |key, value|
           rule.transitions.each do |trans|
             if trans.has_key?(key)
+              rule.dump
               raise "Fatal Error: Rule #{rule.name} has ambiguous " +
                     "transitions for target #{key}"
             end
@@ -271,8 +286,7 @@ class TaskJuggler
           if type == ?$
             if @variables.index(token).nil?
               error('unsupported_token',
-                    "The token #{token} is not supported here.", nil,
-                    token[2])
+                    "The token #{token} is not supported here.", token[2])
             end
           elsif type == ?!
             if @rules[token].nil?
@@ -291,6 +305,7 @@ class TaskJuggler
     # parseRuleNR.
     def parseRuleR(rule)
       #Log.enter('parseRuleR', "Parsing with rule #{rule.name}")
+      #puts "Parsing with rule #{rule.name}"
       result = rule.repeatable ? TextParserResultArray.new : nil
       # Rules can be marked 'repeatable'. This flag will be set to true after
       # the first iteration has been completed.
@@ -321,6 +336,7 @@ class TaskJuggler
             end
             @stack.last.store(parseRuleR(@rules[elToken]), sfi)
             #Log << "Resuming rule #{rule.name}"
+            #puts "Resuming rule #{rule.name}"
           else
             # In case the element is a keyword or variable we have to get a new
             # token if we don't have one anymore.
@@ -357,6 +373,7 @@ class TaskJuggler
       end
 
       #Log.exit('parseRuleR', "Finished rule #{rule.name}")
+      #puts "Finished rule #{rule.name}"
       return result
     end
 
@@ -507,16 +524,12 @@ class TaskJuggler
     end
 
     def getNextToken
-      begin
-        token = nextToken
-        #Log << "Token: [#{token[0]}][#{token[1]}]"
-      rescue TjException
-        error('parse_rule', $!.message)
-      end
+      token = nextToken
+      #Log << "Token: [#{token[0]}][#{token[1]}]"
       if @badVariables.include?(token[0])
         error('unsupported_token',
               "The token #{token[1]} is not supported in this context.",
-              nil, token[2])
+              token[2])
       end
       token
     end
@@ -561,7 +574,7 @@ class TaskJuggler
                  "Unexpected end of file in #{@scanner.fileName}. ") +
                 (@@expectedTokens.length > 1 ?
                  "Expecting one of #{@@expectedTokens.join(', ')}" :
-                 "Expecting #{@@expectedTokens[0]}"))
+                 "Expecting #{@@expectedTokens[0]}"), token[2])
         end
         returnToken(token)
         return nil
@@ -581,15 +594,15 @@ class TaskJuggler
           unless @@expectedTokens.empty?
             text = "#{@@expectedTokens.join(', ')} or " + text
           end
-          error('spec_keywork_expctd', text)
+          error('spec_keywork_expctd', text, token[2])
         end
         @stack.last.store(elToken, token[2])
       elsif elType == ?.
         if token[0..1] != [ '.', '<END>' ]
           error('end_expected',
-                "Found garbage at expected end of file: #{token[1]}\n" +
-                "If you see this in the middle of your file, you probably " +
-                "have closed your context too early.")
+                "Found garbage at expected end of text: #{token[1]}\n" +
+                "If you see this in the middle of your text, you probably " +
+                "have closed your context too early.", token[2])
         end
       else
         # The token must match the expected variable type.
@@ -599,7 +612,7 @@ class TaskJuggler
           unless @@expectedTokens.empty?
             text = "#{@@expectedTokens.join(', ')} or " + text
           end
-          error('spec_token_expctd', text)
+          error('spec_token_expctd', text, token[2])
         end
         # If the element is a variable store the value of the token.
         @stack.last.store(token[1], token[2])

data/lib/TextParser/Pattern.rb

@@ -142,24 +142,28 @@ class TaskJuggler::TextParser
 
     # Find recursively the first terminal token of this pattern. If an index is
     # specified start the search at this n-th pattern token instead of the
-    # first. The return value is either nil or a [ token, pattern ] tuple.
-    def terminalToken(rules, index = 0)
+    # first. The return value is an Array of [ token, pattern ] tuple.
+    def terminalTokens(rules, index = 0)
       # Terminal token start with an underscore or dollar character.
-      if @tokens[index][0] == ?_ || @tokens[index][0] == ?$
-        return [ @tokens[index].slice(1, @tokens[index].length - 1), self ]
+      if @tokens[index][0] == ?_
+        return [ [ @tokens[index][1..-1], self ] ]
+      elsif @tokens[index][0] == ?$
+        return []
       elsif @tokens[index][0] == ?!
-        # Token starting with a bang reference another rule. We have to continue
-        # the search at this rule. First, we get rid of the bang to get the rule
-        # name.
-        token = @tokens[index].slice(1, @tokens[index].length - 1)
+        # Token starting with a bang reference another rule. We have to
+        # continue the search at this rule. First, we get rid of the bang to
+        # get the rule name.
+        token = @tokens[index][1..-1]
         # Then find the rule
         rule = rules[token]
-        # The rule may only have a single pattern. If not, then this pattern has
-        # no terminal token.
-        return nil if rule.patterns.length != 1
-        return rule.patterns[0].terminalToken(rules)
+        # The rule may only have a single pattern. If not, then this pattern
+        # has no terminal token.
+        tts = []
+        rule.patterns.each { |p| tts += p.terminalTokens(rules, 0) }
+        return tts
+      else
+        raise "Unexpected token #{tokens[index]}"
       end
-      nil
     end
 
     # Returns a string that expresses the elements of the pattern in an EBNF

data/lib/TextParser/Rule.rb

@@ -156,6 +156,11 @@ class TaskJuggler::TextParser
            "#{@repeatable ? "[repeatable]" : ""}"
       @patterns.length.times do |i|
         puts "  Pattern: \"#{@patterns[i]}\""
+        unless @transitions[i]
+          puts "No transitions for this pattern!"
+          next
+        end
+
         @transitions[i].each do |key, rule|
           if key[0] == ?_
             token = "\"" + key.slice(1, key.length - 1) + "\""

data/lib/TextScanner.rb

@@ -18,7 +18,6 @@ require 'TjTime'
 require 'TjException'
 require 'SourceFileInfo'
 require 'MacroTable'
-require 'MacroParser'
 require 'Log'
 
 class TaskJuggler
@@ -184,7 +183,7 @@ class TaskJuggler
     # Create a new instance of TextScanner. _masterFile_ must be a String that
     # either contains the name of the file to start with or the text itself.
     # _messageHandler_ is a MessageHandler that is used for error messages.
-    def initialize(masterFile, messageHandler)
+    def initialize(masterFile, messageHandler, tokenPatterns, defaultMode)
       @masterFile = masterFile
       @messageHandler = messageHandler
       # This table contains all macros that may be expanded when found in the
@@ -213,6 +212,15 @@ class TaskJuggler
       @scannerMode = nil
       # Points to the currently active pattern set as defined by the mode.
       @activePatterns = nil
+
+      tokenPatterns.each do |pat|
+        type = pat[0]
+        regExp = pat[1]
+        mode = pat[2] || :tjp
+        postProc = pat[3]
+        addPattern(type, regExp, mode, postProc)
+      end
+      self.mode = defaultMode
     end
 
     # Add a new pattern to the scanner. _type_ is either nil for tokens that
@@ -257,7 +265,7 @@ class TaskJuggler
         begin
           @fileStack = [ [ @cf = FileStreamHandle.new(@masterFile), nil ] ]
         rescue StandardError
-          raise TjException.new, "Cannot open file #{@masterFile}"
+          error('open_file', "Cannot open file #{@masterFile}")
         end
       end
       @masterPath = @cf.dirname + '/'
@@ -276,7 +284,8 @@ class TaskJuggler
 
     # Continue processing with a new file specified by _includeFileName_. When
     # this file is finished, we will continue in the old file after the
-    # location where we started with the new file.
+    # location where we started with the new file. The method returns the full
+    # qualified name of the included file.
     def include(includeFileName, sfi)
       if includeFileName[0] != '/'
         pathOfCallingFile = @fileStack.last[0].dirname
@@ -291,7 +300,7 @@ class TaskJuggler
       @fileStack.each do |entry|
         if includeFileName == entry[0].fileName
           error('include_recursion',
-                "Recursive inclusion of #{includeFileName} detected", nil, sfi)
+                "Recursive inclusion of #{includeFileName} detected", sfi)
         end
       end
 
@@ -305,9 +314,11 @@ class TaskJuggler
         @fileStack << [ (@cf = FileStreamHandle.new(includeFileName)), nil, ]
         Log << "Parsing file #{includeFileName}"
       rescue StandardError
-        error('bad_include', "Cannot open include file #{includeFileName}",
-              nil, sfi)
+        error('bad_include', "Cannot open include file #{includeFileName}", sfi)
       end
+
+      # Return the name of the included file.
+      includeFileName
     end
 
     # Return SourceFileInfo for the current processing prosition.
@@ -390,10 +401,11 @@ class TaskJuggler
 
               break if type.nil? # Ignore certain tokens with nil type.
 
+              #puts "type: #{type}  match: [#{match}]"
               return [ type, match, @startOfToken ]
             end
           end
-        rescue
+        rescue ArgumentError
           error('scan_encoding_error', $!.to_s)
         end
 
@@ -437,6 +449,10 @@ class TaskJuggler
     def expandMacro(prefix, args)
       # Get the expanded macro from the @macroTable.
       macro, text = @macroTable.resolve(args, sourceFileInfo)
+      unless macro && text
+        error('undefined_macro', "Undefined macro '#{args[0]}' called")
+      end
+
       # If the expanded macro is empty, we can ignore it.
       return if text == ''
 
@@ -446,38 +462,43 @@ class TaskJuggler
     end
 
     # Call this function to report any errors related to the parsed input.
-    def error(id, text, property = nil, sfi = nil)
-      message('error', id, text, property, sfi)
+    def error(id, text, sfi = nil, data = nil)
+      message(:error, id, text, sfi, data)
     end
 
-    def warning(id, text, property = nil, sfi = nil)
-      message('warning', id, text, property, sfi)
+    def warning(id, text, sfi = nil, data = nil)
+      message(:warning, id, text, sfi, @cf ? @cf.line : nil, data)
     end
 
-    def message(type, id, text, property, sfi)
+    private
+
+    def message(type, id, text, sfi, data)
       unless text.empty?
-        message = Message.new(id, type, text + "\n" + line.to_s,
-                              property, nil, sfi || sourceFileInfo)
-        @messageHandler.send(message)
+        line = @cf ? @cf.line : nil
+        sfi ||= sourceFileInfo
 
         if @cf && !@cf.macroStack.empty?
-          message = Message.new('macro_stack', 'info', 'Macro call history:')
-          @messageHandler.send(message)
+          @messageHandler.info('macro_stack', 'Macro call history:', nil)
 
           @cf.macroStack.reverse_each do |entry|
             macro = entry.macro
             args = entry.args[1..-1]
             args.collect! { |a| '"' + a + '"' }
-            message = Message.new('macro_stack', 'info',
-                                  "  ${#{macro.name} #{args.join(' ')}}",
-                                  nil, nil, macro.sourceFileInfo)
-            @messageHandler.send(message)
+            @messageHandler.info('macro_stack',
+                                 "  ${#{macro.name} #{args.join(' ')}}",
+                                 macro.sourceFileInfo)
           end
         end
-      end
 
-      # An empty strings signals an already reported error
-      raise TjException.new, '' if type == 'error'
+        case type
+        when :error
+          @messageHandler.error(id, text, sfi, line, data)
+        when :warning
+          @messageHandler.warning(id, text, sfi, line, data)
+        else
+          raise "Unknown message type #{type}"
+        end
+      end
     end
 
   end

data/lib/TimeSheetSummary.rb

@@ -41,7 +41,7 @@ class TaskJuggler
       # A list of email addresses to send the summary to
       @digestRecipients = []
 
-      @resourceIntro = "  Weekly Report from %s\n\n"
+      @resourceIntro = "== Weekly Report from <nowiki>%s</nowiki> ==\n"
       @resourceSheetSubject = "Weekly report %s"
       @summarySubject = "Weekly staff reports %s"
       @reminderSubject = "Your time sheet for the period ending %s is overdue!"
@@ -84,12 +84,13 @@ EOT
               # Resource has submitted a time sheet
               sheet = getResourceJournal(sheetFile)
               summary += sprintf(@resourceIntro, resourceName)
-              summary += sheet + "\n#{'-' * 74}\n\n"
+              summary += sheet + "\n----\n"
               info("Adding report from #{resourceName} to summary")
 
               @sheetRecipients.each do |to|
-                sendEmail(to, sprintf(@resourceSheetSubject, @date), sheet,
-                          nil, "#{resourceName} <#{resourceEmail}>")
+                sendRichTextEmail(to, sprintf(@resourceSheetSubject, @date),
+                                  sheet, nil,
+                                  "#{resourceName} <#{resourceEmail}>")
               end
             end
           else
@@ -104,9 +105,9 @@ EOT
         # Prepend the defaulter list to the summary.
         text = sprintf(@defaulterHeader, defaulterList.length)
         defaulterList.each do |resource|
-          text += " * #{resource[1]}\n"
+          text += "* <nowiki>#{resource[1]}</nowiki>\n"
         end
-        text += "\n#{'-' * 74}\n\n"
+        text += "\n----\n"
         summary = text + summary
 
         # Create a file with the IDs of the resources who's reports are
@@ -123,7 +124,7 @@ EOT
 
       # Send out the summary text to the list of digest recipients.
       @digestRecipients.each do |to|
-        sendEmail(to, sprintf(@summarySubject, @date), summary)
+        sendRichTextEmail(to, sprintf(@summarySubject, @date), summary)
       end
 
       # If there is a reminder text defined, resend the template to those
@@ -165,6 +166,7 @@ EOT
       rescue
         fatal("Cannot summarize sheet: #{$!}")
       end
+
       report
     end