colorable 0.0.8 → 0.1.0

data/lib/colorable/colorset.rb

@@ -5,56 +5,42 @@ module Colorable
     include Enumerable
     extend Forwardable
 
-    def initialize(colorset=nil)
+    # Create a X11 colorset object.
+    #
+    # options::keys should be:
+    #          +order+:: :NAME(default), :RGB, :HSB or :HEX can be specified.
+    #          +dir+:: set :+(default) to increment order, :- to decrement order.
+    #          +colorset+:: set original colorset other than X11 if any.
+    def initialize(opt={})
+      opt = { order: :name, dir: :+ }.merge(opt)
       @pos = 0
-      @colorset =
-        colorset || COLORNAMES.map { |name, rgb| Colorable::Color.new(name) }
+      @colorset = opt[:colorset] ? opt[:colorset] : build_colorset(opt)
     end
 
     def_delegators :@colorset, :size, :first, :last, :to_a
 
-    # +Colorset[:order]+ create a ordered colorset by passing a order key.
-    def self.[](order, dir=:+, colorset=nil)
-      rgb = [:red, :green, :blue]
-      hsb = [:hue, :sat, :bright]
-      blk =
-        case order
-        when :red, :blue, :green
-          ->color{ color.rgb.move_to_top rgb.index(order) }
-        when :hue, :sat, :bright
-          ->color{ color.hsb.move_to_top hsb.index(order) }
-        else
-          ->color{ color.send order }
-        end
-
-      case dir
-      when :+
-        new(colorset).sort_by(&blk)
-      when :-
-        new(colorset).sort_by(&blk).reverse
-      else
-        raise ArgumentError, "it must ':+' or ':-'"
-      end
-    end
-
     def each(&blk)
       @colorset.each(&blk)
     end
 
+    # Returns a top color object in colorset
     def at(pos=0)
       @colorset[(@pos+pos)%size]
     end
 
+    # Returns a next color object in colorset
     def next(n=1)
       @pos = (@pos+n)%size
       at
     end
 
+    # Returns a previous color object in colorset
     def prev(n=1)
       @pos = (@pos-n)%size
       at
     end
 
+    # Rewind a cursor to the top
     def rewind
       @pos = 0
       at
@@ -65,17 +51,60 @@ module Colorable
       (@pos+idx)%size if idx
     end
 
+    # Returns a sorted colorset defined by passed block
     def sort_by(&blk)
-      self.class.new @colorset.sort_by(&blk)
+      self.class.new colorset: @colorset.sort_by(&blk)
     end
 
+    # Returns a reversed colorset
     def reverse
-      self.class.new @colorset.reverse
+      self.class.new colorset: @colorset.reverse
     end
  
     def to_s
-      "#<%s %d/%d pos='%s:%s'>" % [:Colorset, @pos, size, at.name, at]
+      "#<%s %d/%d pos='%s/%s/%s'>" % [:Colorset, @pos, size, at.name, at.rgb, at.hsb]
     end
     alias :inspect :to_s
+
+    private
+    def build_colorset(opt)
+      rgb_part = [:red, :green, :blue]
+      hsb_part = [:hue, :sat, :bright]
+
+      order = opt[:order].downcase.intern
+
+      mode =
+        case order
+        when :name then :NAME
+        when :rgb, *rgb_part then :RGB
+        when :hsb, :hsv, *hsb_part then :HSB
+        else
+          raise ArgumentError, "Invalid order option given"
+        end
+
+      colorset = COLORNAMES.map do |name, _|
+                   Colorable::Color.new(name).tap {|c| c.mode = mode }
+                 end
+
+      order_cond =
+        case order
+        when *rgb_part
+          ->color{ color.rgb.move_to_top rgb_part.index(order) }
+        when *hsb_part
+          ->color{ color.hsb.move_to_top hsb_part.index(order) }
+        when :name, :rgb, :hsb, :hsv
+          ->color{ color.send order }
+        end
+
+      case opt[:dir].intern
+      when :+
+        colorset.sort_by(&order_cond)
+      when :-
+        colorset.sort_by(&order_cond).reverse
+      else
+        raise ArgumentError, "Invalid dir option given"
+      end
+    end
+
   end
 end

data/lib/colorable/converter.rb

@@ -1,20 +1,15 @@
 module Colorable
   module Converter
-    class NoNameError < StandardError; end
-  
     def name2rgb(name)
