colorable 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8551829488f48f304ed2f67f7b3557805257249b
-  data.tar.gz: e7954149790ea24ad68c0d2874be0c1002a6648a
+  metadata.gz: a4005fd6c6a2f7c11c4331bfc96f906c06bce741
+  data.tar.gz: 9af36345b9fa55dbaeb639e7c494c25ebd042ece
 SHA512:
-  metadata.gz: b16f6cabc48e8b27d57b3da0f968c68520e198dd83078646d2c49056fc55660a9a6ba9eb8ea99babbbf3f951407cb93b859aa67b5d661014c0871eeed901be35
-  data.tar.gz: 1aa34b017811d2e9428f4fa36e1b0ce8c468eb9e824650db27db4de37b8185cbfd9ff1a31ad9b7b07c871e3538b75bc8c3ae3a6c8241047529db1f0ffd88ab47
+  metadata.gz: b6645965c7f1971d803610d21763cbd120f517d2cc2b782a3c4e10e3d8fc64e19f2e95a2bc126288dfbb2a362fb0ac620216bc603f0c743f978ba691491c4004
+  data.tar.gz: 969e6b784f5529f579eb9f0364378be285bff790ca81c2b47e45fe8bdc413a83a33fd5452139953c92ad08966987610927c910024ea0fbad4f023fbb360f7bbb

data/README.md

@@ -1,7 +1,11 @@
 # Colorable
 
-Colorable is a color handler written in Ruby which include Color and Colorset classes.
-A color object provide a conversion between X11 colorname, RGB, HSB and HEX or other manipulations. a colorset object represent X11 colorset which can be manipulated like enumerable object.
+Colorable is a color handler written in Ruby, which has following functionalities;
+
+    1. Color conversion: convertible between X11 colorname, HEX, RGB and HSB values.
+    2. Color composition: a color object can be composible using math operators.
+    3. Color enumeration: a color object can be enumerable within X11 colors.
+    4. Color mode: a color object has a mode which represent output state of the color.
 
 ## Installation
 
@@ -19,119 +23,145 @@ Or install it yourself as:
 
 ## Usage
 
+
 Create a color object:
 
     require "colorable"
     include Colorable
 
-    # with a X11 colorname
-    c = Color.new :lime_green
-    c.to_s #=> "Lime Green"
-    c.rgb.to_a #=> [50, 205, 50]
-    c.hsb.to_a #=> [120, 76, 80]
-    c.hex.to_s #=> "#32CD32"
-    c.dark? #=> false
-
-    # with Array of RGB values
-    c = Color.new [50, 205, 50]
-    c.to_s #=> "rgb(50,205,50)"
-    c.name.to_s #=> "Lime Green"
-    c.hsb.to_a #=> [120, 76, 80]
-    c.hex.to_s #=> "#32CD32"
-
-    # with a HEX string
-    c = Color.new '#32CD32'
-    c.to_s #=> "#32CD32"
-
-    # with a RGB, HSB or HEX object
-    c = Color.new RGB.new(50, 205, 50)
-    c = Color.new HSB.new(120, 76, 80)
-    c = Color.new HEX.new('#32CD32')
-
-Manipulate color object:
-
-    c = Color.new :lime_green
-
-    c.to_s #=> "Lime Green"
-    c.rgb.to_a #=> [50, 205, 50]
-    c.hsb.to_a #=> [120, 76, 80]
-    c.hex.to_s #=> "#32CD32"
-    c.dark? #=> false
-
-    # info returns information of the color
-    c.info #=> {:NAME=>"Lime Green", :RGB=>[50, 205, 50], :HSB=>[120, 76, 80], :HEX=>"#32CD32", :MODE=>:NAME, :DARK=>false}
-
-    # next, prev returns next, prev color object in X11 color sequence
-    c.next.to_s #=> "Linen"
-    c.next(2).to_s #=> "Magenta"
-    c.prev.to_s #=> "Lime"
-    c.prev(2).to_s #=> "Light Yellow"
-
-    # +, - returns incremented or decremented color object
-    (c + 1).to_s #=> "Linen"
-    (c + 2).to_s #=> "Magenta"
-    (c - 1).to_s #=> "Lime"
-    (c - 2).to_s #=> "Light Yellow"
-
-Color object has a mode which represent output mode of the color. Behaviours of `#to_s`, `next`, `prev`, `+`, `-` will be changed based on the mode. You can change the mode with `#mode=` between :NAME, :RGB, :HSB, :HEX.
-
-    c = Color.new 'Lime Green'
-    c.mode = :NAME
-    c.to_s #=> "Lime Green"
-    c.next.to_s #=> "Linen"
+    # from a X11 colorname
+    Color.new 'Alice Blue' # => #<Colorable::Color 'Alice Blue<rgb(240,248,255)/hsb(208,6,100)/#F0F8FF>'>
 
