taskjuggler 3.1.0 → 3.2.0

data/lib/taskjuggler/LeaveList.rb

@@ -49,7 +49,7 @@ class TaskJuggler
     end
 
     def to_s
-      "#{@type} #{@description ? "\"#{@description}\"" : ""} #{@interval}"
+      "#{@type} #{@reason ? "\"#{@reason}\"" : ""} #{@interval}"
     end
 
   end

data/lib/taskjuggler/Limits.rb

@@ -94,9 +94,7 @@ class TaskJuggler
       def ok?(index, upper, resource)
         # if @upper does not match or the provided resource does not match,
         # we can ignore this limit.
-        return true if @upper != upper ||
-                       (!@resource.nil? ^ !resource.nil?) ||
-                       (@resource && resource && @resource != resource)
+        return true if @upper != upper || (@resource && @resource != resource)
 
         if index.nil?
           # No index given. We need to check all counters.
@@ -109,8 +107,8 @@ class TaskJuggler
           # anything. Everything is ok.
           return true if !@interval.contains?(index)
 
-          return @upper ? @scoreboard[idxToSbIdx(index)] < @value :
-                          @scoreboard[idxToSbIdx(index)] >= @value
+          sbVal = @scoreboard[idxToSbIdx(index)]
+          return @upper ? (sbVal < @value) : (sbVal >= @value)
         end
       end
 

data/lib/taskjuggler/MessageHandler.rb

@@ -15,18 +15,23 @@ if RUBY_VERSION < "1.9.0"
   require 'rubygems'
 end
 
+require 'singleton'
 require 'term/ansicolor'
 require 'taskjuggler/TextParser/SourceFileInfo'
 
 class TaskJuggler
 
+  class TjRuntimeError < RuntimeError
+  end
+
   # The Message object can store several classes of messages that the
   # application can send out.
   class Message
 
     include Term::ANSIColor
 
-    attr_reader :type, :id, :message, :sourceFileInfo, :line
+    attr_reader :type, :id, :message, :line
+    attr_accessor :sourceFileInfo
 
     # Create a new Message object.  The _type_ specifies what tpye of message
     # this is. The following types are supported: fatal, error, warning, info
@@ -68,7 +73,7 @@ class TaskJuggler
       @scenario = scenario
     end
 
-    # Convert the Message into a String.
+    # Convert the Message into a String that can be printed to the console.
     def to_s
       str = ""
       # The SourceFileInfo is printed as <fileName>:line:
@@ -87,26 +92,81 @@ class TaskJuggler
       str
     end
 
+    # Convert the Message into a String that can be stored in a log file.
+    def to_log
+      str = ""
+      # The SourceFileInfo is printed as <fileName>:line:
+      if @sourceFileInfo
+        str += "#{@sourceFileInfo.fileName}:#{sourceFileInfo.lineNo}: "
+      end
+      str += "Scenario #{@scenario.id}: " if @scenario
+      str += @message
+      str
+    end
+
   end
 
   # The MessageHandler can display and store application messages. Depending
   # on the type of the message, a TjExeption can be raised (:error), or the
   # program can be immedidately aborted (:fatal). Other types will just
   # continue the program flow.
-  class MessageHandler
+  class MessageHandlerInstance
+
+    include Singleton
 
     attr_reader :messages, :errors
-    attr_accessor :scenario, :abortOnWarning
+    attr_accessor :logFile, :appName, :abortOnWarning, :trapSetup, :baselineSFI
 
-    # Initialize the MessageHandler. _console_ specifies if the messages
-    # should be printed to $stderr.
-    def initialize(console = false)
-      @messages = []
-      @console = console
-      # We count the errors.
-      @errors = 0
+    LogLevels = { :none => 0, :fatal => 1, :error => 2, :critical => 2,
+                  :warning => 3, :info => 4, :debug => 5 }
+
+    # Initialize the MessageHandler.
+    def initialize
+      reset
+    end
+
+    # Reset the MessageHandler to the initial state. All messages will be
+    # purged and the error counter set to 0.
+    def reset
+      # This setting controls what type of messages will be written to the
+      # console.
+      @outputLevel = 4
+      # This setting controls what type of messages will be written to the log
+      # file.
+      @logLevel = 3
+      # The full file name of the log file.
+      @logFile = nil
+      # The name of the current application
+      @appName = 'unknown'
       # Set to true if program should be exited on warnings.
       @abortOnWarning = false
