taskjuggler 0.0.2

data/lib/LogicalFlag.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = LogicalFlag.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 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 'LogicalOperation'
+
+class TaskJuggler
+
+  class LogicalFlag < LogicalOperation
+
+    def initialize(opnd)
+      super
+    end
+
+    def eval(expr)
+      expr.property['flags', 0].include?(@operand1)
+    end
+
+    def to_s
+      @operand1
+    end
+
+  end
+
+end
+

data/lib/LogicalFunction.rb

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = LogicalFunction.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 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 'LogicalOperation'
+
+class TaskJuggler
+
+  # The LogicalFunction is a specialization of the LogicalOperation. It models a
+  # function call in a LogicalExpression.
+  class LogicalFunction
+
+    attr_accessor :name, :arguments
+
+    # A map with the names of the supported functions and the number of
+    # arguments they require.
+    @@functions = {
+        'isdutyof' => 2,
+        'isleaf' => 0,
+        'isresource' => 1,
+        'isoncriticalpath' => 1,
+        'treelevel' => 0
+    }
+
+    # Create a new LogicalFunction. _opnd_ is the name of the function.
+    def initialize(opnd)
+      @name = opnd
+      @arguments = []
+    end
+
+    # Register the arguments of the function and check if the name is a known
+    # function and the number of arguments match this function. If not, return
+    # an [ id, message ] error. Otherwise nil.
+    def setArgumentsAndCheck(args)
+      unless @@functions.include?(@name)
+        return [ 'unknown_function',
+                 "Unknown function #{@name} used in logical expression." ]
+      end
+      if @@functions[@name] != args.length
+        return [ 'wrong_no_func_arguments',
+                 "Wrong number of arguments for function #{@name}. Got " +
+                 "#{args.length} instead of #{@@functions[@name]}." ]
+      end
+      @arguments = args
+      nil
+    end
+
+    # 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
+
+    # Return a textual expression of the function call.
+    def to_s
+      "#{@name}(#{@arguments.join(', ')})"
+    end
+
+  private
+
+    def isdutyof(expr, args)
+      # The result can only be true when called for a Task property.
+      return false unless expr.property.is_a?(Task)
+      project = expr.property.project
+      # 1st arg must be a resource ID.
+      return false if (resource = project.resource(args[0])).nil?
+      # 2nd arg must be a scenario index.
+      return false if (scenarioIdx = project.scenarioIdx(args[1])).nil?
+
+      expr.property['assignedresources', scenarioIdx].include?(resource)
+    end
+
+    def isleaf(expr, args)
+      expr.property.leaf?
+    end
+
+    def isresource(expr, args)
+      expr.property.is_a?(Resource) && expr.property.fullId == args[0]
+    end
+
+    def isoncricitalpath(expr, args)
+      # TODO
+      false
+    end
+
+    def treelevel(expr, args)
+      expr.property.level + 1
+    end
+
+  end
+
+end
+

data/lib/LogicalOperation.rb

@@ -0,0 +1,118 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = LogicalOperation.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 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 'TjException'
+
+class TaskJuggler
+
+  # A LogicalOperation is the basic building block for a LogicalExpression. A
+  # logical operation has one or two operands and an operator. The operands can
+  # be LogicalOperation objects, fixed values or references to project data. The
+  # LogicalOperation can be evaluated in a certain context. This contexts
+  # determines the actual values of the project data references.
+  # The evaluation is done by calling LogicalOperation#eval. The result must be
+  # of a type that responds to all the operators that are used in the eval
+  # method.
+  class LogicalOperation
+
+    attr_reader :operand1
+    attr_accessor :operand2, :operator
+
+    # Create a new LogicalOperation object. _opnd1_ is the mandatory operand.
+    # The @operand2 and the @operator can be set later.
+    def initialize(opnd1, operator = nil, opnd2 = nil)
+      @operand1 = opnd1
+      @operand2 = opnd2
+      @operator = operator
+    end
+
+    # Evaluate the expression in a given context represented by _expr_ of type
+    # LogicalExpression. The result must be of a type that responds to all the
+    # operators of this function.
+    def eval(expr)
+      begin
+        case @operator
+        when nil
+          if @operand1.respond_to?(:eval)
+            # An operand can be a fixed value or another term. This could be a
+            # LogicalOperation, LogicalFunction or anything else that provides
+            # an appropriate eval() method.
+            return @operand1.eval(expr)
+          else
+            return @operand1
+          end
+        when '~'
+          return !coerceBoolean(@operand1.eval(expr))
+        when '>'
+          return coerceNumber(@operand1.eval(expr)) >
+                 coerceNumber(@operand2.eval(expr))
+        when '>='
+          return coerceNumber(@operand1.eval(expr)) >=
+                 coerceNumber(@operand2.eval(expr))
+        when '='
+          return coerceNumber(@operand1.eval(expr)) ==
+                 coerceNumber(@operand2.eval(expr))
+        when '<'
+          return coerceNumber(@operand1.eval(expr)) <
+                 coerceNumber(@operand2.eval(expr))
+        when '<='
+          return coerceNumber(@operand1.eval(expr)) <=
+                 coerceNumber(@operand2.eval(expr))
+        when '&'
+          return coerceBoolean(@operand1.eval(expr)) &&
+                 coerceBoolean(@operand2.eval(expr))
+        when '|'
+          return coerceBoolean(@operand1.eval(expr)) ||
+                 coerceBoolean(@operand2.eval(expr))
+        else
+          raise TjException.new,
+                "Unknown operator #{@operator} in logical expression"
+        end
+      rescue TjException
+        expr.error "Can't evaluate #{to_s}"
+      end
+    end
+
+    # Convert the operation into a textual representation. This function is used
+    # for error reporting and debugging.
+    def to_s # :nodoc:
+      if @operator.nil?
+        @operand1.to_s
+      elsif @operand2.nil?
+        "#{@operator}#{@operand1}"
+      else
+        "#{@operand1} #{@operator} #{@operand2}"
+      end
+    end
+
+  private
+
+    # Force the _val_ into a boolean value.
+    def coerceBoolean(val)
+      return val if val.class == TrueClass || val.class == FalseClass
+      # In TJP logic 'non 0' means false.
+      val != 0
+    end
+
+    # Force the _val_ into a number. In case this fails, an exception is raised.
+    def coerceNumber(val)
+      unless val.is_a?(Fixnum) || val.is_a?(Float) || val.is_a?(Bignum)
+        raise TjException.new,
+          "Operand #{val} of type #{val.class} must be a number"
+      end
+      val
+    end
+
+  end
+
+end
+