-    c.mode = :RGB
-    c.to_s #=> "rgb(50,205,50)"
-    c.next.to_s #=> "rgb(60,179,113)"
-    c.next.name.to_s #=> "Medium Sea Green"
-    (c + 10).to_s #=> "rgb(60,215,60)"
-    (c + [0, 50, 100]).to_s #=> "rgb(50, 255, 150)"
+    # from a HEX string
+    Color.new '#F0F8FF' # => #<Colorable::Color 'Alice Blue<rgb(240,248,255)/hsb(208,6,100)/#F0F8FF>'>
 
-Shortcut for creating a color object with #to_color of String, Symbol and Array:
+    # from RGB values
+    Color.new [240, 248, 255] # => #<Colorable::Color 'Alice Blue<rgb(240,248,255)/hsb(208,6,100)/#F0F8FF>'>
 
-    c = "Lime Green".to_color
-    c.class #=> Colorable::Color
+    # from a HSB object
+    Color.new HSB.new(208, 6, 100) # => #<Colorable::Color 'Alice Blue<rgb(240,248,255)/hsb(208,6,100)/#F0F8FF>'>
 
-    c = :lime_green.to_color
-    c.class #=> Colorable::Color
+    # using #to_color methods
 
-    c = "#32CD32".to_color
-    c.class #=> Colorable::Color
+    'Alice Blue'.to_color # => #<Colorable::Color 'Alice Blue<rgb(240,248,255)/hsb(208,6,100)/#F0F8FF>'>
 
-    c = [50, 205, 50].to_color
-    c.class #=> Colorable::Color
+    :alice_blue.to_color # => #<Colorable::Color 'Alice Blue<rgb(240,248,255)/hsb(208,6,100)/#F0F8FF>'>
 
-Create a X11 colorset object:
+    '#f0f8ff'.to_color # => #<Colorable::Color 'Alice Blue<rgb(240,248,255)/hsb(208,6,100)/#F0F8FF>'>
 
-    include Colorable
+    [240, 248, 255].to_color # => #<Colorable::Color 'Alice Blue<rgb(240,248,255)/hsb(208,6,100)/#F0F8FF>'>
+
+    0xf0f8ff.to_color # => #<Colorable::Color 'Alice Blue<rgb(240,248,255)/hsb(208,6,100)/#F0F8FF>'>
+
+
+Color conversion:
+
+    c = Color.new :alice_blue
+
+    c.name # => "Alice Blue"
+    c.rgb  # => [240, 248, 255]
+    c.hsb  # => [208, 6, 100]
+    c.hex  # => "#F0F8FF"
+    c.dark?     # => false
+    c.info # => {:name=>"Alice Blue", :rgb=>[240, 248, 255], :hsb=>[208, 6, 100], :hex=>"#F0F8FF", :mode=>:NAME, :dark=>false}
+
+    [240, 248, 255].to_color.hex # => "#F0F8FF"
+    [240, 248, 255].to_color.hsb # => [208, 6, 100]
+
+
+Color composition:
+
+    red = Color.new :red
+    green = Color.new :green
+    blue = Color.new :blue
+
+    yellow = red + green
+    yellow.info # => {:name=>"Yellow", :rgb=>[255, 255, 0], :hsb=>[60, 100, 100], :hex=>"#FFFF00", :mode=>:NAME, :dark=>false}
+
+    red + blue # => #<Colorable::Color 'Fuchsia<rgb(255,0,255)/hsb(300,100,100)/#FF00FF>'>
+
+    green + blue # => #<Colorable::Color 'Aqua<rgb(0,255,255)/hsb(180,100,100)/#00FFFF>'>
+
+    red + green + blue # => #<Colorable::Color 'White<rgb(255,255,255)/hsb(0,0,100)/#FFFFFF>'>
 
