taskjuggler 0.0.2

data/lib/Limits.rb

@@ -0,0 +1,219 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = Limits.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 'Scoreboard'
+
+class TaskJuggler
+
+  # This class holds a set of limits. Each limit can be created individually and
+  # must have unique name. The Limit objects are created when an upper or lower
+  # limit is set. All upper or lower limits can be tested with a single function
+  # call.
+  class Limits
+
+    # This class implements a mechanism that can be used to limit certain events
+    # within a certain time period. It supports an upper and a lower limit.
+    class Limit
+
+      attr_accessor :resource
+
+      # To create a new Limit object, the Interval +interval+ and the
+      # period duration (+period+ in seconds) must be specified. This creates a
+      # counter for each period within the overall interval. +value+ is the value
+      # of the limit. +upper+ specifies whether the limit is an upper or lower
+      # limit. The limit can also be restricted to certain a Resource specified
+      # by +resource+.
+      def initialize(interval, period, value, upper, resource)
+        @interval = interval
+        @period = period
+        @value = value
+        @upper = upper
+        @resource = resource
+
+        # To avoid multiple resets of untouched scoreboards we keep this dirty
+        # flag. It's set whenever a counter is increased.
+        @dirty = true
+        reset
+      end
+
+      # Returns a deep copy of the class instance.
+      def copy
+        Limit.new(@interval, @period, @value, @upper, @resource)
+      end
+
+      # This function can be used to reset the counter for a specific period
+      # specified by +date+ or to reset all counters.
+      def reset(date = nil)
+        return unless @dirty
+
+        if date.nil?
+          @scoreboard = Scoreboard.new(@interval.start, @interval.end, @period, 0)
+        else
+          return unless @interval.contains?(date)
+          @scoreboard.set(date, 0)
+        end
+        @dirty = false
+      end
+
+      # Increase the counter for a specific period specified by +date+. If
+      # +resource+ is not nil, the counter is only increased if +resource+
+      # matches resource.
+      def inc(date, resource)
+        return if !@interval.contains?(date) || (!resource.nil? && @resource != resource)
+
+        @dirty = true
+        @scoreboard.set(date, @scoreboard.get(date) + 1)
+      end
+
+      # Returns true if the counter for the time slot specified by +date+ or all
+      # counters are within the limit. If +upper+ is true, only upper limits are
+      # checked. If not, only lower limits are checked. If +resource+ is not
+      # nil, only limits for this resource are checked.
+      def ok?(date, upper, resource)
+        if date.nil?
+          # if @upper does not match, we can ignore this limit.
+          return true if @upper != upper || (!resource.nil? && @resource != resource)
+
+          # Check all counters.
+          @scoreboard.each do |i|
+            return false if @upper ? i >= @value : i < @value
+          end
+          return true
+        else
+          # If the date is outside the interval or @upper does not match, ignore
+          # this limit.
+          return true if !@interval.contains?(date) || @upper != upper
+          return @upper ? @scoreboard.get(date) < @value : @scoreboard.get(date) >= @value
+        end
+      end
+
+    end
+
+    attr_reader :limits, :project
+
+    # Create a new Limits object. If an argument is passed, it acts as a copy
+    # contructor.
+    def initialize(limits = nil)
+      if limits.nil?
+        # Normal initialization
+        @limits = {}
+        @project = nil
+      else
+        # Deep copy content from other instance.
+        @limits = {}
+        limits.limits.each do |name, limit|
+          @limits[name] = limit.copy
+        end
+        @project = limits.project
+      end
+    end
+
+    # The objects need access to some project specific data like the project
+    # period.
+    def setProject(project)
+      raise "Cannot change project after limits have been set!" unless @limits.empty?
+      @project = project
+    end
+
+    # Reset all counter for all limits.
+    def reset
+      @limits.each_value { |limit| limit.reset }
+    end
+
+    # Call this function to create or change a limit. The limit must be uniquely
+    # identified by +name+. +value+ is the new limit value (in time slots).
+    # +period+ is the Interval where the limit is active. In case the interval
+    # is nil, the complete project time frame is used.
+    def setLimit(name, value, interval = nil, resource = nil)
+      @limits.delete(name) if @limits[name]
+      newLimit(name, value, interval.nil? ?
+               Interval.new(@project['start'], @project['end']) : interval, resource)
+    end
+
+    # This function increases the counters for all limits for a specific
+    # interval identified by _date_.
+    def inc(date, resource = nil)
+      @limits.each_value do |limit|
+        limit.inc(date, resource)
+      end
+    end
+
+    # Check all upper limits and return true if none is exceeded. If a _date_ is
+    # specified only the counter for that specific period is tested. Otherwise
+    # all periods are tested.
+    def ok?(date = nil, upper = true, resource = nil)
+      @limits.each_value do |limit|
+        return false unless limit.ok?(date, upper, resource)
+      end
+      true
+    end
+
+  private
+
+    # This function creates a new Limit identified by _name_. In case _name_ is
+    # none of the predefined intervals (e. g. dailymax, weeklymin, monthlymax) a
+    # the whole interval is used for the period length.
+    def newLimit(name, value, interval, resource)
+      # The known intervals are aligned to start at their respective start.
+      interval.start = interval.start.midnight
+      interval.end = interval.end.midnight
+      case name
+      when 'dailymax'
+        period = 60 * 60 * 24
+        upper = true
+      when 'dailymin'
+        period = 60 * 60 * 24
+        upper = false
+      when 'weeklymax'
+        interval.start = interval.start.beginOfWeek(@project['weekstartsmonday'])
+        interval.end = interval.end.beginOfWeek(@project['weekstartsmonday'])
+        period = 60 * 60 * 24 * 7
+        upper = true
+      when 'weeklymin'
+        interval.start = interval.start.beginOfWeek(@project['weekstartsmonday'])
+        interval.end = interval.end.beginOfWeek(@project['weekstartsmonday'])
+        period = 60 * 60 * 24 * 7
+        upper = false
+      when 'monthlymax'
+        interval.start = interval.start.beginOfMonth
+        interval.end = interval.end.beginOfMonth
+        # We use 30 days intervals here. This will cause the interval to drift
+        # away from calendar months. But it's better than using 30.4167 which
+        # does not align with day boundaries.
+        period = 60 * 60 * 24 * 30
+        upper = true
+      when 'monthlymin'
+        interval.start = interval.start.beginOfMonth
+        interval.end = interval.end.beginOfMonth
+        # We use 30 days intervals here. This will cause the interval to drift
+        # away from calendar months. But it's better than using 30.4167 which
+        # does not align with day boundaries.
+        period = 60 * 60 * 24 * 30
+        upper = false
+      when 'maximum'
+        period = interval.end - interval.start
+        upper = true
+      when 'minimum'
+        period = interval.end - interval.start
+        upper = false
+      else
+        raise "Limit period undefined"
+      end
+      endDate = @project['end']
+
+      @limits[name] = Limit.new(interval, period, value, upper, resource)
+    end
+
+  end
+
+end
+

