colorable 0.0.8 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cd1ee00539ef3544f0938729f93a1abc32c3b3ec
-  data.tar.gz: 72879c844b5456ad6908cf0875cc5468f553b0ea
+  metadata.gz: b79f5456ff48188f4232decead4443e0c511ba3f
+  data.tar.gz: cf8e2236927be3b23baaec50d220d112190076b5
 SHA512:
-  metadata.gz: a04a172d115e8c82c5f0d6746bebebd90670e74ac8a7a97bf8369c961a37de9e2825ef7ba6f57199862ef0253910af6d79d20ff20ef7bdc8ed925c7296d2694a
-  data.tar.gz: fe15f0a313eea761fbd741398159dad8d8aaa26d4f56f74b9ff1ff45a48cfaa571537578b4ccb95db1f02a88919b10ab91ea52ef8f10a3f79e8d4f25eb83a6a2
+  metadata.gz: a7fc1f13cefb37d408c10491150020f788445693855b9a07d39c3653298d739f5f4b3f4de4f8d7e3fe5e2db58f0d3976d0982a167b330c54558c9abb768bc87d
+  data.tar.gz: 66a27bbed8977cd6b543b86eb947a7fa5b9ece0fa5a40d1d7e0e7d110ac26b2472f3b69348bb9a83e7b7c69651459512a91c856c7e7b84fc91dfdda5280f6368

data/README.md

@@ -1,6 +1,7 @@
 # Colorable
 
-A simple color handler which provide a conversion between colorname, RGB, HSB and HEX. It also provides a colorset which can be sorted by above color units.
+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.
 
 ## Installation
 
@@ -21,33 +22,103 @@ Or install it yourself as:
 Create a color object:
 
     require "colorable"
+    include Colorable
 
-    # Accept X11 color names
-    c = Colorable::Color.new(:green) #=> #<Colorable::Color:0x007fa449954ee0 @name="Green", @rgb=[0, 255, 0], @hex=nil, @hsb=nil, @esc=nil>
-    c.name #=> "Green"
-    c.hsb #=> [120, 100, 100]
-    c.hex #=> "#00FF00"
-    c.to_s #=> "rgb(0,255,0)"
-
-    # or RGB
-    c2 = Colorable::Color.new([240, 248, 255]) #=> #<Colorable::Color:0x007fa449a69c90 @name="Alice Blue", @rgb=[240, 248, 255], @hex=nil, @hsb=nil, @esc=nil>
-    c2.name #=> "Alice Blue"
-    c2.rgb #=> [240, 248, 255]
-    c2.hsb #=> [208, 6, 100]
-    c2.hex #=> "#F0F8FF"
-    c2.to_s #=> "rgb(240,248,255)"
-
-Create a colorset object:
-
-    # Default colorset sequence is by its color name order.
-    cs = Colorable::Colorset.new #=> #<Colorset 0/144 pos='Alice Blue:rgb(240,248,255)'>
-    cs.at #=> #<Colorable::Color:0x007fa448beb2b8 @name="Alice Blue", @rgb=[240, 248, 255], @hex=nil, @hsb=nil, @esc=nil>
-    10.times.map { cs.next.name } #=> ["Antique White", "Aqua", "Aquamarine", "Azure", "Beige", "Bisque", "Black", "Blanched Almond", "Blue", "Blue Violet"]
-
-    # Using Colorset#[], the order of the sequence is specified.
-    cs2 = Colorable::Colorset[:hsb] #=> #<Colorset 0/144 pos='Black:rgb(0,0,0)'>
-    cs2.at #=> #<Colorable::Color:0x007fa448a913e0 @name="Black", @rgb=[0, 0, 0], @hex=nil, @hsb=[0, 0, 0], @esc=nil>
-    10.times.map { cs2.next.hsb } #=> [[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], [0, 2, 100]]
+    # 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"
+
+    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)"
+
+
+Create a X11 colorset object:
+
+    include Colorable
+
+    cs = Colorset.new #=> #<Colorset 0/144 pos='Alice Blue/rgb(240,248,255)/hsb(208,6,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"
+
+    # 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.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).map(&:to_s).take(10) #=> ["Black", "Dim Gray", "Gray2", "Dark Gray", "Gray", "Silver", "Light Gray", "Gainsboro", "White Smoke", "White"]
 
 
 ## Contributing