-    cs = Colorset.new #=> #<Colorset 0/144 pos='Alice Blue/rgb(240,248,255)/hsb(208,6,100)'>
+    red - green # => #<Colorable::Color 'Black<rgb(0,0,0)/hsb(0,0,0)/#000000>'>
+    red * green # => #<Colorable::Color 'Black<rgb(0,0,0)/hsb(0,0,0)/#000000>'>
+    red / green # => #<Colorable::Color 'Yellow<rgb(255,255,0)/hsb(60,100,100)/#FFFF00>'>
+
+Color enumeration:
+
+    c = Color.new :alice_blue
+    
+    c.next # => #<Colorable::Color 'Antique White<rgb(250,235,215)/hsb(35,14,98)/#FAEBD7>'>
+    c.next(10) # => #<Colorable::Color 'Blue Violet<rgb(138,43,226)/hsb(271,81,89)/#8A2BE2>'>
+
+    c.prev # => #<Colorable::Color 'Yellow Green<rgb(154,205,50)/hsb(79,76,80)/#9ACD32>'>
+    c.prev(10) # => #<Colorable::Color 'Teal<rgb(0,128,128)/hsb(180,100,50)/#008080>'>
+
+    c + 1 # => #<Colorable::Color 'Antique White<rgb(250,235,215)/hsb(35,14,98)/#FAEBD7>'>
+    c + 10 # => #<Colorable::Color 'Blue Violet<rgb(138,43,226)/hsb(271,81,89)/#8A2BE2>'>
+    c - 1 # => #<Colorable::Color 'Yellow Green<rgb(154,205,50)/hsb(79,76,80)/#9ACD32>'>
+    c - 10 # => #<Colorable::Color 'Teal<rgb(0,128,128)/hsb(180,100,50)/#008080>'>
+
+    10.times.map { c = c.next }.map(&:name) # => ["Antique White", "Aqua", "Aquamarine", "Azure", "Beige", "Bisque", "Black", "Blanched Almond", "Blue", "Blue Violet"]
+
+
+Color mode:
+
+    c = Color.new :alice_blue
+    c.mode # => :NAME
+    c.to_s # => "Alice Blue"
+    c.next # => #<Colorable::Color 'Antique White<rgb(250,235,215)/hsb(35,14,98)/#FAEBD7>'>
+    c + 1 # => #<Colorable::Color 'Antique White<rgb(250,235,215)/hsb(35,14,98)/#FAEBD7>'>
+
+    c.mode = :RGB
+    c.to_s # => "rgb(240,248,255)"
+    c.next # => #<Colorable::Color 'Honeydew<rgb(240,255,240)/hsb(120,6,100)/#F0FFF0>'>
+    c + [15, -20, -74] # => #<Colorable::Color 'Moccasin<rgb(255,228,181)/hsb(39,29,100)/#FFE4B5>'>
+    c - 20 # => #<Colorable::Color '<rgb(220,228,235)/hsb(208,6,92)/#DCE4EB>'>
+
+    c.mode = :HSB # !> `*' interpreted as argument prefix
+    c.to_s # => "hsb(208,6,100)"
+    c.next # => #<Colorable::Color 'Slate Gray<rgb(112,128,144)/hsb(210,22,56)/#708090>'>
+    c + [152, 94, 0] # => #<Colorable::Color 'Red<rgb(255,0,0)/hsb(0,100,100)/#FF0000>'>
+
+    c.mode = :HEX
+    c.to_s # => "#F0F8FF"
+    c.next # => #<Colorable::Color 'Honeydew<rgb(240,255,240)/hsb(120,6,100)/#F0FFF0>'>
+    c + 4 # => #<Colorable::Color '<rgb(244,252,3)/hsb(62,99,99)/#F4FC03>'>
+
+Create a X11 Colorset object
+
+        cs = Colorset.new # => #<Colorable::Colorset 0/144 pos='Alice Blue<rgb(240,248,255)/hsb(208,6,100)>'>
+
+        # with option
+        cs = Colorset.new(order: :RGB) # => #<Colorable::Colorset 0/144 pos='Black<rgb(0,0,0)/hsb(0,0,0)>'>
+        cs = Colorset.new(order: :HSB, dir: :-) # => #<Colorable::Colorset 0/144 pos='Light Pink<rgb(255,182,193)/hsb(352,29,100)>'>
 
-    # with option
-    cs = Colorset.new(order: :RGB) #=> #<Colorset 0/144 pos='Black/rgb(0,0,0)/hsb(0,0,0)'>
-    cs = Colorset.new(order: :HSB, dir: :-) #=> #<Colorset 0/144 pos='Light Pink/rgb(255,182,193)/hsb(352,29,100)'>
 
 Manupilate colorset:
 