-      COLORNAMES.assoc(name)[1]
-    rescue
-      raise NoNameError, "'#{name}' not exist"
+      COLORNAMES.assoc(name).tap{|c, rgb| break rgb if c }
     end
 
     def rgb2name(rgb)
-      validate_rgb(rgb)
-      COLORNAMES.rassoc(rgb).tap { |c, _| break c if c }
+      COLORNAMES.rassoc(rgb)
+                .tap { |c, _| break c if c }
     end
 
     def rgb2hsb(rgb)
-      validate_rgb(rgb)
       r, g, b = rgb.map(&:to_f)
       hue = Math.atan2(Math.sqrt(3)*(g-b), 2*r-g-b).to_degree
 
@@ -28,7 +23,6 @@ module Colorable
 
     class NotImplemented < StandardError; end
     def rgb2hsl(rgb)
-      validate_rgb(rgb)
       raise NotImplemented, 'Not Implemented Yet'
       r, g, b = rgb.map(&:to_f)
       hue = Math.atan2(Math.sqrt(3)*(g-b), 2*r-g-b).to_degree
@@ -41,7 +35,6 @@ module Colorable
     end
 
     def hsb2rgb(hsb)
-      validate_hsb(hsb)
       hue, sat, bright = hsb
       norm = ->range{ hue.norm(range, 0..255) }
       rgb_h =
@@ -51,7 +44,7 @@ module Colorable
         when 120..180 then [0, 255, norm[120..180]]
         when 180..240 then [0, 255-norm[180..240], 255]
         when 240..300 then [norm[240..300], 0, 255]
-        when 300..360 then [255, 0, 255-norm[300.360]]
+        when 300..360 then [255, 0, 255-norm[300..360]]
         end
       rgb_s = rgb_h.map { |val| val + (255-val) * (1-sat/100.0) }
       rgb_s.map { |val| (val * bright/100.0).round }
@@ -59,7 +52,6 @@ module Colorable
     alias :hsv2rgb :hsb2rgb
 
     def rgb2hex(rgb)
-      validate_rgb(rgb)
       hex = rgb.map do |val|
         val.to_s(16).tap { |h| break "0#{h}" if h.size==1 }
       end
@@ -67,35 +59,8 @@ module Colorable
     end
 
     def hex2rgb(hex)
-      validate_hex(hex)
       _, *hex = hex.unpack('A1A2A2A2')
       hex.map { |val| val.to_i(16) }
     end