+      # A SourceFileInfo object that will be used to baseline the provided
+      # source file infos of the messages.
+      @baselineSFI = nil
+      # If this is set the true, we only throw a TjRuntimeError instead of
+      # using exit().
+      @trapSetup = false
+
+      clear
+    end
+
+    # Clear the error log.
+    def clear
+      # A counter for messages of type error.
+      @errors = 0
+      # A list of all generated messages.
+      @messages = []
+    end
+
+
+    # Set the console output level.
+    def outputLevel=(level)
+      @outputLevel = checkLevel(level)
+    end
+
+    # Set the log output level.
+    def logLevel=(level)
+      @logLevel = checkLevel(level)
     end
 
     # Generate a fatal message that will abort the application.
@@ -142,19 +202,70 @@ class TaskJuggler
     # Generate a debug message.
     def debug(id, message, sourceFileInfo = nil, line = nil, data = nil,
               scenario = nil)
-      addMessage(:info, id, message, sourceFileInfo, line, data, scenario)
+      addMessage(:debug, id, message, sourceFileInfo, line, data, scenario)
+    end
+
+    # Convert all messages into a single String.
+    def to_s
+      text = ''
+      @messages.each { |msg| text += msg.to_s }
+      text
+    end
+
+    private
+
+    def checkLevel(level)
+      if level.is_a?(Fixnum)
+        if level < 0 || level > 5
+          raise ArgumentError, "Unsupported level #{level}"
+        end
+      else
+        unless (level = LogLevels[level])
+          raise ArgumentError, "Unsupported level #{level}"
+        end
+      end
+
+      level
+    end
+
+    def log(type, message)
+      return unless @logFile
+
+      timeStamp = Time.new.strftime("%Y-%m-%d %H:%M:%S")
+      begin
+        @logFile.untaint
+        File.open(@logFile, 'a') do |f|
+          f.write("#{timeStamp} #{type} #{@appName}[#{Process.pid}]: " +
+                  "#{message}\n")
+        end
+      rescue
+        $stderr.puts "Cannot write to log file #{@logFile}: #{$!}"
+      end
     end
 
     # Generate a message by specifying the _type_.
     def addMessage(type, id, message, sourceFileInfo = nil, line = nil,
                    data = nil, scenario = nil)
+      # If we have a SourceFileInfo and a baseline SFI, we correct the
+      # sourceFileInfo accordingly.
+      if sourceFileInfo && @baselineSFI
+        sourceFileInfo = TextParser::SourceFileInfo.new(
+          @baselineSFI.fileName,
+          sourceFileInfo.lineNo + @baselineSFI.lineNo - 1,
+          sourceFileInfo.columnNo)
+      end
+
       # Treat criticals like errors but without generating another
       # exception.
       msg = Message.new(type == :critical ? :error : type, id, message,
                         sourceFileInfo, line, data, scenario)
       @messages << msg
+
+      # Append the message to the log file if requested by the user.
+      log(type, msg.to_log) if @logLevel >= LogLevels[type]
+
       # Print the message to $stderr if requested by the user.
-      $stderr.puts msg.to_s if @console
+      $stderr.puts msg.to_s if @outputLevel >= LogLevels[type]
 
       case type
       when :warning
@@ -165,17 +276,60 @@ class TaskJuggler
       when :error
         # Increase the error counter.
         @errors += 1
-        raise TjException.new, ''
+        if @trapSetup
+          raise TjRuntimeError
+        else
+          exit 1
+        end
       when :fatal
         raise RuntimeError
       end
     end
 