-    cs = Colorset.new
-    cs.size #=> 144
-    cs.at.to_s #=> "Alice Blue"
-    cs.at(1).to_s #=> "Antique White"
-    cs.at(2).to_s #=> "Aqua"
+        cs = Colorset.new
+        cs.size # => 144
+        cs.at # => #<Colorable::Color 'Alice Blue<rgb(240,248,255)/hsb(208,6,100)/#F0F8FF>'>
+        cs.at.to_s # => "Alice Blue"
+        cs.at(1).to_s # => "Antique White"
+        cs.at(2).to_s # => "Aqua"
+
+        # next(prev) methods moves cursor position
+        cs.next.to_s # => "Antique White"
+        cs.at.to_s # => "Antique White"
+        cs.next.to_s # => "Aqua"
+        cs.at.to_s # => "Aqua"
+        cs.rewind
+        cs.at.to_s # => "Alice Blue"
 
-    # next(prev) methods moves cursor position
-    cs.next.to_s #=> "Antique White"
-    cs.at.to_s #=> "Antique White"
-    cs.next.to_s #=> "Aqua"
-    cs.at.to_s #=> "Aqua"
-    cs.rewind
-    cs.at.to_s #=> "Alice Blue"
+        cs.map(&:to_s).take(10) # => ["Alice Blue", "Antique White", "Aqua", "Aquamarine", "Azure", "Beige", "Bisque", "Black", "Blanched Almond", "Blue"]
 
-    cs.map(&:to_s).take(10) #=> ["Alice Blue", "Antique White", "Aqua", "Aquamarine", "Azure", "Beige", "Bisque", "Black", "Blanched Almond", "Blue"]
+        cs.sort_by(&:rgb).take(10).map(&:rgb) # => [[0, 0, 0], [0, 0, 128], [0, 0, 139], [0, 0, 205], [0, 0, 255], [0, 100, 0], [0, 128, 0], [0, 128, 128], [0, 139, 139], [0, 191, 255]]
 
-    cs.sort_by(&:rgb).map(&:to_s).take(10) #=> ["Black", "Navy", "Dark Blue", "Medium Blue", "Blue", "Dark Green", "Green2", "Teal", "Dark Cyan", "Deep Sky Blue"]
+        cs.sort_by(&:hsb).take(10).map(&:hsb) # => [[0, 0, 0], [0, 0, 41], [0, 0, 50], [0, 0, 66], [0, 0, 75], [0, 0, 75], [0, 0, 83], [0, 0, 86], [0, 0, 96], [0, 0, 100]]
 
-    cs.sort_by(&:hsb).map(&:to_s).take(10) #=> ["Black", "Dim Gray", "Gray2", "Dark Gray", "Gray", "Silver", "Light Gray", "Gainsboro", "White Smoke", "White"]
 
 
 ## Contributing

data/lib/colorable.rb

@@ -12,6 +12,10 @@ module Colorable
 
 end
 
-[String, Symbol, Array].each do |klass|
-	klass.class_eval { define_method(:to_color) { Colorable::Color.new self } }
+[String, Symbol, Array, Fixnum].each do |klass|
+  klass.class_eval do
+    define_method(:to_color) do
+      Colorable::Color.new (klass==Fixnum ? self.to_s(16) : self)
+    end
+  end
 end

data/lib/colorable/color.rb

@@ -2,7 +2,6 @@ module Colorable
   class Color
     class NameError < StandardError; end
     include Comparable
-    attr_reader :name, :rgb
 
     # Create a Color object which has several representations of a color.
     #
@@ -24,7 +23,7 @@ module Colorable
 
     # Set output mode.
     def mode=(mode)