data/lib/MacroParser.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = MacroParser.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 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 'TextParser'
+require 'MessageHandler'
+
+class TaskJuggler
+
+  # This class implements a mini parser for the macro calls. It will be called
+  # from the same scanner that it uses to read the macro tokens.
+  class MacroParser < TextParser
+
+    def initialize(scanner, messageHandler)
+      super()
+
+      @scanner = scanner
+      @messageHandler = messageHandler
+      @variables = %w( ID STRING )
+
+      initRules
+    end
+
+    def nextToken
+      @scanner.nextToken
+    end
+
+    def returnToken(token)
+      @scanner.returnToken(token)
+    end
+
+    def rule_macroArguments
+      optional
+      repeatable
+      pattern(%w( $STRING ), Proc.new {
+        @val[0]
+      })
+    end
+
+    def rule_macroCall
+      pattern(%w( _{ !relax $ID !macroArguments _} ), Proc.new {
+        # When the ID is prefixed by a '?' the macro may be undefined and the
+        # macro call is replaced by an empty string.
+        unless @scanner.macroDefined?(@val[2])
+          if @val[1].nil?
+            error('undef_macro', "Macro #{@val[2]} is undefined")
+          end
+          nil
+        else
+          @scanner.expandMacro([ @val[2] ] + @val[3])
+        end
+      })
+      pattern(%w( _( $ID _) ), lambda {
+        ENV[@val[0]]
+      })
+    end
+
+    def rule_relax
+      optional
+      pattern(%w( _? ), lambda {
+        true
+      })
+    end
+
+  end
+
+end
+

data/lib/MacroTable.rb

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = MacroTable.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 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 'SourceFileInfo'
+require 'MessageHandler'
+require 'Message'
+require 'TjException'
+
+class TaskJuggler
+
+  class Macro
+
+    attr_reader :name, :value, :sourceFileInfo
+
+    def initialize(name, value, sourceFileInfo)
+      @name = name
+      @value = value
+      @sourceFileInfo = sourceFileInfo
+    end
+
+  end
+
+  # The MacroTable is used by the TextScanner to store defined macros and
+  # resolve them on request later on. A macro is a text pattern that has a name.
+  # The pattern may contain variable parts that are replaced by arguments passed
+  # during the macro call.
+  class MacroTable
+
+    def initialize(messageHandler)
+      @messageHandler = messageHandler
+      @macros = {}
+    end
+
+    # Add a new macro definition to the table or replace an existing one.
+    def add(macro)
+      @macros[macro.name] = macro
+    end
+
+    # Remove all definitions from the table.
+    def clear
+      @macros = []
+    end
+
+    # Returns true only if a macro named _name_ is defined in the table.
+    def include?(name)
+      @macros.include?(name)
+    end
+
+    # Returns the definition of the macro specified by name as first entry of
+    # _args_. The other entries of _args_ are parameters that are replacing the
+    # ${n} tokens in the macro definition. In case the macro call has less
+    # arguments than the macro definition uses, the ${n} tokens remain
+    # unchanged. No error is generated.
+    def resolve(args, sourceFileInfo)
+      name = args[0]
+      resolved = @macros[name].value.clone
+      i = 0
+      args.each do |arg|
+        resolved.gsub!("${#{i}}", arg)
+        i += 1
+      end
+      [ @macros[name], resolved ]
+    end
+
+    # 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'
+    end
+
+  end
+
+end
+

data/lib/Message.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = Message.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 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 'SourceFileInfo'
+
+class TaskJuggler
+
+  # The class holds a message object that is passed from the back-end library to
+  # the front-end. It can be an informational message, a warning, an error or a
+  # fatal event. Every message has an id, a level and a message text. Optional
+  # data include the associated source file reference, the property or the
+  # scenario.
+  class Message
+
+    attr_reader :id, :level, :text, :sourceFileInfo, :property, :scenario
+
+    def initialize(id, level, text, property = nil, scenario = nil,
+                   sourceFileInfo = nil)
+      @id = id
+      unless %w( info warning error fatal ).include?(level)
+        raise "Unknown message level '#{level}'"
+      end
+      @level = level
+      @text = text
+
+      @property = property
+      @scenario = scenario
+      @sourceFileInfo = sourceFileInfo
+    end
+
+    def to_s
+      str = ""
+      if @sourceFileInfo
+        str += "#{@sourceFileInfo.fileName}:#{sourceFileInfo.lineNo}: "
+      end
+      if @scenario
+        str += "#{@level.capitalize} in scenario #{@scenario.id}: "
+      else
+        str += "#{@level.capitalize}: "
+      end
+      str += text
+    end
+
+  end
+
+end
+