-    # Convert all messages into a single String.
-    def to_s
-      text = ''
-      @messages.each { |msg| text += msg.to_s }
-      text
+  end
+
+  module MessageHandler
+
+    # Generate a fatal message that will abort the application.
+    def fatal(id, message, sourceFileInfo = nil, line = nil, data = nil,
+              scenario = nil)
+      MessageHandlerInstance.instance.fatal(id, message, sourceFileInfo, line,
+                                            data, scenario)
+    end
+
+    # Generate an error message.
+    def error(id, message, sourceFileInfo = nil, line = nil, data = nil,
+              scenario = nil)
+      MessageHandlerInstance.instance.error(id, message, sourceFileInfo, line,
+                                            data, scenario)
+    end
+
+    # Generate an critical message.
+    def critical(id, message, sourceFileInfo = nil, line = nil, data = nil,
+                 scenario = nil)
+      MessageHandlerInstance.instance.critical(id, message, sourceFileInfo,
+                                               line, data, scenario)
+    end
+
+    # Generate a warning.
+    def warning(id, message, sourceFileInfo = nil, line = nil, data = nil,
+                scenario = nil)
+      MessageHandlerInstance.instance.warning(id, message, sourceFileInfo,
+                                              line, data, scenario)
+    end
+
+    # Generate an info message.
+    def info(id, message, sourceFileInfo = nil, line = nil, data = nil,
+             scenario = nil)
+      MessageHandlerInstance.instance.info(id, message, sourceFileInfo, line,
+                                           data, scenario)
+    end
+
+    # Generate a debug message.
+    def debug(id, message, sourceFileInfo = nil, line = nil, data = nil,
+              scenario = nil)
+      MessageHandlerInstance.instance.debug(id, message, sourceFileInfo, line,
+                                            data, scenario)
     end
 
   end

data/lib/taskjuggler/Painter.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = Painter.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011, 2012
+#               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/XMLElement'
+require 'taskjuggler/Painter/Primitives'
+require 'taskjuggler/Painter/Group'
+require 'taskjuggler/Painter/BasicShapes'
+require 'taskjuggler/Painter/Text'
+require 'taskjuggler/Painter/FontMetrics'
+
+class TaskJuggler
+
+  # This is a vector drawing class. It can describe a canvas with lines,
+  # rectangles, circles, ellipses and text elements on it. The elements can be
+  # grouped. It currently only supports rendering as an SVG output.
+  class Painter
+
+    include Primitives
+
+    # Create a canvas of dimension _width_ times _height_. The block can be
+    # used to add elements to the drawing. If the block has an argument, the
+    # block content is evaluated within the current context. If no argument is
+    # provided, the newly created object will be the evaluation context of the
+    # block. This will make instance variables of the caller inaccessible.
+    # Methods of the caller will still be available.
+    def initialize(width, height, &block)
+      @width = width
+      @height = height
+
+      @elements = []
+      if block
+        if block.arity == 1
+          # This is the traditional case where self is passed to the block.
+          # All Primitives methods now must be prefixed with the block
+          # variable to call them.
+          yield self
+        else
+          # In order to have the primitives easily available in the block, we
+          # use instance_eval to switch self to this object. But this makes the
+          # methods of the original self no longer accessible. We work around
+          # this by saving the original self and using method_missing to
+          # delegate the method call to the original self.
+          @originalSelf = eval('self', block.binding)
+          instance_eval(&block)
+        end
+      end
+    end
+
+    # Delegator to @originalSelf.
+    def method_missing(method, *args, &block)
+      @originalSelf.send(method, *args, &block)
+    end
+
+    # Render the canvas as SVG output (tree of XMLElement objects).
+    def to_svg
+      XMLElement.new('svg', 'width' => "#{@width}px",
+                            'height' => "#{@height}px") do
+        @elements.map { |el| el.to_svg }
+      end
+    end
+
+  end
+
+end
+

