taskjuggler 0.0.5 → 0.0.6

data/lib/daemon/WebServer.rb

@@ -0,0 +1,204 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = WebServer.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009, 2010 by Chris Schlaeger <cs@kde.org>
+#
+# 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 'drb'
+require 'webrick'
+require 'stringio'
+
+require 'AppConfig'
+require 'RichText'
+
+# StringIO needs to be extended so we can send $stdout and $stderr over DRb.
+class StringIO
+  include DRbUndumped
+end
+
+class TaskJuggler
+
+  # The WebServer class provides a self-contained HTTP server that can serve
+  # HTML versions of Report objects that are generated on the fly.
+  class WebServer
+
+    attr_reader :broker
+
+    # Create a web server object that runs in a separate thread.
+    def initialize(broker, port)
+      @broker = broker
+
+      config = { :Port => port }
+      @server = WEBrick::HTTPServer.new(config)
+      @server.mount('/taskjuggler', ReportServlet, @broker)
+
+      # Serve some directories via the FileHandler servlet.
+      %w( css icons scripts ).each do |dir|
+        fullDir = AppConfig.dataDirs("data/#{dir}")[0]
+        @server.mount("/#{dir}", WEBrick::HTTPServlet::FileHandler, fullDir)
+      end
+
+      # Start the web server in a new thread so we don't block this thread.
+      @thread = Thread.new { @server.start }
+    end
+
+    # Stop the web server.
+    def stop
+      if @server
+        @server.shutdown
+        @server = nil
+        @thread.join
+      end
+    end
+
+  end
+
+  class ReportServlet < WEBrick::HTTPServlet::AbstractServlet
+
+    def initialize(config, *options)
+      @broker = options[0]
+    end
+
+    def self.get_instance(config, options)
+      self.new(config, *options)
+    end
+
+    def do_GET(req, res)
+      @req = req
+      @res = res
+      begin
+        projectId = req.query['project']
+        reportId = req.query['report']
+        if projectId.nil? || reportId.nil?
+          generateWelcomePage(projectId)
+        else
+          attributes = req.query['attributes'] || ''
+          generateReport(projectId, reportId, attributes)
+        end
+      rescue
+      end
+    end
+
+    private
+
+    def generateReport(projectId, reportId, attributes)
+      # Request the Project credentials from the ProbjectBroker.
+      @ps_uri, @ps_authKey = @broker.getProject(projectId)
+      if @ps_uri.nil?
+        error("No project with ID #{projectId} loaded")
+      end
+      # Get the responsible ReportServer that can generate the report.
+      begin
+        @projectServer = DRbObject.new(nil, @ps_uri)
+        @rs_uri, @rs_authKey = @projectServer.getReportServer(@ps_authKey)
+        @reportServer = DRbObject.new(nil, @rs_uri)
+      rescue
+        error("Cannot get report server")
+      end
+      # Create two StringIO buffers that will receive the $stdout and $stderr
+      # text from the report server. This buffer will contain the generated
+      # report as HTML encoded text.
+      stdOut = StringIO.new('')
+      stdErr = StringIO.new('')
+      begin
+        @reportServer.connect(@rs_authKey, stdOut, stdErr, $stdin, true)
+      rescue
+        error("Can't connect IO: #{$!}")
+      end
+
+      # Ask the ReportServer to generate the reports with the provided ID.
+      begin
+        @reportServer.generateReport(@rs_authKey, reportId, false, attributes)
+      rescue
+        stdOut.rewind
+        stdErr.rewind
+        error("Report server crashed: #{$!}\n#{stdErr.read}\n#{stdOut.read}")
+      end
+      # Disconnect the ReportServer
+      begin
+        @reportServer.disconnect(@rs_authKey)
+      rescue
+        error("Can't disconnect IO: #{$!}")
+      end
+      # And send a termination request.
+      begin
+        @reportServer.terminate(@rs_authKey)
+      rescue
+        error("Report server termination failed: #{$!}")
+      end
+      @reportServer = nil
+
+      @res['content-type'] = 'text/html'
+      stdErr.rewind
+      $stderr.puts stdErr.read
+      # To read the $stdout of the ReportServer we need to rewind the buffer
+      # and then read the full text.
+      stdOut.rewind
+      @res.body = stdOut.read
+    end
+
+    def generateWelcomePage(projectId)
+      projects = @broker.getProjectList
+
+      text = "== Welcome to the TaskJuggler Project Server ==\n----\n"
+      projects.each do |id|
+        if id == projectId
+          # Show the list of reports for this project.
+          text << "* [/taskjuggler #{getProjectName(id)}]\n"
+          reports = getReportList(id)
+          if reports.empty?
+            text << "** This project has no reports defined.\n"
+          else
+            reports.each do |reportId, reportName|
+              text << "** [/taskjuggler?project=#{id};report=#{reportId} " +
+                      "#{reportName}]\n"
+            end
+          end
+        else
+          # Just show a link to open the report list.
+          text << "* [/taskjuggler?project=#{id} #{getProjectName(id)}]\n"
+        end
+      end
+      rt = RichText.new(text)
+      rti = rt.generateIntermediateFormat
+      rti.sectionNumbers = false
+      page = HTMLDocument.new
+      page.generateHead("The TaskJuggler Project Server")
+      page << rti.to_html
+      @res['content-type'] = 'text/html'
+      @res.body = page.to_s
+    end
+
+    def getProjectName(id)
+      uri, authKey = @broker.getProject(id)
+      return nil unless uri
+      projectServer = DRbObject.new(nil, uri)
+      return nil unless projectServer
+      projectServer.getProjectName(authKey)
+    end
+
+    def getReportList(id)
+      uri, authKey = @broker.getProject(id)
+      return [] unless uri
+      projectServer = DRbObject.new(nil, uri)
+      return [] unless projectServer
+      projectServer.getReportList(authKey)
+    end
+
+    def error(message)
+      @res.status = 412
+      @res.body = "ERROR: #{message}"
+      @res['content-type'] = 'text/plain'
+      raise "Error: #{message}"
+    end
+
+  end
+
+end
+