data/lib/colorable.rb

@@ -1,5 +1,5 @@
 require "colorable/version"
-%w(system_extension converter color colorset).each { |lib| require_relative "colorable/" + lib }
+%w(system_extension converter color colorset color_space).each { |lib| require_relative "colorable/" + lib }
 
 module Colorable
 

data/lib/colorable/color.rb

@@ -1,71 +1,161 @@
 module Colorable
   class Color
-    class ColorNameError < StandardError; end
-    include Colorable::Converter
+    class NameError < StandardError; end
     include Comparable
     attr_reader :name, :rgb
 
-    def initialize(name_or_rgb)
-      @name, @rgb, @hex, @hsb, @esc = nil
-      case name_or_rgb
-      when String, Symbol
-        @name = varidate_name(name_or_rgb)
-        @rgb = name2rgb(@name)
-      when Array
-        @rgb = validate_rgb(name_or_rgb)
-        @name = rgb2name(@rgb)
-      else
-        raise ArgumentError, "'#{name_or_rgb}' is wrong argument. Only colorname and RGB value are acceptable"
-      end
+    # Create a Color object which has several representations of a color.
+    #
+    # +arg+ can be:
+    #   String or Symbol of color name
+    #   String of HEX color
+    #   Array of RGB values
+    #   NAME, RGB, HSB, HEX objects
+    #
+    # Color object has output mode, which is determined by +arg+ type.
+    def initialize(arg)
+      @name, @rgb, @hsb, @hex, @mode = set_variables(arg)
+    end
+
+    # Returns a current output mode
+    def mode
+      "#{@mode.class}"[/\w+$/].intern
+    end
+
+    # Set output mode.
+    def mode=(mode)
+      modes = [rgb, hsb, name, hex]
+      @mode = modes.detect { |m| m.class.to_s.match /#{mode}/i } || begin
+                raise ArgumentError, "Invalid mode given"
+              end
     end
 
     def to_s
-      "rgb(%i,%i,%i)" % rgb
+      @mode.to_s
+    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?
+      }
     end
 
     def hex
-      @hex ||= rgb2hex(rgb)
+      @hex ||= HEX.new rgb.to_hex
     end
 
     def hsb
-      @hsb ||= rgb2hsb(rgb)
+      @hsb ||= HSB.new *rgb.to_hsb
     end
     alias :hsv :hsb
 
-    %w(red green blue).each_with_index do |c, i|
-      define_method(c) { rgb[i] }
+    %w(red green blue).each do |c|
+      define_method(c) { rgb.send c }
     end
 
-    %w(hue sat bright).each_with_index do |n, i|
-      define_method(n) { hsb[i] }
+    %w(hue sat bright).each do |c|
+      define_method(c) { hsb.send c }
     end
 
     def <=>(other)
-      self.name <=> other.name
+      self.rgb <=> other.rgb
     end
 
     @@colorset = {}
-    def next(set=:name, n=1)
-      @@colorset[set] ||= Colorable::Colorset[set]
-      idx = @@colorset[set].find_index(self)
-      @@colorset[set].at(idx+n) if idx
+    # Returns a next color object in X11 colors.
+    # The color sequence is determined by its color mode.
+    def next(n=1)
+      @@colorset[mode] ||= Colorable::Colorset.new(order: mode)
+      idx = @@colorset[mode].find_index(self)
+      @@colorset[mode].at(idx+n).tap{|c| c.mode = mode } if idx
     end
 
-    def prev(set=:name, n=1)
-      self.next(set, -n)
+    # Returns a previous color object in X11 colors.
+    # The color sequence is determined by its color mode.
+    def prev(n=1)
+      self.next(-n)
     end
 
     def dark?