data/lib/taskjuggler/Painter/BasicShapes.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = BasicShapes.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011, 2012
+#               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/XMLElement'
+require 'taskjuggler/Painter/Element'
+
+class TaskJuggler
+
+  class Painter
+
+    # A circle element.
+    class Circle < Element
+
+      # Create a circle with center at cx, cy and radius r.
+      def initialize(attrs)
+        super('circle', [ :cx, :cy, :r ] + FillAndStrokeAttrs, attrs)
+      end
+
+    end
+
+    # An ellipse element.
+    class Ellipse < Element
+
+      # Create an ellipse with center at cx, cy and radiuses rx and ry.
+      def initialize(attrs)
+        super('ellipse', [ :cx, :cy, :rx, :ry ] + FillAndStrokeAttrs, attrs)
+      end
+
+    end
+
+    # A line element.
+    class Line < Element
+
+      # Create a line from x1, y1, to x2, y2.
+      def initialize(attrs)
+        super('line', [ :x1, :y1, :x2, :y2 ] + StrokeAttrs, attrs)
+      end
+
+    end
+
+    # A Rectangle element.
+    class Rect < Element
+
+      # Create a rectangle at x, y with width and height.
+      def initialize(attrs)
+        super('rect', [ :x, :y, :width, :height, :rx, :ry ] +
+                      FillAndStrokeAttrs, attrs)
+      end
+
+    end
+
+    # A Polygon line element.
+    class PolyLine < Element
+
+      # Create a polygon line with the provided Points.
+      def initialize(attrs)
+        super('polyline', [ :points ] + FillAndStrokeAttrs, attrs)
+      end
+
+    end
+
+  end
+
+end
+
+

data/lib/taskjuggler/Painter/Color.rb

