taskjuggler 0.0.2

data/gem_spec.rb

@@ -0,0 +1,30 @@
+# GEM SPECIFICATION
+GEM_SPEC = Gem::Specification.new { |s|
+    s.name              = UNIX_NAME
+    s.version           = PROJECT_VERSION
+    s.summary           = PROJECT_SUMMARY
+    s.rubyforge_project = UNIX_NAME
+    s.homepage          = PROJECT_HOMEPAGE
+    s.author            = USER_NAME
+    s.email             = USER_EMAIL
+    s.files             = DIST_FILES
+    s.require_path      = LIB_DIR
+    s.bindir            = BIN_DIR
+    s.test_files        = TEST_FILES
+    s.executables       = BIN_FILES.map { |fn| File.basename(fn) }
+    s.has_rdoc          = true
+    s.extra_rdoc_files  = RDOC_FILES
+    #s.rdoc_options      = GENERAL_RDOC_OPTS.to_a.flatten
+    s.date              = Time.now
+    if HAVE_EXT
+        s.extensions    = EXT_CONF_FILES
+        s.require_paths << EXT_DIR
+    end
+    if HAVE_CERT
+        s.signing_key = CERT_PRIVATE
+        s.cert_chain  = [CERT_PUBLIC]
+    end
+    s.platform          = Gem::Platform::RUBY
+    s.required_ruby_version  = '>= 1.8.5'
+}
+

data/lib/Account.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = Account.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 'PropertyTreeNode'
+require 'AccountScenario'
+
+class TaskJuggler
+
+  # An Account is an object to record financial transactions. Alternatively, an
+  # Account can just be a container for a set of Accounts. In this case it
+  # cannot directly record any transactions.
+  class Account < PropertyTreeNode
+
+    def initialize(project, id, name, parent)
+      super(project.resources, id, name, parent)
+      project.addAccount(self)
+
+      @data = Array.new(@project.scenarioCount, nil)
+      @project.scenarioCount.times do |i|
+        @data[i] = AccountScenario.new(self, i, @scenarioAttributes[i])
+      end
+    end
+
+    # Many Account functions are scenario specific. These functions are
+    # provided by the class AccountScenario. In case we can't find a
+    # function called for the Account class we try to find it in
+    # AccountScenario.
+    def method_missing(func, scenarioIdx, *args)
+      @data[scenarioIdx].method(func).call(*args)
+    end
+
+    # Return a reference to the _scenarioIdx_-th scenario.
+    def scenario(scenarioIdx)
+      return @data[scenarioIdx]
+    end
+
+  end
+
+end
+

data/lib/AccountScenario.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = AccountScenario.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 'ScenarioData'
+
+class TaskJuggler
+
+  # This class handles the scenario specific features of a Account object.
+  class AccountScenario < ScenarioData
+
+    def initialize(account, scenarioIdx, attributes)
+      super
+    end
+
+    # Compute the turnover for the _period_. Period should be an Interval.
+    def turnover(period)
+      amount = 0.0
+      if container?
+        @children.each { |child| amount += child.turnover }
+      else
+        @project.tasks.each do |task|
+          amount += task.turnover(period, self)
+        end
+      end
+      amount
+    end
+
+  end
+
+end