-  
-    private
-    def validate_rgb(rgb)
-      if rgb.all? { |val| val.between?(0, 255) }
-        rgb
-      else
-        raise ArgumentError, "'#{rgb}' is invalid for a RGB value"
-      end
-    end
-
-    def validate_hsb(hsb)
-      h, *sb = hsb
-      if h.between?(0, 360) && sb.all? { |val| val.between?(0, 100) } 
-        hsb
-      else
-        raise ArgumentError, "'#{hsb}' is invalid for a HSB value"
-      end
-    end
-  
-    def validate_hex(hex)
-      if hex.match(/^#[0-9A-F]{6}$/i)
-        hex.upcase
-      else
-        raise ArgumentError, "'#{hex}' is invalid for a HEX value"
-      end
-    end
   end
 end

data/lib/colorable/system_extension.rb

@@ -16,9 +16,11 @@ class Array
   def same?(&blk)
     self.uniq(&blk).size==1
   end
+end
 
-  def move_to_top(idx)
-    arr = self.dup
-    arr.insert 0, arr.delete_at(idx)
-  end
+class Pattern < Array
+  def ===(other)
+    zip(other).all? { |a, b| a === b }
+  end      
 end
+

data/lib/colorable/version.rb

@@ -1,3 +1,3 @@
 module Colorable
-  VERSION = "0.0.8"
+  VERSION = "0.1.0"
 end

data/spec/color_space_spec.rb

@@ -0,0 +1,356 @@
+require_relative 'spec_helper'
+
+include Colorable
+describe RGB do
+  describe ".new" do
+    context "without arguments" do
+      subject { RGB.new }
+      its(:to_a) { should eql [0, 0, 0] }
+      its(:rgb) { should eql [0, 0, 0] }
+      its(:red) { should eql 0 }
+      its(:green) { should eql 0 }
+      its(:blue) { should eql 0 }
+    end
+
+    context "with arguments" do
+      subject { RGB.new 100, 255, 255 }
+      its(:to_a) { should eql [100, 255, 255] }
+      its(:rgb) { should eql [100, 255, 255] }
+      its(:red) { should eql 100 }
+      its(:green) { should eql 255 }
+      its(:blue) { should eql 255 }
+    end
+
+    context "pass out of RGB range" do
+      it "raise ArgumentError" do
+        expect { RGB.new(0, 0, 256) }.to raise_error ArgumentError
+        expect { RGB.new(-10, 0, 255) }.to raise_error ArgumentError
+        expect { RGB.new(256, 256, 256) }.to raise_error ArgumentError
+      end
+    end
+  end
+
+  describe "#+" do
+    context "pass an array of numbers" do
+      before(:all) { @rgb = RGB.new(100, 100, 100) }
+      subject { @rgb + [0, 50, 100] }
+      its(:rgb) { should eql [100, 150, 200] }
+      it "keep original same" do @rgb.rgb.should eql [100, 100, 100] end
+    end
+
+    context "when '+' makes out of RGB range or rack of numbers" do
+      it "raise ArgumentError" do
+        expect { RGB.new(100, 100, 100) + [0, 50, 200] }.to raise_error ArgumentError
+        expect { RGB.new(100, 100, 100) + [0, -150, 0] }.to raise_error ArgumentError
+        expect { RGB.new(100, 100, 100) + [0, 150] }.to raise_error ArgumentError
+      end
+    end
+
+    context "pass a Fixnum" do
+      before(:all) { @rgb = RGB.new(100, 100, 100) }
+      it { (@rgb + 50).rgb.should eql [150, 150, 150] }
+      it "raise ArgumentError" do
+        expect { @rgb + 160 }.to raise_error ArgumentError
+      end
+    end
+
+    context "coerce make Fixnum#+ accept rgb object" do
+      it { (10 + RGB.new(100, 100, 100)).rgb.should eql [110, 110, 110] }
+    end
+  end
+
+  describe "#-" do
+    context "pass an array of numbers" do
+      before(:all) { @rgb = RGB.new(100, 100, 100) }
+      subject { @rgb - [0, 50, 100] }
+      its(:rgb) { should eql [100, 50, 0] }
+      it "keep original same" do @rgb.rgb.should eql [100, 100, 100] end
+    end
+
+    context "when '-' makes out of RGB range" do
+      it "raise ArgumentError" do
+        expect { RGB.new(100, 100, 100) - [0, 50, 200] }.to raise_error ArgumentError
+        expect { RGB.new(100, 100, 100) - [0, -250, 0] }.to raise_error ArgumentError
+      end
+    end
+
+    context "pass a Fixnum" do
+      before(:all) { @rgb = RGB.new(100, 100, 100) }
+      it { (@rgb - 50).rgb.should eql [50, 50, 50] }
+      it "raise ArgumentError" do
+        expect { @rgb - 160 }.to raise_error ArgumentError
+      end
+    end
+  end
+
+  describe "#to_s" do
+    it { RGB.new(0, 50, 100).to_s.should eql "rgb(0,50,100)"}
+  end
+
+  describe "#to_name" do
+    it { RGB.new(240, 248, 255).to_name.should eql 'Alice Blue' }
+  end
+
+  describe "#to_hsb" do
+    it { RGB.new(240, 248, 255).to_hsb.should eql [208, 6, 100] }
+  end
+
+  describe "#to_hex" do
+    it { RGB.new(240, 248, 255).to_hex.should eql '#F0F8FF' }
+  end
+end
+
+describe HSB do
+  describe ".new" do
+    context "without arguments" do
+      subject { HSB.new }
+      its(:to_a) { should eql [0, 0, 0] }
+      its(:hsb) { should eql [0, 0, 0] }
+      its(:hue) { should eql 0 }
+      its(:sat) { should eql 0 }
+      its(:bright) { should eql 0 }
+    end
+
+    context "with arguments" do
+      subject { HSB.new 300, 70, 90 }
+      its(:to_a) { should eql [300, 70, 90] }
+      its(:hsb) { should eql [300, 70, 90] }
+      its(:hue) { should eql 300 }
+      its(:sat) { should eql 70 }
+      its(:bright) { should eql 90 }
+    end
+
+    context "pass out of HSB range" do
+      it "raise ArgumentError" do
+        expect { HSB.new(0, 0, 120) }.to raise_error ArgumentError
+        expect { HSB.new(360, 0, 80) }.to raise_error ArgumentError
+        expect { HSB.new(0, -10, 0) }.to raise_error ArgumentError
+      end
+    end
+  end
+
+  describe "#+" do
+    context "pass an array of numbers" do
+      before(:all) { @hsb = HSB.new(300, 70, 90) }
+      subject { @hsb + [0, 5, 10] }
+      its(:hsb) { should eql [300, 75, 100] }
+      it "keep original same" do @hsb.hsb.should eql [300, 70, 90] end
+    end
+
+    context "when '+' makes out of HSB range or rack of numbers" do
+      it "raise ArgumentError" do
+        expect { HSB.new(300, 70, 90) + [0, 50, 0] }.to raise_error ArgumentError
+        expect { HSB.new(300, 70, 90) + [0, 0, -100] }.to raise_error ArgumentError
+        expect { HSB.new(300, 70, 90) + [0, 5] }.to raise_error ArgumentError
+        expect { HSB.new(300, 70, 90) + 5 }.to raise_error ArgumentError
+      end
+    end
+  end
+
+  describe "#-" do
+    context "pass an array of numbers" do
+      before(:all) { @hsb = HSB.new(300, 70, 90) }
+      subject { @hsb - [0, 5, 10] }
+      its(:hsb) { should eql [300, 65, 80] }
+      it "keep original same" do @hsb.hsb.should eql [300, 70, 90] end
+    end
+
+    context "when '-' makes out of HSB range" do
+      it "raise ArgumentError" do
+        expect { HSB.new(300, 7, 90) - [305, 0, 10] }.to raise_error ArgumentError
+        expect { HSB.new(300, 70, 90) - [0, -35, 0] }.to raise_error ArgumentError
+      end
+    end
+  end
+
+  describe "#to_s" do
+    it { HSB.new(0, 50, 100).to_s.should eql "hsb(0,50,100)"}
+  end
+
+  describe "#to_name" do
+    it { HSB.new(208, 6, 100).to_name.should eql 'Alice Blue' }
+  end
+
+  describe "#to_rgb" do
+    it { HSB.new(208, 6, 100).to_rgb.should eql [240, 248, 255] }
+  end
+
+  describe "#to_hex" do
+    it { HSB.new(208, 6, 100).to_hex.should eql '#F0F8FF' }
+  end
+end
+
+describe NAME do
+  describe ".new" do
+    context "with valid name" do
+      subject { NAME.new :alice_blue } 
+      its(:to_s) { should eql 'Alice Blue' }
+      its(:name) { should eql 'Alice Blue' }
+      its(:sym) { should eql :alice_blue }
+    end
+
+    context "with invalid name" do
+      it "raise ArgumentError" do
+        expect { NAME.new :abc_color }.to raise_error ArgumentError
+      end
+    end
+  end
+
+  describe "dark?" do
+    it { NAME.new(:navy).dark?.should be_true }
+    it { NAME.new(:alice_blue).dark?.should be_false }
+  end
+
+  describe "#+" do
+    context "pass an irregal argument" do
+      it "raise ArgumentError" do
+        expect { NAME.new(:alice_blue) + [0, 150, 100] }.to raise_error ArgumentError
+      end
+    end
+
+    context "pass a Fixnum" do
+      before(:all) { @name = NAME.new(:alice_blue) }
+      it { (@name + 1).name.should eql 'Antique White' }
+      it { (@name + 2).name.should eql 'Aqua' }
+    end
+
+    context "coerce make Fixnum#+ accept name object" do
+      it { (1 + NAME.new(:alice_blue)).to_s.should eql 'Antique White' }
+    end
+  end
+
+  describe "#-" do
+    context "pass an irregal argument" do
+      it "raise ArgumentError" do
+        expect { NAME.new(:alice_blue) - [0, 150, 100] }.to raise_error ArgumentError
+      end
+    end
+
+    context "pass a Fixnum" do
+      before(:all) { @name = NAME.new(:alice_blue) }
+      it { (@name - 1).name.should eql 'Yellow Green' }
+      it { (@name - 2).name.should eql 'Yellow' }
+    end
+
+    context "coerce make Fixnum#+ accept name object" do
+      it { (1 - NAME.new(:alice_blue)).to_s.should eql 'Yellow Green' }
+    end
+  end
+
+  describe "#to_rgb" do
+    it { NAME.new('Alice Blue').to_rgb.should eql [240, 248, 255] }
+  end
+
+  describe "#to_hsb" do
+    it { NAME.new('Alice Blue').to_hsb.should eql [208, 6, 100] }
+  end
+
+  describe "#to_hex" do
+    it { NAME.new('Alice Blue').to_hex.should eql '#F0F8FF' }
+  end
+end
+
+describe HEX do
+  describe ".new" do
+    context "without arguments" do
+      subject { HEX.new }
+      its(:to_s) { should eql '#FFFFFF' }
+      its(:hex) { should eql '#FFFFFF' }
+      its(:to_a) { should eql ['FF', 'FF', 'FF'] }
+    end
+
+    context "with arguments" do
+      it { HEX.new('#FFFF00').to_s.should eql '#FFFF00' }
+      it { HEX.new('#ffff00').to_s.should eql '#FFFF00' }
+      it { HEX.new('FFFF00').to_s.should eql '#FFFF00' }
+      it { HEX.new('#ff0').to_s.should eql '#FFFF00' }
+      it { HEX.new(['FF', 'FF', '00']).to_s.should eql '#FFFF00' }
+    end
+
+    context "pass out of HEX range" do
+      it "raise ArgumentError" do
+        expect { HEX.new('#FFGG00') }.to raise_error ArgumentError
+        expect { HEX.new('aaxxxx') }.to raise_error ArgumentError
+        expect { HEX.new(['FF', 'FF', 00]) }.to raise_error ArgumentError
+      end
+    end
+  end
+
+  describe "#+" do
+    context "pass a HEX string" do
+      before(:all) { @hex = HEX.new('#FF0000') }
+      it { (@hex + '#00FFCC').hex.should eql '#FFFFCC'}
+      it { (@hex + '#00ffcc').hex.should eql '#FFFFCC'}
+      it { (@hex + '00FFCC').hex.should eql '#FFFFCC'}
+      it { (@hex + '#0FC').hex.should eql '#FFFFCC'}
+      it "keep original" do @hex.hex.should eql '#FF0000' end
+    end
+
+    context "out of HEX range" do
+      it "raise ArgumentError" do
+        expect { HEX.new('#FF0000') + '#010000' }.to raise_error ArgumentError
+        expect { HEX.new('#FF0000') + '#00ffgg' }.to raise_error ArgumentError
+        expect { HEX.new('#000000') + [0, 50, 100] }.to raise_error ArgumentError
+      end
+    end
+
+    context "pass a Fixnum" do
+      before(:all) { @hex = HEX.new('#000000') }
+      it { (@hex + 255).hex.should eql '#FFFFFF' }
+      it "raise ArgumentError" do
+        expect { @hex + 260 }.to raise_error ArgumentError
+      end
+    end
+
+    context "coerce make Fixnum#+ accept hex object" do
+      it { (255 + HEX.new('#000000')).hex.should eql '#FFFFFF' }
+    end
+  end
+
+  describe "#-" do
+    context "pass a HEX string" do
+      before(:all) { @hex = HEX.new('#00FFFF') }
+      it { (@hex - '#00FFCC').hex.should eql '#000033'}
+      it { (@hex - '#00ffcc').hex.should eql '#000033'}
+      it { (@hex - '00FFCC').hex.should eql '#000033'}
+      it { (@hex - '#0FC').hex.should eql '#000033'}
+      it "keep original" do @hex.hex.should eql '#00FFFF' end
+    end
+
+    context "out of HEX range" do
+      it "raise ArgumentError" do
+        expect { HEX.new('#FF0000') - '#000100' }.to raise_error ArgumentError
+        expect { HEX.new('#FF0000') - '#0000cc' }.to raise_error ArgumentError
+        expect { HEX.new('#000000') - [0, 50, 100] }.to raise_error ArgumentError
+      end
+    end
+
+    context "pass a Fixnum" do
+      before(:all) { @hex = HEX.new('#FFFFFF') }
+      it { (@hex - 255).hex.should eql '#000000' }
+      it "raise ArgumentError" do
+        expect { @hex + 260 }.to raise_error ArgumentError
+      end
+    end
+
+    context "coerce make Fixnum#+ accept hex object" do
+      it { (255 - HEX.new('#FFFFFF')).hex.should eql '#000000' }
+    end
+  end
+
+  describe "#to_s" do
+    it { HEX.new('#F0F8FF').to_s.should eql '#F0F8FF' }
+  end
+
+  describe "#to_rgb" do
+    it { HEX.new('#F0F8FF').to_rgb.should eql [240, 248, 255] }
+  end
+
+  describe "#to_hsb" do
+    it { HEX.new('#F0F8FF').to_hsb.should eql [208, 6, 100] }
+  end
+
+  describe "#to_name" do
+    it { HEX.new('#F0F8FF').to_name.should eql 'Alice Blue' }
+  end
+end