@@ -0,0 +1,273 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = Color.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011, 2012
+#               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.
+#
+
+class TaskJuggler
+
+  class Painter
+
+    # A description of the color. The color is stored internally as an RGB
+    # value. Common names are provided for many popular colors.
+    class Color
+
+      NamedColors = {
+        :aliceblue => [ 240, 248, 255 ],
+        :antiquewhite  => [ 250, 235, 215 ],
+        :aqua => [ 0, 255, 255 ],
+        :aquamarine  => [ 127, 255, 212 ],
+        :azure => [ 240, 255, 255 ],
+        :beige => [ 245, 245, 220 ],
+        :bisque  => [ 255, 228, 196 ],
+        :black => [ 0, 0, 0 ],
+        :blanchedalmond  => [ 255, 235, 205 ],
+        :blue => [ 0, 0, 255 ],
+        :blueviolet  => [ 138, 43, 226 ],
+        :brown => [ 165, 42, 42 ],
+        :burlywood => [ 222, 184, 135 ],
+        :cadetblue => [ 95, 158, 160 ],
+        :chartreuse  => [ 127, 255, 0 ],
+        :chocolate => [ 210, 105, 30 ],
+        :coral => [ 255, 127, 80 ],
+        :cornflowerblue  => [ 100, 149, 237 ],
+        :cornsilk  => [ 255, 248, 220 ],
+        :crimson => [ 220, 20, 60 ],
+        :cyan => [ 0, 255, 255 ],
+        :darkblue => [ 0, 0, 139 ],
+        :darkcyan => [ 0, 139, 139 ],
+        :darkgoldenrod => [ 184, 134, 11 ],
+        :darkgray  => [ 169, 169, 169 ],
+        :darkgreen => [ 0, 100, 0 ],
+        :darkgrey  => [ 169, 169, 169 ],
+        :darkkhaki => [ 189, 183, 107 ],
+        :darkmagenta => [ 139, 0, 139 ],
+        :darkolivegreen => [ 85, 107, 47 ],
+        :darkorange  => [ 255, 140, 0 ],
+        :darkorchid  => [ 153, 50, 204 ],
+        :darkred => [ 139, 0, 0 ],
+        :darksalmon  => [ 233, 150, 122 ],
+        :darkseagreen  => [ 143, 188, 143 ],
+        :darkslateblue => [ 72, 61, 139 ],
+        :darkslategray => [ 47, 79, 79 ],
+        :darkslategrey => [ 47, 79, 79 ],
+        :darkturquoise => [ 0, 206, 209 ],
+        :darkviolet  => [ 148, 0, 211 ],
+        :deeppink  => [ 255, 20, 147 ],
+        :deepskyblue => [ 0, 191, 255 ],
+        :dimgray => [ 105, 105, 105 ],
+        :dimgrey => [ 105, 105, 105 ],
+        :dodgerblue => [ 30, 144, 255 ],
+        :firebrick => [ 178, 34, 34 ],
+        :floralwhite => [ 255, 250, 240 ],
+        :forestgreen => [ 34, 139, 34 ],
+        :fuchsia => [ 255, 0, 255 ],
+        :gainsboro => [ 220, 220, 220 ],
+        :ghostwhite  => [ 248, 248, 255 ],
+        :gold  => [ 255, 215, 0 ],
+        :goldenrod => [ 218, 165, 32 ],
+        :gray  => [ 128, 128, 128 ],
+        :grey  => [ 128, 128, 128 ],
+        :green => [ 0, 128, 0 ],
+        :greenyellow => [ 173, 255, 47 ],
+        :honeydew  => [ 240, 255, 240 ],
+        :hotpink => [ 255, 105, 180 ],
+        :indianred => [ 205, 92, 92 ],
+        :indigo => [ 75, 0, 130 ],
+        :ivory => [ 255, 255, 240 ],
+        :khaki => [ 240, 230, 140 ],
+        :lavender  => [ 230, 230, 250 ],
+        :lavenderblush => [ 255, 240, 245 ],
+        :lawngreen => [ 124, 252, 0 ],
+        :lemonchiffon  => [ 255, 250, 205 ],
+        :lightblue => [ 173, 216, 230 ],
+        :lightcoral  => [ 240, 128, 128 ],
+        :lightcyan => [ 224, 255, 255 ],
+        :lightgoldenrodyellow  => [ 250, 250, 210 ],
+        :lightgray => [ 211, 211, 211 ],
+        :lightgreen  => [ 144, 238, 144 ],
+        :lightgrey => [ 211, 211, 211 ],
+        :lightpink => [ 255, 182, 193 ],
+        :lightsalmon => [ 255, 160, 122 ],
+        :lightseagreen => [ 32, 178, 170 ],
+        :lightskyblue  => [ 135, 206, 250 ],
+        :lightslategray  => [ 119, 136, 153 ],
+        :lightslategrey  => [ 119, 136, 153 ],
+        :lightsteelblue  => [ 176, 196, 222 ],
+        :lightyellow => [ 255, 255, 224 ],
+        :lime => [ 0, 255, 0 ],
+        :limegreen => [ 50, 205, 50 ],
+        :linen => [ 250, 240, 230 ],
+        :magenta => [ 255, 0, 255 ],
+        :maroon  => [ 128, 0, 0 ],
+        :mediumaquamarine  => [ 102, 205, 170 ],
+        :mediumblue => [ 0, 0, 205 ],
+        :mediumorchid  => [ 186, 85, 211 ],
+        :mediumpurple  => [ 147, 112, 219 ],
+        :mediumseagreen => [ 60, 179, 113 ],
+        :mediumslateblue => [ 123, 104, 238 ],
+        :mediumspringgreen => [ 0, 250, 154 ],
+        :mediumturquoise => [ 72, 209, 204 ],
+        :mediumvioletred => [ 199, 21, 133 ],
+        :midnightblue => [ 25, 25, 112 ],
+        :mintcream => [ 245, 255, 250 ],
+        :mistyrose => [ 255, 228, 225 ],
+        :moccasin  => [ 255, 228, 181 ],
+        :navajowhite => [ 255, 222, 173 ],
+        :navy => [ 0, 0, 128 ],
+        :oldlace => [ 253, 245, 230 ],
+        :olive => [ 128, 128, 0 ],
+        :olivedrab => [ 107, 142, 35 ],
+        :orange  => [ 255, 165, 0 ],
+        :orangered => [ 255, 69, 0 ],
+        :orchid  => [ 218, 112, 214 ],
+        :palegoldenrod => [ 238, 232, 170 ],
+        :palegreen => [ 152, 251, 152 ],
+        :paleturquoise => [ 175, 238, 238 ],
+        :palevioletred => [ 219, 112, 147 ],
+        :papayawhip  => [ 255, 239, 213 ],
+        :peachpuff => [ 255, 218, 185 ],
+        :peru  => [ 205, 133, 63 ],
+        :pink  => [ 255, 192, 203 ],
+        :plum  => [ 221, 160, 221 ],
+        :powderblue  => [ 176, 224, 230 ],
+        :purple  => [ 128, 0, 128 ],
+        :red => [ 255, 0, 0 ],
+        :rosybrown => [ 188, 143, 143 ],
+        :royalblue => [ 65, 105, 225 ],
+        :saddlebrown => [ 139, 69, 19 ],
+        :salmon  => [ 250, 128, 114 ],
+        :sandybrown  => [ 244, 164, 96 ],
+        :seagreen => [ 46, 139, 87 ],
+        :seashell  => [ 255, 245, 238 ],
+        :sienna  => [ 160, 82, 45 ],
+        :silver  => [ 192, 192, 192 ],
+        :skyblue => [ 135, 206, 235 ],
+        :slateblue => [ 106, 90, 205 ],
+        :slategray => [ 112, 128, 144 ],
+        :slategrey => [ 112, 128, 144 ],
+        :snow  => [ 255, 250, 250 ],
+        :springgreen => [ 0, 255, 127 ],
+        :steelblue => [ 70, 130, 180 ],
+        :tan => [ 210, 180, 140 ],
+        :teal => [ 0, 128, 128 ],
+        :thistle => [ 216, 191, 216 ],
+        :tomato  => [ 255, 99, 71 ],
+        :turquoise => [ 64, 224, 208 ],
+        :violet  => [ 238, 130, 238 ],
+        :wheat => [ 245, 222, 179 ],
+        :white => [ 255, 255, 255 ],
+        :whitesmoke  => [ 245, 245, 245 ],
+        :yellow  => [ 255, 255, 0 ],
+        :yellowgreen => [ 154, 205, 50 ]
+      }
+
+      # Create a new Color object.
+      def initialize(*args)
+        if args.length == 1
+          unless NamedColors.include?(args[0])
+            raise "Unknown color name #{args[0]}"
+          end
+
+          @r, @g, @b = NamedColors[args[0]]
+        elsif args.length == 3
+          args.each do |v|
+            unless v >= 0 && v < 256
+              raise ArgumentError, "RGB values (#{args.join(', ')}) must " +
+                                   "be between 0 and 255."
+            end
+          end
+
+          @r, @g, @b = args
+        elsif args.length == 4
+          unless args[0] >= 0 && args[0] < 360
+            raise ArgumentError, "Hue value must be between 0 and 360"
+          end
+          unless args[1] >= 0 && args[1] <= 255
+            raise ArgumentError, "Saturation value (#{args[1]}) must be " +
+                                 "between 0 and 255"
+          end
+          unless args[2] >= 0 && args[2] <= 255
+            raise ArgumentError, "Color value (#{args[2]}) must be " +
+                                 "between 0 and 255"
+          end
+          @r, @g, @b = hsvToRgb(*args[0..2])
+        else
+          raise ArgumentError
+        end
+      end
+
+      def to_rgb
+        [ @r, @g, @b ]
+      end
+
+      def to_hsv
+        rgbToHsv(@r, @g, @b)
+      end
+
+      # Convert the RGB value into a String format that is used in HTML.
+      def to_s
+        format("#%02x%02x%02x", @r, @g, @b)
+      end
+
+      private
+
+      def hsvToRgb(h, s, v)
+        hi = (h / 60.0).floor % 6
+        f = (h / 60.0) - (h / 60.0).floor
+        p = (v * (1.0 - s / 255.0)).to_i
+        q = (v * (1.0 - (f * s / 255.0))).to_i
+        t = (v * (1.0 - ((1.0 - f) * s / 255.0))).to_i
+        [ [ v, t, p ],
+          [ q, v, p ],
+          [ p, v, t ],
+          [ p, q, v ],
+          [ t, p, v ],
+          [ v, p, q ] ][hi]
+      end
+
+      def rgbToHsv(*rgb)
+        max = rgb.max
+        min = rgb.min
+        chroma = (max - min).to_f
+        v = max
+
+        if (max != 0.0)
+            s = chroma / max * 255.0
+        else
+            s = 0.0
+        end
+
+        r, g, b = rgb
+        if (s == 0.0)
+          h = 0.0
+        else
+          if (r == max)
+            h = (g - b) / chroma
+          elsif (g == max)
+            h = 2.0 + (b - r) / chroma
+          elsif (b == max)
+            h = 4.0 + (r - g) / chroma
+          end
+
+          h *= 60.0
+
+          h += 360.0 if h < 0.0
+        end
+
+        [ h.to_i, s.to_i, v.to_i ]
+      end
+
+    end
+
+  end
+
+end
+