data/lib/deep_copy.rb

@@ -34,7 +34,10 @@ class Object
   # This is a variant of Object#clone that returns a deep copy of an object.
   def deep_clone
     # We can't clone frozen objects. So just return a reference to them.
-    return self if frozen?
+    # Built-in classed can't be cloned either. The check below is probably
+    # cheaper than the frequent (hiddent) exceptions from those objects.
+    return self if frozen? || nil? || is_a?(Fixnum) || is_a?(Float) ||
+                   is_a?(TrueClass) || is_a?(FalseClass)
 
     # In case we have loops in our graph, we return references, not
     # deep-copied objects.

data/lib/reports/CSVFile.rb

@@ -19,12 +19,16 @@ class TaskJuggler
   # Hence we use our own class.
   class CSVFile
 
+    attr_reader :data
+
     # At construction time you need to specify the +data+ container. This is an
     # Array of Arrays that holds the table. Optionally, you can specify a
     # +separator+ and a +quote+ string for the CSV file.
-    def initialize(data, separator = ';', quote = '"')
+    def initialize(data = nil, separator = ';', quote = '"')
       @data = data
+      raise "Illegal separator: #{separator}" if '."'.include?(separator)
       @separator = separator
+      raise "Illegal quote: #{separator}" if quote == '.'
       @quote = quote
     end
 
@@ -37,19 +41,7 @@ class TaskJuggler
         file = File.open(fileName, 'w')
       end
 
-      @data.each do |line|
-        first = true
-        line.each do |field|
-          # Don't output a separator before the first field of the line.
-           if first
-             first = false
-           else
-             file.write @separator
-           end
-           file.write(marshal(field))
-        end
-        file.write "\n"
-      end
+      file.write(to_s)
 
       file.close unless fileName == '.'
     end
@@ -63,81 +55,173 @@ class TaskJuggler
         file = File.open(fileName, 'r')
       end
 
-      csv = []
-      file.each_line do |line|
-        csv << parseLine(line)
-      end
+      @data = parse(file.read)
 
       file.close unless fileName == '.'
-      csv
-    end
-
-    # Read the data as Array of Arrays from a CSV formated String +str+.
-    def parse(str)
-      csv = []
-      str.each_line do |line|
-        csv << parseLine(line)
-      end
+      @data
     end
 
-    private
-
-    # This function is used to properly quote @quote and @separation characters
-    # contained in the +field+.
-    def marshal(field)
-      if field.include?(@quote) || field.include?(@separator)
-        field.gsub!(/@quote/, '""')
-        field = '"' + field + '"'
+    # Convert the CSV data into a CSV formatted String.
+    def to_s
+      s = ''
+      @data.each do |line|
+        first = true
+        line.each do |field|
+          # Don't output a separator before the first field of the line.
+           if first
+             first = false
+           else
+             s << @separator
+           end
+           s << marshal(field)
+        end
+        s << "\n"
       end
-      field
+      s
     end
 
