taskjuggler 0.0.10 → 0.0.11

data/lib/taskjuggler/TernarySearchTree.rb

@@ -0,0 +1,203 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = Account.rb -- The TaskJuggler III Project Management Software
+#
+# Copylarger (c) 2006, 2007, 2008, 2009, 2010, 2011
+#               by Chris Schlaeger <chris@linux.com>
+#
+# 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 'taskjuggler/UTF8String'
+
+class TaskJuggler
+
+  # Classical ternary search tree implementation. It can store any list
+  # objects who's elements are comparable. These are usually String or Array
+  # objects. Common elements (by value and index) are only stored once which
+  # makes it fairly efficient for large lists that have similar start
+  # sequences. It also provides a fast find method.
+  class TernarySearchTree
+
+    # Create a new TernarySearchTree object. The optional _arg_ can be an
+    # element to store in the new tree or a list of elements to store.
+    def initialize(arg = nil)
+      clear
+
+      if arg.nil?
+        return
+      elsif arg.is_a?(Array)
+        sortForBalancedTree(arg).each { |elem| insert(elem) }
+      else
+        insert(arg) if arg
+      end
+    end
+
+    # Stores _str_ in the tree. _index_ is for internal use only.
+    def insert(str, index = 0)
+      if str.nil? || str.empty?
+        raise ArgumentError, "Cannot insert nil or empty lists"
+      end
+      if index > (maxIdx = str.length - 1) || index < 0
+        raise ArgumentError, "index out of range [0..#{maxIdx}]"
+      end
+
+      @value = str[index] unless @value
+
+      if str[index] < @value
+        @smaller = TernarySearchTree.new unless @smaller
+        @smaller.insert(str, index)
+      elsif str[index] > @value
+        @larger = TernarySearchTree.new unless @larger
+        @larger.insert(str, index)
+      else
+        if index == maxIdx
+          @last = true
+        else
+          @equal = TernarySearchTree.new unless @equal
+          @equal.insert(str, index + 1)
+        end
+      end
+    end
+
+    alias << insert
+
+    # Insert the elements of _list_ into the tree.
+    def insertList(list)
+      list.each { |val| insert(val) }
+    end
+
+    # if _str_ is stored in the tree it returns _str_. If _partialMatch_ is
+    # true, it returns all items that start with _str_. _index_ is for
+    # internal use only. If nothing is found it returns either nil or an empty
+    # list.
+    def find(str, partialMatch = false, index = 0)
+      return nil if str.nil? || index > (maxIdx = str.length - 1)
+
+      if str[index] < @value
+        return @smaller.find(str, partialMatch, index) if @smaller
+      elsif str[index] > @value
+        return @larger.find(str, partialMatch, index) if @larger
+      else
+        if index == maxIdx
+          # We've reached the end of the search pattern.
+          if partialMatch
+            return collect { |v| str[0..-2] + v }
+          else
+            return str if @last
+          end
+        end
+
+        return @equal.find(str, partialMatch, index + 1) if @equal
+      end
+      nil
+    end
+
+    alias [] find
+
+    # Returns the number of elements in the tree.
+    def length
+      result = 0
+
+      result += @smaller.length if @smaller
+      result += 1 if @last
+      result += @equal.length if @equal
+      result += @larger.length if @larger
+
+      result
+    end
+
+    # Return the maximum depth of the tree.
+    def maxDepth(depth = 0)
+      depth += 1
+      depths = []
+      depths << @smaller.maxDepth(depth) if @smaller
+      depths << @equal.maxDepth(depth) if @equal
+      depths << @larger.maxDepth(depth) if @larger
+      depths << depth if @last
+
+      depths.max
+    end
+
+    # Invokes _block_ for each element and returns the results as an Array.
+    def collect(str = nil, &block)
+      result = []
+
+      result += @smaller.collect(str, &block) if @smaller
+      newStr = str.nil? ? @value : str + @value
+      result << yield(newStr) if @last
+      result += @equal.collect(newStr, &block) if @equal
+      result += @larger.collect(str, &block) if @larger
+
+      result
+    end
+
+    # Return an Array with all the elements stored in the tree.
+    def to_a
+      collect{ |x| x}
+    end
+
+    # Balance the tree for more effective data retrieval.
+    def balance!
+      list = sortForBalancedTree(to_a)
+      clear
+      list.each { |x| insert(x) }
+    end
+
+    # Return a balanced version of the tree.
+    def balanced
+      TernarySearchTree.new(to_a)
+    end
+
+    def inspect(prefix = ' ', indent = 0)
+      puts "#{' ' * indent}#{prefix} #{@value} #{@last ? '!' : ''}"
+      @smaller.inspect('<', indent + 2) if @smaller
+      @equal.inspect('=', indent + 2) if @equal
+      @larger.inspect('>', indent + 2) if @larger
+    end
+
+    private
+
+    # Reset the node to an empty tree.
+    def clear
+      @smaller = @equal = @larger = @value = nil
+      @last = false
+    end
+
+    # Split the list into the first element and the remaining ones.
+    def split(str)
+      # The list may not be nil or empty. This would be a bug.
+      raise ArgumentError if str.nil? || str.empty?
+
+      # The second element of the result may be nil.
+      [ str[0], str[1..-1] ]
+    end
+
+    # Reorder the list elements so that we get a fully balanced tree when
+    # inserting the elements from front to back.
+    def sortForBalancedTree(list)
+      lists = [ list.sort ]
+      result = []
+      while !lists.empty?
+        newLists = []
+        lists.each do |l|
+          # Split the list in half and add the center element to the result
+          # list.
+          pivot = l.length / 2
+          result << l[pivot]
+          # Add the two remaining sub lists to the newLists Array.
+          newLists << l[0..pivot - 1] if pivot > 0
+          newLists << l[pivot + 1..-1] if pivot < l.length - 1
+        end
+        lists = newLists
+      end
+      result
+    end
+
+  end
+
+end
+