data/lib/Allocation.rb

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = Allocation.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 'Resource'
+require 'Shift'
+
+class TaskJuggler
+
+  # The Allocation is key object in TaskJuggler. It contains a description how
+  # Resources are assigned to a Task. Each allocation holds a non-empty list of
+  # candidate resources. For each time slot one candidate will be assigned if
+  # any are available. A selectionMode controls the order in which the resources
+  # are checked for availability. The first available one is selected.
+  class Allocation
+
+    attr_reader :selectionMode
+    attr_accessor :persistent, :mandatory, :shifts, :lockedResource
+
+    # Create an Allocation object. The _candidates_ list must at least contain
+    # one Resource reference.
+    def initialize(candidates, selectionMode = 1, persistent = false,
+                   mandatory = false)
+      @candidates = candidates
+      # The selection mode determines how the candidate is selected from the
+      # list of candidates.
+      # 0 : 'order'        : select by order of list
+      # 1 : 'minallocated' : select candidate with lowest allocation probability
+      # 2 : 'minloaded'    : select candidate with lowest allocated overall load
+      # 3 : 'maxloaded'    : select candidate with highest allocated overall load
+      # 4 : 'random'       : select a random candidate
+      @selectionMode = selectionMode
+      @persistent = persistent
+      @mandatory = mandatory
+      @shifts = nil
+    end
+
+    # Set the selection mode identified by name specified in _str_. For
+    # efficiency reasons, we turn the name into a Fixnum value.
+    def setSelectionMode(str)
+      modes = %w( order minallocated minloaded maxloaded random )
+      @selectionMode = modes.index(str)
+      raise "Unknown selection mode #{str}" if @selectionMode.nil?
+    end
+
+    # Append another candidate to the candidates list.
+    def addCandidate(candidate)
+      @candidates << candidate
+    end
+
+    # Returns true if we either have no shifts defined or the defined shifts are
+    # active at _date_.
+    def onShift?(date)
+      return @shifts.onShift?(date) if @shifts
+
+      true
+    end
+
+    # Return the candidate list sorted according to the selectionMode.
+    def candidates(scenarioIdx = -1)
+      if scenarioIdx < 0 || @selectionMode == 0 # oder
+        return @candidates
+      end
+      if @selectionMode == 4 # random
+        # For a random sorting we put the candidates in a hash with a random
+        # number as key. Then we sort the hash according to the random keys an
+        # use the resuling sequence of the values.
+        hash = {}
+        @candidates.each { |c| hash[rand] = c }
+        twinList = hash.sort { |x, y| x[0] <=> y[0] }
+        list = []
+        twinList.each { |k, v| list << v }
+        return list
+      end
+
+      list = @candidates.sort do |x, y|
+        case @selectionMode
+        when 1 # lowest alloc probability
+          x['criticalness', scenarioIdx] <=> y['criticalness', scenarioIdx]
+        when 2 # lowest allocated load
+          x['effort', scenarioIdx] <=> y['effort', scenarioIdx]
+        when 3 # hightes allocated load
+          y['effort', scenarioIdx] <=> x['effort', scenarioIdx]
+        else
+          raise "Unknown selection mode #{@selectionMode}"
+        end
+      end
+      list
+    end
+
+  end
+
+end
+

data/lib/AppConfig.rb

@@ -0,0 +1,134 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = AppConfig.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 'rbconfig'
+
+# This class provides central management of configuration data to an
+# application. It stores the version number, the name of the application and
+# the suite it belongs to. It also holds copyright and license information.
+# These infos have to be set in the main module of the application right after
+# launch. Then, all other modules can retrieve them from the global instance
+# as needed.
+class AppConfig
+
+  def initialize
+    @@version = '0.0.0'
+    @@packageName = 'unnamed'
+    @@packageInfo = 'no info'
+    @@appName = 'unnamed'
+    @@authors = []
+    @@copyright = []
+    @@contact = 'not specified'
+    @@license = 'no license'
+  end
+
+  def AppConfig.version=(version)
+    @@version = version
+  end
+
+  def AppConfig.version
+    @@version
+  end
+
+  def AppConfig.packageName=(name)
+    @@packageName = name
+  end
+
+  def AppConfig.packageName
+    @@packageName
+  end
+
+  def AppConfig.packageInfo=(info)
+    @@packageInfo = info
+  end
+
+  def AppConfig.packageInfo
+    @@packageInfo
+  end
+
+  def AppConfig.appName=(name)
+    @@appName = name
+  end
+
+  def AppConfig.appName
+    @@appName
+  end
+
+  def AppConfig.authors=(authors)
+    @@authors = authors
+  end
+
+  def AppConfig.authors
+    @@authors
+  end
+
+  def AppConfig.copyright=(copyright)
+    @@copyright = copyright
+  end
+
+  def AppConfig.copyright
+    @@copyright
+  end
+
+  def AppConfig.contact=(contact)
+    @@contact = contact
+  end
+
+  def AppConfig.contact
+    @@contact
+  end
+
+  def AppConfig.license=(license)
+    @@license = license
+  end
+
+  def AppConfig.license
+    @@license
+  end
+
+  def AppConfig.dataDirs(baseDir = 'data')
+    siteLibDir = ::Config::CONFIG['sitelibdir']
+    siteBaseDir, rubyVersionDir = siteLibDir.scan(/(.*\/)(.*)/)[0]
+    dirs = []
+    # This is for the development version. We assume that we run the app
+    # from the source base directory.
+    dirs << "#{baseDir}/"
+    # Or from the lib directory.
+    dirs << "../#{baseDir}/"
+    # This hopefully works for all setups. Otherwise we have to add more
+    # alternative pathes.
+    dirs << siteBaseDir + "gems/" + rubyVersionDir + '/gems/' \
+        + @@packageName + '-' + @@version + "/#{baseDir}/"
+    # Remove non-existing directories from the list again
+    dirs.delete_if do |dir|
+      !File.exists?(dir)
+    end
+    dirs
+  end
+
+  def AppConfig.dataFiles(fileName)
+    files = []
+    dirs = dataDirs
+    dirs.each { |d| files << d + fileName if File.exist?(d + fileName) }
+
+    files
+  end
+
+  def AppConfig.dataFile(fileName)
+    dirs = dataDirs
+    dirs.each { |d| return d + fileName if File.exist?(d + fileName) }
+
+    nil
+  end
+
+end
+