-    def parseLine(line)
-      @state = 0 # start of field
-      @fields = []
-      @field = ''
-      line.each_utf8_char do |c|
-        case @state
-        when 0 # start of field
+    # Read the data as Array of Arrays from a CSV formated String +str+.
+    def parse(str)
+      @data = []
+      state = :startOfRecord
+      fields = field = quoted = nil
+
+      # Make sure the input is terminated with a record end.
+      str += "\n" unless str[-1] == ?\n
+
+      str.each_utf8_char do |c|
+        #puts "c: #{c}  State: #{state}"
+        case state
+        when :startOfRecord
+          # This will store the fields of a record
+          fields = []
+          state = :startOfField
+          redo
+        when :startOfField
+          field = ''
+          quoted = false
           if c == @quote
-            @state = 1
+            # We've found the start of a quoted field.
+            state = :inQuotedField
+            quoted = true
+          elsif c == @separator || c == "\n"
+            # We've found an empty field
+            field = nil
+            state = :fieldEnd
+            redo
           else
-            @field << c
-            @state = 2
+            # We've found the first character of an unquoted field
+            field << c
+            state = :inUnquotedField
           end
-        when 1 # in quoted field
+        when :inQuotedField
+          # We are processing the content of a quoted field
           if c == @quote
-            @state = 3
-          elsif c == @separator
-            closeField
+            # This could be then end of the field or a quoted quote.
+            state = :quoteInQuotedField
           else
-            @field << c
+            # We've found a normal character of the quoted field
+            field << c
           end
-        when 2 # in unquoted field
-          if c == @separator
-            closeField
+        when :quoteInQuotedField
+          # We are processing a quoted quote or the end of a quoted field
+          if c == @quote
+            # We've found a quoted quote
+            field << c
+            state = :inQuotedField
+          elsif c == @separator || c == "\n"
+            state = :fieldEnd
+            redo
           else
-            @field << c
+            raise "Unexpected character #{c} in CSV"
           end
-        when 3 # quote found in quoted field
-          if c == @quote
-            @field << c
-            @state = 2
+        when :inUnquotedField
+          # We are processing an unquoted field
+          if c == @separator || c == "\n"
+            # We've found the end of a unquoted field
+            state = :fieldEnd
+            redo
           else
-            closeField
+            # A normal character of an unquoted field
+            field << c
           end
+        when :fieldEnd
+          # We've completed processing a field. Add the field to the list of
+          # fields. Convert Fixnums and Floats in native types.
+          fields << unMarshal(field, quoted)
+
+          if c == "\n"
+            # The field end is an end of a record as well.
+            state = :recordEnd
+            redo
+          else
+            # Get the next field.
+            state = :startOfField
+          end
+        when :recordEnd
+          # We've found the end of a record. Add fields to the @data
+          # structure.
+          @data << fields
+          # Look for a new record.
+          state = :startOfRecord
         else
           raise "Unknown state #{state}"
         end
       end
-      closeField if @state != 0
-      @fields
+
+      unless state == :startOfRecord
+        raise "CSV state machine error in state #{state}"
+      end
+
+      @data
     end
 
-    def closeField
-      @fields << @field
-      @field = ''
-      @state = 0
+    # Utility function that tries to convert a String into a native type that
+    # is supported by the CSVFile generator. If no native type is found, the
+    # input String _str_ will be returned unmodified. nil is returned as nil.
+    def CSVFile.strToNative(str)
+      if str.nil?
+        nil
+      elsif /^[-+]?\d+$/ =~ str
+        # field is a Fixnum
+        str.to_i
+      elsif /^[-+]?\d*\.?\d+([eE][-+]?\d+)?$/ =~ str
+        # field is a Float
+        str.to_f
+      else
+        # Everything else is kept as String
+        str
+      end
+    end
+
+    private
+
+    # This function is used to properly quote @quote and @separation
+    # characters contained in the +field+.
+    def marshal(field)
+      if field.nil?
+        ''
+      elsif field.is_a?(Fixnum) || field.is_a?(Float)
+        # Numbers don't have to be quoted.
+        field.to_s
+      else
+        # Duplicate quote characters.
+        f = field.gsub(/@quote/, "#{@quote * 2}")
+        # Enclose the field in quote characters
+        @quote + f.to_s + @quote
+      end
+    end
+
+    # Convert the String _field_ into a native Ruby type. If field was
+    # _quoted_, the result is always the String.
+    def unMarshal(field, quoted)
+      # Quoted Strings and nil are returned verbatim.
+      if quoted || field.nil?
+        field
+      else
+        # Unquoted fields are inspected for special types
+        CSVFile.strToNative(field)
+      end
     end
 
   end