data/lib/Log.rb

@@ -0,0 +1,160 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = Log.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 'singleton'
+
+class TaskJuggler
+
+  # The Log class implements a filter for segmented execution traces. The
+  # trace messages are filtered based on their segment name and the nesting
+  # level of the segments. The class is a Singleton, so there is only one
+  # instance in the program.
+  class Log
+
+    include Singleton
+
+    @@level = 0
+    @@stack = []
+    @@segments = []
+    @@silent = true
+    @@progress = 0
+
+    # Set the maximum nesting level that should be shown. Segments with a
+    # nesting level greater than _l_ will be silently dropped.
+    def Log.level=(l)
+      @@level = l
+    end
+
+    # The trace output can be limited to a list of segments. Messages not in
+    # these segments will be ignored. Messages from segments that are nested
+    # into the shown segments will be shown for the next @@level nested
+    # segments.
+    def Log.segments=(s)
+      @@segments = []
+    end
+
+    # if +s+ is true, progress information will not be shown.
+    def Log.silent=(s)
+      @@silent = s
+    end
+
+    # Return the @@silent value.
+    def Log.silent
+      @@silent
+    end
+
+    # This function is used to open a new segment. +segment+ is the name of
+    # the segment and +message+ is a description of it.
+    def Log.enter(segment, message)
+      return if @@level == 0
+
+      @@stack << segment
+      Log.<< ">> [#{segment}] #{message}"
+    end
+
+    # This function is used to close an open segment. To make this mechanism a
+    # bit more robust, it will search the stack of open segments for a segment
+    # with that name and will close all nested segments as well.
+    def Log.exit(segment, message = nil)
+      return if @@level == 0
+
+      Log.<< "<< [#{segment}] #{message}" if message
+      if @@stack.include?(segment)
+        loop do
+          m = @@stack.pop
+          break if m == segment
+        end
+      end
+    end
+
+    # Use this function to show a log message within the currently active
+    # segment.
+    def Log.<<(message)
+      return if @@level == 0
+
+      offset = 0
+      unless @@segments.empty?
+        showMessage = false
+        @@stack.each do |segment|
+          # If a segment list is used to filter the output, we look for the
+          # first listed segments on the stack. This and all nested segments
+          # will be shown.
+          if @@segments.include?(segment) &&
+            (offset = @@stack.length - @@stack.index(segment)) >= @@level
+            showMessage = true
+            break
+          end
+        end
+        return unless showMessage
+      end
+      if @@stack.length - offset < @@level
+        $stderr.puts ' ' * (@@stack.length - offset) + message
+      end
+    end
+
+    # The progress meter can be a textual progress bar or some animated
+    # character sequence that informs the user about ongoing activities. Call
+    # this function to start the progress meter display or to change the info
+    # +text+. The the meter is active the text cursor is always returned to
+    # the start of the same line. Consequent output will overwrite the last
+    # meter text.
+    def Log.startProgressMeter(text)
+      return if @@silent
+
+      maxlen = 60
+      text = text.ljust(maxlen)
+      text = text[0..maxlen] if text.length > maxlen
+      @@progressMeter = text
+      $stdout.print("#{@@progressMeter} ...\r")
+    end
+
+    # This sets the progress meter status to "done" and puts the cursor into
+    # the next line again.
+    def Log.stopProgressMeter
+      return if @@silent
+
+      $stdout.print("#{@@progressMeter} [      Done      ]\n")
+    end
+
+    # This function may only be called when Log#startProgressMeter has been
+    # called before. It updates the progress indicator to the next symbol to
+    # visualize ongoing activity.
+    def Log.activity
+      return if @@silent
+
+      indicator = %w( - \\ | / )
+      @@progress = (@@progress.to_i + 1) % indicator.length
+      $stdout.print("#{@@progressMeter} [#{indicator[@@progress]}]\r")
+    end
+
+    # This function may only be called when Log#startProgressMeter has been
+    # called before. It updates the progress bar to the given +percent+
+    # completion value. The value should be between 0.0 and 1.0.
+    def Log.progress(percent)
+      return if @@silent
+
+      percent = 0.0 if percent < 0.0
+      percent = 1.0 if percent > 1.0
+      @@progress = percent
+
+      length = 16
+      full = (length * percent).to_i
+      bar = '=' * full + ' ' * (length - full)
+      label = (percent * 100.0).to_i.to_s + '%'
+      bar[length / 2 - label.length / 2, label.length] = label
+      $stdout.print("#{@@progressMeter} [#{bar}]\r")
+    end
+
+  end
+
+end
+