data/lib/AttributeBase.rb

@@ -0,0 +1,131 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = AttributeBase.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.
+#
+
+class TaskJuggler
+
+  # This class is the base for all property attribute types. Each property can
+  # have multiple attributes of different type. For each type, there must be a
+  # special Ruby class. Each of these classes must be derived from this class.
+  # The class holds information like a reference to the property that owns the
+  # attribute and the type of the attribute.
+  #
+  # The class can track wheter the attribute value was provided by the project
+  # file, inherited from another property or computed during scheduling.
+  #
+  # Attributes that are of an inheritable type will be copied from a parent
+  # property.
+  class AttributeBase
+    attr_reader :property, :type, :provided, :inherited, :value
+
+    # Create a new AttributeBase object. _type_ specifies the specific type of
+    # the object. _property_ is the PropertyTreeNode object this attribute
+    # belongs to.
+    def initialize(property, type)
+      @type = type
+      @property = property
+      # Flag that marks whether the value of this attribute was inherited from
+      # the parent PropertyTreeNode.
+      @inherited = false
+      # Flat that marks whether the value of this attribute was provided by the
+      # user (in contrast to being calculated).
+      @provided = false
+      # Some types can provide the default value as result of a initValue()
+      # method. If that does not exists, the default value from the
+      # AttributeDefinition.
+      if respond_to?('initValue')
+        @value = initValue(@type.default)
+      else
+        @value = @type.default
+      end
+      # The mode is flag that controls how value assignements affect the flags.
+      @@mode = 0
+    end
+
+    # Call this function to inherit _value_ from another property. It is very
+    # important that the values are deep copied as they may be modified later
+    # on.
+    def inherit(value)
+      @inherited = true
+      if value.is_a?(Fixnum) || value.is_a?(Float) ||
+         value.is_a?(TrueClass) || value.is_a?(FalseClass)
+        @value = value
+      elsif value.is_a?(Limits)
+        @value = Limits.new(value)
+      elsif value.is_a?(ShiftAssignments)
+        @value = ShiftAssignments.new(value)
+      elsif value.is_a?(String) || value.is_a?(TjTime)
+        @value = value.clone
+      elsif value.is_a?(WorkingHours)
+        @value = WorkingHours.new(value)
+      elsif value.is_a?(Array)
+        @value = Array.new(value)
+      else
+        raise "Don't know how to copy values of class #{value.class}"
+      end
+    end
+
+    # Change the @@mode. 0 means values are provided, 1 means values are
+    # inherited, any other value means calculated.
+    def AttributeBase.setMode(mode)
+      @@mode = mode
+    end
+
+    # Return the ID of the attribute.
+    def id
+      type.id
+    end
+
+    # Return the name of the attribute.
+    def name
+      type.name
+    end
+
+    # Set the value of the attribute. Depending on the mode we are in, the flags
+    # are updated accordingly.
+    def set(value)
+      @value = value
+      case @@mode
+        when 0
+          @provided = true
+        when 1
+          @inherited = true
+      end
+    end
+
+    # Return the attribute value.
+    def get
+      @value
+    end
+
+    # Check whether the value is uninitialized or nil.
+    def nil?
+      if @value.is_a?(Array)
+        @value.empty?
+      else
+        @value.nil?
+      end
+    end
+
+    # Return the value as String.
+    def to_s
+      @value.to_s
+    end
+
+    # Return the value in TJP file syntax.
+    def to_tjp
+      @type.id + " " + @value.to_s
+    end
+
+  end
+
+end
+