-      modes = [rgb, hsb, name, hex]
+      modes = [_rgb, _hsb, _name, _hex]
       @mode = modes.detect { |m| m.class.to_s.match /#{mode}/i } || begin
                 raise ArgumentError, "Invalid mode given"
               end
@@ -34,37 +33,65 @@ module Colorable
       @mode.to_s
     end
 
+    def inspect
+      "#<%s '%s<%s/%s/%s>'>" % [self.class, _name, _rgb, _hsb, _hex]
+    end
+
     # Returns information of the color object
     def info
       {
-        NAME: name.to_s,
-        RGB: rgb.to_a,
-        HSB: hsb.to_a,
-        HEX: hex.to_s,
-        MODE: mode,
-        DARK: dark?
+        name: name,
+        rgb: rgb,
+        hsb: hsb,
+        hex: hex,
+        mode: mode,
+        dark: dark?
       }
     end
 
+    def _name
+      @name
+    end
+
+    def _rgb
+      @rgb
+    end
+
+    def _hex
+      @hex ||= HEX.new _rgb.to_hex
+    end
+
+    def _hsb
+      @hsb ||= HSB.new *_rgb.to_hsb
+    end
+
+    def name
+      _name.to_s
+    end
+
     def hex
-      @hex ||= HEX.new rgb.to_hex
+      _hex.to_s
+    end
+
+    def rgb
+      _rgb.to_a
     end
 
     def hsb
-      @hsb ||= HSB.new *rgb.to_hsb
+      _hsb.to_a
     end
     alias :hsv :hsb
 
     %w(red green blue).each do |c|
-      define_method(c) { rgb.send c }
+      define_method(c) { _rgb.send c }
     end
 
     %w(hue sat bright).each do |c|
-      define_method(c) { hsb.send c }
+      define_method(c) { _hsb.send c }
     end
 
     def <=>(other)
-      if [self.name, other.name].any?(&:nil?)
+      if [self.name, other.name].any?(&:empty?)
         self.rgb <=> other.rgb
       else
         self.name <=> other.name
@@ -79,6 +106,7 @@ module Colorable
       idx = @@colorset[mode].find_index(self)
       @@colorset[mode].at(idx+n).tap{|c| c.mode = mode } if idx
     end
+    alias :succ :next
 
     # Returns a previous color object in X11 colors.
     # The color sequence is determined by its color mode.
@@ -87,21 +115,51 @@ module Colorable
     end
 
     def dark?
-      !!DARK_COLORS.detect { |d| d == name.to_s }
+      !!DARK_COLORS.detect { |d| d == self.name }
     end
 
-    # Returns a color object which has incremented color values.
-    # Array of values or a Fixnum is acceptable as an argument.
-    # Which values are affected is determined by its color mode.
-    def +(arg)
-      self.class.new @mode + arg
+    # Color addition
+    #
+    # +other+ can be:
+    #   Color object: apply minimum compositing with its RGBs.
+    #   Array of values or Fixnum: addiction applies based on its color mode.
+    def +(other)
+      case other
+      when Color
+        new_by_composed_rgb(:+, other)
+      else
+        self.class.new @mode + other
+      end
+    end
+
+    # Color subtruction
+    #
+    # +other+ can be:
+    #   Color object: apply maximum compositing with its RGBs.
+    #   Array of values or Fixnum: subtruction applies based on its color mode.
+    def -(other)
+      case other
+      when Color
+        new_by_composed_rgb(:-, other)
+      else
+        self.class.new @mode - other
+      end
     end
 
-    # Returns a color object which has decremented color values.
-    # Array of values or a Fixnum is acceptable as an argument.
-    # Which values are affected is determined by its color mode.
-    def -(arg)
-      self.class.new @mode - arg
+    # Color multiplication
+    #
+    # +other+ should be a Color object.
+    # It applies multiply compositing with its RGBs.
+    def *(other)
+      new_by_composed_rgb(:*, other)
+    end
+
+    # Color division
+    #
+    # +other+ should be a Color object.
+    # It applies screen compositing with its RGBs.
+    def /(other)
+      new_by_composed_rgb(:/, other)
     end
 
     private
@@ -163,5 +221,10 @@ module Colorable
         raise NameError, "Invalid color name given" unless res.name
       end
     end
+
+    def new_by_composed_rgb(op, other)
+      rgb = self._rgb.send(op, other._rgb)
+      self.class.new(rgb).tap { |c| c.mode = self.mode }
+    end
   end
 end

data/lib/colorable/color_space.rb

@@ -1,36 +1,36 @@
 module Colorable
-	class ColorSpace
+  class ColorSpace
     include Colorable::Converter
-		include Comparable
+    include Comparable
 
-		def <=>(other)
-			self.to_a <=> other.to_a
-		end
+    def <=>(other)
+      self.to_a <=> other.to_a
+    end
 
-	  def move_to_top(idx)
-	    arr = self.to_a
-	    arr.insert 0, arr.delete_at(idx)
-	  end
+    def move_to_top(idx)
+      arr = self.to_a
+      arr.insert 0, arr.delete_at(idx)
+    end
 
-	  def +(arg)
-	  	raise "Subclass must implement it"
-	  end
+    def +(arg)
+      raise "Subclass must implement it"
+    end
 
-		def -(arg)
-			arg = arg.is_a?(Fixnum) ? -arg : arg.map(&:-@)
-			self + arg
-		end
+    def -(arg)
+      arg = arg.is_a?(Fixnum) ? -arg : arg.map(&:-@)
+      self + arg
+    end
 
-		def coerce(arg)
-			[self, arg]
-		end
+    def coerce(arg)
+      [self, arg]
+    end
 
-		def to_s
-			name = "#{self.class}"[/\w+$/].downcase
+    def to_s
+      name = "#{self.class}"[/\w+$/].downcase
       "#{name}(%i,%i,%i)" % to_a
-		end
+    end
 
-		private
+    private
     def validate(pattern, data)
       case Array(data)
       when Pattern[*Array(pattern)] then data
@@ -38,138 +38,183 @@ module Colorable
         raise ArgumentError, "'#{data}' is invalid for a #{self.class} value"
       end
     end
-	end
-
-	class RGB < ColorSpace
-		attr_accessor :rgb, :r, :g, :b
-		def initialize(r=0,g=0,b=0)
-			@r, @g, @b = @rgb = validate_rgb([r, g, b])
-		end
-		alias :red :r
-		alias :green :g
-		alias :blue :b
-		alias :to_a :rgb
-
-		# Pass Array of [r, g, b] or a Fixnum.
-		# Returns new RGB object with added RGB.
-		def +(arg)
-			arg =
-				case arg
-				when Fixnum
-					[arg] * 3
-				when Array
-					raise ArgumentError, "Must be three numbers contained" unless arg.size==3
-					arg
-				else
-					raise ArgumentError, "Accept only Array of three numbers or a Fixnum"
-				end
-			new_rgb = self.rgb.zip(arg).map { |x, y| x + y }
-			self.class.new *new_rgb
-		end
-
-		def to_name
-			rgb2name(self.to_a)
-		end
-
-		def to_hsb
-			rgb2hsb(self.to_a)
-		end
-
-		def to_hex
-			rgb2hex(self.to_a)
-		end
-
-		private
+  end
+
+  class RGB < ColorSpace
+    attr_accessor :rgb, :r, :g, :b
+    def initialize(r=0,g=0,b=0)
+      @r, @g, @b = @rgb = validate_rgb([r, g, b])
+    end
+    alias :red :r
+    alias :green :g
+    alias :blue :b
+    alias :to_a :rgb
+
+    # Color addition
+    #
+    # +other+ can be:
+    #   RGB object: apply minimum compositing.
+    #   Array of RGB values: each values added to each of RGBs.
+    #   Fixnum: other number added to all of RGBs.
+    def +(other)
+      rgb =
+        case other
+        when RGB
+          compound_by(other.rgb) { |a, b| [a+b, 255].min }
+        when Array
+          raise ArgumentError, "Invalid size of Array given" unless other.size==3
+          compound_by(other) { |a, b| (a + b) % 256 }
+        when Fixnum
+          compound_by([other] * 3) { |a, b| (a + b) % 256 }
+        else
+          raise ArgumentError, "Invalid argument given"
+        end
+      self.class.new *rgb
+    end
+
+    # Color subtruction
+    #
+    # +other+ can be:
+    #   RGB object: apply maximum compositing.
+    #   Array of RGB values: each values added to each of RGBs.
+    #   Fixnum: other number added to all of RGBs.
+    def -(other)
+      case other
+      when RGB
+        rgb = compound_by(other.rgb) { |a, b| [a+b-255, 0].max }
+        self.class.new *rgb
+      else
+        super
+      end
+    end
+
+    # Color multiplication
+    #
+    # +other+ should be a Color object.
+    # It applies multiply compositing.
+    def *(other)
+      raise ArgumentError, "Invalid argument given" unless other.is_a?(RGB)
+      rgb = compound_by(other.rgb) { |a, b| [(a*b/255.0).round, 0].max }
+      self.class.new *rgb
+    end
+
+    # Color division
+    #
+    # +other+ should be a Color object.
+    # It applies screen compositing.
+    def /(other)
+      raise ArgumentError, "Invalid argument given" unless other.is_a?(RGB)
+      rgb = compound_by(other.rgb) { |a, b| [a+b-(a*b/255.0).round, 255].min }
+      self.class.new *rgb
+    end
+
+    def to_name
+      rgb2name(self.to_a)
+    end
+
+    def to_hsb
+      rgb2hsb(self.to_a)
+    end
+
+    def to_hex
+      rgb2hex(self.to_a)
+    end
+
+    private
     def validate_rgb(rgb)
       validate([0..255, 0..255, 0..255], rgb)
     end
-	end
-
-	class HSB < ColorSpace
-		attr_accessor :hsb, :h, :s, :b
-		def initialize(h=0,s=0,b=0)
-			@h, @s, @b = @hsb = validate_hsb([h, s, b])
-		end
-		alias :hue :h
-		alias :sat :s
-		alias :bright :b
-		alias :to_a :hsb
-		undef :coerce
-
-		# Pass Array of [h, s, b] or a Fixnum.
-		# Returns new HSB object with added HSB.
-		def +(arg)
-			arg =
-				case arg
-				when Array
-					raise ArgumentError, "Must be three numbers contained" unless arg.size==3
-					arg
-				else
-					raise ArgumentError, "Accept only Array of three numbers"
-				end
-			new_hsb = self.hsb.zip(arg).map { |x, y| x + y }
-			self.class.new *new_hsb
-		end
-
-		def to_name
-			rgb2name(self.to_rgb)
-		end
-
-		def to_rgb
-			hsb2rgb(self.to_a)
-		end
-
-		def to_hex
-			rgb2hex(self.to_rgb)
-		end
-
-		private
+
+    def compound_by(rgb, &blk)
+      self.rgb.zip(rgb).map(&blk)
+    end
+  end
+
+  class HSB < ColorSpace
+    attr_accessor :hsb, :h, :s, :b
+    def initialize(h=0,s=0,b=0)
+      @h, @s, @b = @hsb = validate_hsb([h, s, b])
+    end
+    alias :hue :h
+    alias :sat :s
+    alias :bright :b
+    alias :to_a :hsb
+    undef :coerce
+
+    # Pass Array of [h, s, b] or a Fixnum.
+    # Returns new HSB object with added HSB.
+    def +(arg)
+      arg =
+        case arg
+        when Array
+          raise ArgumentError, "Must be three numbers contained" unless arg.size==3
+          arg
+        else
+          raise ArgumentError, "Accept only Array of three numbers"
+        end
+      new_hsb = self.hsb.zip(arg, [360, 101, 101]).map { |x, y, div| (x + y) % div }
+      self.class.new *new_hsb
+    end
+
+    def to_name
+      rgb2name(self.to_rgb)
+    end
+
+    def to_rgb
+      hsb2rgb(self.to_a)
+    end
+
+    def to_hex
+      rgb2hex(self.to_rgb)
+    end
+
+    private
     def validate_hsb(hsb)
       validate([0..359, 0..100, 0..100], hsb)
     end
-	end
+  end
 
-	class HEX < ColorSpace
-		attr_reader :hex
-		def initialize(hex='#FFFFFF')
-			@hex = validate_hex(hex)
-		end
-		alias :to_s :hex
+  class HEX < ColorSpace
+    attr_reader :hex
+    def initialize(hex='#FFFFFF')
+      @hex = validate_hex(hex)
+    end
+    alias :to_s :hex
 
-		def to_a
-			@hex.unpack('A1A2A2A2').drop(1)
-		end
+    def to_a
+      @hex.unpack('A1A2A2A2').drop(1)
+    end
 
-		def +(arg)
-			build_hex_with(:+, arg)
-		end
+    def +(arg)
+      build_hex_with(:+, arg)
+    end
 
-		def -(arg)
-			build_hex_with(:-, arg)
-		end
+    def -(arg)
+      build_hex_with(:-, arg)
+    end
 
-		def to_rgb
-			hex2rgb(self.to_s)
-		end
+    def to_rgb
+      hex2rgb(self.to_s)
+    end
 
-		def to_hsb
-			rgb2hsb(self.to_rgb)
-		end
+    def to_hsb
+      rgb2hsb(self.to_rgb)
+    end
 
-		def to_name
-			rgb2name(self.to_rgb)
-		end
+    def to_name
+      rgb2name(self.to_rgb)
+    end
 
     private
     def validate_hex(hex)
-    	hex = hex.join if hex.is_a?(Array)
+      hex = hex.join if hex.is_a?(Array)
       validate(/^#[0-9A-F]{6}$/i, hex_norm(hex))
     end
 
     def hex_norm(hex)
-    	hex = hex.to_s.sub(/^#/, '').upcase
-    	 				 .sub(/^([0-9A-F])([0-9A-F])([0-9A-F])$/, '\1\1\2\2\3\3')
-    	"##{hex}"
+      hex = hex.to_s.sub(/^#/, '').upcase
+               .sub(/^([0-9A-F])([0-9A-F])([0-9A-F])$/, '\1\1\2\2\3\3')
+      "##{hex}"
     end
 
     def rgb2hex(rgb)
@@ -185,76 +230,76 @@ module Colorable
     end
 
     def build_hex_with(op, arg)
-    	_rgb =
-				case arg
-				when Fixnum
-					[arg] * 3
-				when String
-					hex2rgb(validate_hex arg)
-				else
-					raise ArgumentError, "Accept only a Hex string or a Fixnum"
-				end	
-			rgb = hex2rgb(self.hex).zip(_rgb).map { |x, y| x.send(op, y) }
-			self.class.new rgb2hex(rgb)
-    end
-	end
-
-	class NAME < ColorSpace
-		attr_accessor :name
-		attr_reader :sym
-		def initialize(name)
-			@name = find_name(name)
-			@sym = nil
-		end
-
-		alias :to_s :name
-
-		def sym(sep='_')
-			@name.gsub(/\s/, sep).downcase.intern if @name
-		end
-
-		def dark?
+      _rgb =
+        case arg
+        when Fixnum
+          [arg] * 3
+        when String
+          hex2rgb(validate_hex arg)
+        else
+          raise ArgumentError, "Accept only a Hex string or a Fixnum"
+        end 
+      rgb = hex2rgb(self.hex).zip(_rgb).map { |x, y| (x.send(op, y)) % 256 }
+      self.class.new rgb2hex(rgb)
+    end
+  end
+
+  class NAME < ColorSpace
+    attr_accessor :name
+    attr_reader :sym
+    def initialize(name)
+      @name = find_name(name)
+      @sym = nil
+    end
+
+    alias :to_s :name
+
+    def sym(sep='_')
+      @name.gsub(/\s/, sep).downcase.intern if @name
+    end
+
+    def dark?
       DARK_COLORS.detect { |d| d == self.name }
-		end
-
-		def <=>(other)
-			self.name <=> other.name
-		end
-
-		def +(n)
-			raise ArgumentError, 'Only accept a Fixnum' unless n.is_a?(Fixnum)
-			pos = COLORNAMES.find_index{|n,_| n==self.name} + n
-			self.class.new COLORNAMES.at(pos % COLORNAMES.size)[0]
-		end
-
-		def -(n)
-			raise ArgumentError, 'Only accept a Fixnum' unless n.is_a?(Fixnum)
-			self + -n
-		end
-
-		def coerce(arg)
-			[self, arg]
-		end
-
-		def to_rgb
-			name2rgb(self.to_s)
-		end
-
-		def to_hsb
-			rgb2hsb(self.to_rgb)
-		end
-
-		def to_hex
-			rgb2hex(self.to_rgb)
-		end
-
-		private
-		def find_name(name)
-			COLORNAMES.map(&:first).detect { |c|
+    end
+
+    def <=>(other)
+      self.name <=> other.name
+    end
+
+    def +(n)
+      raise ArgumentError, 'Only accept a Fixnum' unless n.is_a?(Fixnum)
+      pos = COLORNAMES.find_index{|n,_| n==self.name} + n
+      self.class.new COLORNAMES.at(pos % COLORNAMES.size)[0]
+    end
+
+    def -(n)
+      raise ArgumentError, 'Only accept a Fixnum' unless n.is_a?(Fixnum)
+      self + -n
+    end
+
+    def coerce(arg)
+      [self, arg]
+    end
+
+    def to_rgb
+      name2rgb(self.to_s)
+    end
+
+    def to_hsb
+      rgb2hsb(self.to_rgb)
+    end
+
+    def to_hex
+      rgb2hex(self.to_rgb)
+    end
+
+    private
+    def find_name(name)
+      COLORNAMES.map(&:first).detect { |c|
         [c, name].same? { |str| "#{str}".gsub(/[_\s]/,'').downcase }
-			} || begin
-				raise ArgumentError, "'#{name}' is not in X11 colorset."
-			end
-		end	
-	end
+      } || begin
+        raise ArgumentError, "'#{name}' is not in X11 colorset."
+      end
+    end 
+  end
 end