data/lib/{TextFormatter.rb → taskjuggler/TextFormatter.rb}

@@ -11,7 +11,7 @@
 # published by the Free Software Foundation.
 #
 
-require 'UTF8String'
+require 'taskjuggler/UTF8String'
 
 class TaskJuggler
 

data/lib/{TextParser.rb → taskjuggler/TextParser.rb}

@@ -11,12 +11,12 @@
 # published by the Free Software Foundation.
 #
 
-require 'TextParser/Pattern'
-require 'TextParser/Rule'
-require 'TextParser/StackElement'
-require 'MessageHandler'
-require 'TjException'
-require 'Log'
+require 'taskjuggler/TextParser/Pattern'
+require 'taskjuggler/TextParser/Rule'
+require 'taskjuggler/TextParser/StackElement'
+require 'taskjuggler/MessageHandler'
+require 'taskjuggler/TjException'
+require 'taskjuggler/Log'
 
 class TaskJuggler
 

data/lib/{MacroTable.rb → taskjuggler/TextParser/MacroTable.rb}

@@ -11,11 +11,7 @@
 # published by the Free Software Foundation.
 #
 
-require 'SourceFileInfo'
-require 'MessageHandler'
-require 'TjException'
-
-class TaskJuggler
+class TaskJuggler::TextParser
 
   class Macro
 
@@ -35,8 +31,7 @@ class TaskJuggler
   # during the macro call.
   class MacroTable
 
-    def initialize(messageHandler)
-      @messageHandler = messageHandler
+    def initialize
       @macros = {}
     end
 
@@ -73,11 +68,6 @@ class TaskJuggler
       [ @macros[name], resolved ]
     end
 
-    # This function sends an error message to the message handler.
-    def error(id, text, sourceFileInfo)
-      @messageHandler.error(id, text, sourceFileInfo)
-    end
-
   end
 
 end

data/lib/{TextParser → taskjuggler/TextParser}/Pattern.rb

@@ -11,8 +11,8 @@
 # published by the Free Software Foundation.
 #
 
-require 'TextParser/TokenDoc'
-require 'TextParser/State'
+require 'taskjuggler/TextParser/TokenDoc'
+require 'taskjuggler/TextParser/State'
 
 class TaskJuggler::TextParser
 