data/lib/LogicalExpression.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = LogicalExpression.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'
+require 'Attributes'
+require 'LogicalFlag'
+require 'LogicalFunction'
+
+class TaskJuggler
+
+  # A LogicalExpression is an object that describes tree of LogicalOperation
+  # objects and the context that it should be evaluated in.
+  class LogicalExpression
+
+    attr_reader :property, :sourceFileInfo
+
+    # Create a new LogicalExpression object. _op_ must be a LogicalOperation.
+    # _sourceFileInfo_ is the file position where expression started. It may be
+    # nil if not available.
+    def initialize(op, sourceFileInfo = nil)
+      @operation = op
+      @sourceFileInfo = sourceFileInfo
+
+      @property = @scopeProperty = nil
+    end
+
+    # This function triggers the evaluation of the expression. _property_ is the
+    # PropertyTreeNode that should be used for the evaluation. _scopeProperty_
+    # is the PropertyTreeNode that describes the scope. It may be nil.
+    def eval(property, scopeProperty)
+      @property = property
+      @scopeProperty = scopeProperty
+      res = @operation.eval(self)
+      return res if res.class == TrueClass || res.class == FalseClass
+      # In TJP syntax 'non 0' means false.
+      return res != 0
+    end
+
+    # This function is only used for debugging.
+    def to_s # :nodoc:
+      if @sourceFileInfo.nil?
+        "#{@operation}"
+      else
+        str = "#{@sourceFileInfo} #{@operation}"
+      end
+    end
+
+    # This is an internal function. It's called by the LogicalOperation methods
+    # in case something went wrong during an evaluation.
+    def error(text) # :nodoc:
+      if @sourceFileInfo.nil?
+        str = "Logical expression error: " + text
+      else
+        str = "#{@sourceFileInfo} Logical expression error: #{text}\n"
+      end
+      raise TjException.new, str
+    end
+
+  end
+
+end
+