-      DARK_COLORS.detect { |d| d == self.name }
+      !!DARK_COLORS.detect { |d| d == name.to_s }
+    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
+    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
     end
 
     private
-    def varidate_name(name)
-      COLORNAMES.detect do |label, _|
-        [label, name].same? { |str| "#{str}".gsub(/[_\s]/,'').downcase }
-      end.tap do |res, _|
-        raise ColorNameError, "'#{name}' is not a valid colorname" unless res
-        break res
+    def set_variables(arg)
+      case arg
+      when String, Symbol
+        begin
+          hex = HEX.new(arg)
+          name = NAME.new(hex.to_name) rescue nil
+          rgb = RGB.new *hex.to_rgb
+          hsb = nil
+          mode = hex
+        rescue ArgumentError
+          name = validate_name(arg)
+          rgb = RGB.new *name.to_rgb
+          hsb = nil
+          hex = nil
+          mode = name
+        end
+      when Array
+        rgb = RGB.new *arg
+        name = NAME.new(rgb.to_name) rescue nil
+        hsb = nil
+        hex = nil
+        mode = rgb
+      when RGB
+        rgb = arg
+        name = NAME.new(rgb.to_name) rescue nil
+        hsb = nil
+        hex = nil
+        mode = rgb
+      when HSB
+        hsb = arg
+        rgb = RGB.new *hsb.to_rgb
+        name = NAME.new(rgb.to_name) rescue nil
+        hex = nil
+        mode = hsb
+      when NAME
+        name = arg
+        rgb = RGB.new *name.to_rgb
+        hsb = nil
+        hex = nil
+        mode = name
+      when HEX
+        hex = arg
+        name = NAME.new(hex.to_name) rescue nil
+        rgb = RGB.new *hex.to_rgb
+        hsb = nil
+        mode = hex
+      else
+        raise ArgumentError
+      end
+      return name, rgb, hsb, hex, mode
+    end
+
+    def validate_name(name)
+      NAME.new(name).tap do |res|
+        raise NameError, "Invalid color name given" unless res.name
       end
     end
   end

data/lib/colorable/color_space.rb

@@ -0,0 +1,260 @@
+module Colorable
+	class ColorSpace
+    include Colorable::Converter
+		include Comparable
+
+		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 +(arg)
+	  	raise "Subclass must implement it"
+	  end
+
+		def -(arg)
+			arg = arg.is_a?(Fixnum) ? -arg : arg.map(&:-@)
+			self + arg
+		end
+
+		def coerce(arg)
+			[self, arg]
+		end
+
+		def to_s
+			name = "#{self.class}"[/\w+$/].downcase
+      "#{name}(%i,%i,%i)" % to_a
+		end
+
+		private
+    def validate(pattern, data)
+      case Array(data)
+      when Pattern[*Array(pattern)] then data
+      else
+        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
+    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 validate_hsb(hsb)
+      validate([0..359, 0..100, 0..100], hsb)
+    end
+	end
+
+	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 +(arg)
+			build_hex_with(:+, arg)
+		end
+
+		def -(arg)
+			build_hex_with(:-, arg)
+		end
+
+		def to_rgb
+			hex2rgb(self.to_s)
+		end
+
+		def to_hsb
+			rgb2hsb(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)
+      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}"
+    end
+
+    def rgb2hex(rgb)
+      hex = rgb.map do |val|
+        val.to_s(16).tap { |h| break "0#{h}" if h.size==1 }
+      end
+      '#' + hex.join.upcase
+    end
+
+    def hex2rgb(hex)
+      _, *hex = hex.unpack('A1A2A2A2')
+      hex.map { |val| val.to_i(16) }
+    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
+			@name.gsub(/\s/, '_').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|
+        [c, name].same? { |str| "#{str}".gsub(/[_\s]/,'').downcase }
+			} || begin
+				raise ArgumentError, "'#{name}' is not in X11 colorset."
+			end
+		end	
+	end
+end