@@ -43,6 +43,9 @@ class TaskJuggler::TextParser
     attr_reader :keyword, :doc, :seeAlso, :exampleFile, :exampleTag,
                 :tokens, :function
 
+    # Create a new Pattern object. _tokens_ must be an Array of String objects
+    # that describe the Pattern. _function_ can be a reference to a method
+    # that should be called when the Pattern was recognized by the parser.
     def initialize(tokens, function = nil)
       # A unique name for the pattern that is used in the documentation.
       @keyword = nil

data/lib/{TextParser → taskjuggler/TextParser}/Rule.rb

@@ -11,7 +11,7 @@
 # published by the Free Software Foundation.
 #
 
-require 'TextParser/State'
+require 'taskjuggler/TextParser/State'
 
 class TaskJuggler::TextParser
 

data/lib/{TextScanner.rb → taskjuggler/TextParser/Scanner.rb}

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby -w
 # encoding: UTF-8
 #
-# = TextScanner.rb -- The TaskJuggler III Project Management Software
+# = Scanner.rb -- The TaskJuggler III Project Management Software
 #
 # Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011
 #               by Chris Schlaeger <chris@linux.com>
@@ -14,22 +14,19 @@
 require 'stringio'
 require 'strscan'
 
-require 'UTF8String'
-require 'TjTime'
-require 'TjException'
-require 'SourceFileInfo'
-require 'MacroTable'
-require 'Log'
+require 'taskjuggler/UTF8String'
+require 'taskjuggler/TextParser/SourceFileInfo'
+require 'taskjuggler/TextParser/MacroTable'
 
-class TaskJuggler
+class TaskJuggler::TextParser
 
-  # The TextScanner class is an abstract text scanner with support for nested
+  # The Scanner class is an abstract text scanner with support for nested
   # include files and text macros. The tokenizer will operate on rules that
   # must be provided by a derived class. The scanner is modal. Each mode
   # operates only with the subset of token patterns that are assigned to the
   # current mode. The current line is tracked accurately and can be used for
   # error reporting. The scanner can operate on Strings or Files.
-  class TextScanner
+  class Scanner
 
     class MacroStackEntry
 
@@ -46,7 +43,7 @@ class TaskJuggler
 
     # This class is used to handle the low-level input operations. It knows
     # whether it deals with a text buffer or a file and abstracts this to the
-    # TextScanner. For each nested file the scanner puts an StreamHandle on the
+    # Scanner. For each nested file the scanner puts an StreamHandle on the
     # stack while the file is scanned. With this stack the scanner can resume
     # the processing of the enclosing file once the included files has been
     # completely processed.
@@ -54,7 +51,8 @@ class TaskJuggler
 
       attr_reader :fileName, :macroStack
 
-      def initialize
+      def initialize(log)
+        @log = log
         @fileName = nil
         @stream = nil
         @line = nil
@@ -89,7 +87,7 @@ class TaskJuggler
         if @scanner.nil? || @scanner.eos?
           if (@line = @stream.gets)
             # Update activity meter about every 1024 lines.
-            Log.activity if (@stream.lineno & 0x3FF) == 0
+            @log.activity if (@stream.lineno & 0x3FF) == 0
             # Check for DOS or Mac end of line signatures.
             if @line[-1] == ?\r
               # Mac: Convert CR into LF
@@ -157,12 +155,12 @@ class TaskJuggler
 
       attr_reader :fileName
 
-      def initialize(fileName)
-        super()
+      def initialize(fileName, log)
+        super(log)
         @fileName = fileName.dup.untaint
         @stream = fileName == '.' ? $stdin : File.new(@fileName, 'r')
-        Log << "Parsing file #{@fileName} ..."
-        Log.startProgressMeter("Reading file #{fileName}")
+        @log << "Parsing file #{@fileName} ..."
+        @log.startProgressMeter("Reading file #{fileName}")
       end
 
       def close
@@ -175,23 +173,25 @@ class TaskJuggler
     # Specialized version of StreamHandle for operations on Strings.
     class BufferStreamHandle < StreamHandle
 
-      def initialize(buffer)
-        super()
+      def initialize(buffer, log)
+        super(log)
         @stream = StringIO.new(buffer)
-        Log << "Parsing buffer #{buffer[0, 20]} ..."
+        @log << "Parsing buffer #{buffer[0, 20]} ..."
       end
 
     end
 
-    # Create a new instance of TextScanner. _masterFile_ must be a String that
+    # Create a new instance of Scanner. _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, tokenPatterns, defaultMode)
+    # _log_ is a Log to report progress and status.
+    def initialize(masterFile, messageHandler, log, tokenPatterns, defaultMode)
       @masterFile = masterFile
       @messageHandler = messageHandler
+      @log = log
       # This table contains all macros that may be expanded when found in the
       # text.
-      @macroTable = MacroTable.new(messageHandler)
+      @macroTable = MacroTable.new
       # The currently processed IO object.
       @cf = nil
       # This Array stores the currently processed nested files. It's an Array
@@ -263,10 +263,12 @@ class TaskJuggler
     def open(fileNameIsBuffer = false)
       @fileNameIsBuffer = fileNameIsBuffer
       if fileNameIsBuffer
-        @fileStack = [ [ @cf = BufferStreamHandle.new(@masterFile), nil, nil ] ]
+        @fileStack = [ [ @cf = BufferStreamHandle.new(@masterFile, @log),
+                         nil, nil ] ]
       else
         begin
-          @fileStack = [ [ @cf = FileStreamHandle.new(@masterFile), nil, nil ] ]
+          @fileStack = [ [ @cf = FileStreamHandle.new(@masterFile, @log),
+                           nil, nil ] ]
         rescue StandardError
           error('open_file', "Cannot open file #{@masterFile}")
         end
@@ -278,8 +280,8 @@ class TaskJuggler
     # Finish processing and reset all data structures.
     def close
       unless @fileNameIsBuffer
-        Log.startProgressMeter("Reading file #{@masterFile}")
-        Log.stopProgressMeter
+        @log.startProgressMeter("Reading file #{@masterFile}")
+        @log.stopProgressMeter
       end
       @fileStack = []
       @cf = @tokenBuffer = nil
@@ -314,9 +316,9 @@ class TaskJuggler
 
       # Open the new file and push the handle on the @fileStack.
       begin
-        @fileStack << [ (@cf = FileStreamHandle.new(includeFileName)),
+        @fileStack << [ (@cf = FileStreamHandle.new(includeFileName, @log)),
                         nil, block ]
-        Log << "Parsing file #{includeFileName}"
+        @log << "Parsing file #{includeFileName}"
       rescue StandardError
         error('bad_include', "Cannot open include file #{includeFileName}", sfi)
       end
@@ -365,7 +367,7 @@ class TaskJuggler
         # completion. Close it and remove the corresponding entry from the
         # @fileStack.
         @finishLastFile = false
-        #Log << "Completed file #{@cf.fileName}"
+        #@log << "Completed file #{@cf.fileName}"
 
         # If we have a block to be executed on EOF, we call it now.
         onEof = @fileStack.last[2]
@@ -382,7 +384,7 @@ class TaskJuggler
         else
           # Continue parsing the file that included the current file.
           @cf, tokenBuffer = @fileStack.last
-          Log << "Parsing file #{@cf.fileName} ..."
+          @log << "Parsing file #{@cf.fileName} ..."
           # If we have a left over token from previously processing this file,
           # return it now.
           if tokenBuffer
@@ -435,7 +437,7 @@ class TaskJuggler
     # Return a token to retrieve it with the next nextToken() call again. Only 1
     # token can be returned before the next nextToken() call.
     def returnToken(token)
-      #Log << "-> Returning Token: [#{token[0]}][#{token[1]}]"
+      #@log << "-> Returning Token: [#{token[0]}][#{token[1]}]"
       unless @tokenBuffer.nil?
         $stderr.puts @tokenBuffer
         raise "Fatal Error: Cannot return more than 1 token in a row"