simplecolor 0.2.0 → 0.3.0

data/lib/simplecolor/colorer.rb

@@ -0,0 +1,228 @@
+module SimpleColor
+	ColorerError=Class.new(SimpleColorError)
+	WrongColor=Class.new(ColorerError)
+	WrongParameter=Class.new(ColorerError)
+
+	# The Colorer module handle all color outputs
+	module Colorer
+		extend self
+		def colors
+			COLORS
+		end
+		# A color name can be:
+		# - an array of rgb data (truecolor)
+		#		(start with :on to specify background)
+		# - a String:
+		#			rgb:10-20-30 (foreground truecolor)
+		#			on_rgb:10-20-30 (background truecolor)
+		#			t:rgb... (don't fallback to lower color mode)
+		#			(on_)rgb256:r:g:b  (force 256 color mode)
+		#			(on_)rgb256:grey3 (256 grey scale)
+		#			(on_)rgb256:5 (direct color code)
+		#			(t:)(on_)#AABBCC (hex code, truecolor)
+		#			(t:)(on_)#ABC (reduced hex code, truecolor)
+		#			(t:)(on_)name (X11 color name, truecolor)
+		# A color attribute can be:
+		# - a symbol (looked in at COLORS)
+		# - an integer (direct color code)
+		# - a color escape sequence
+		# - a String
+		def color_attributes(*args, mode: :text, color_mode: :truecolor, abbreviations: {}, rgb_class: RGB, **rgb_parse_opts)
+			return "" if mode==:disabled or mode==false #early abort
+			abbreviations={} if abbreviations.nil?
+			colors=self.colors
+			accu=[]
+			buffer=""
+			flush=lambda {r=accu.join(";"); accu=[]; r.empty? || r="\e["+r+"m"; buffer<<r} #Note: "\e"="\x1b"
+
+			parse_rgb=lambda do |s|
+				symbol=s.is_a?(Symbol)
+				truecol=/(?<truecol>(?:truecolor|true|t):)?/
+				on=/(?<on>on_)?/
+				s.match(/\A#{truecol}#{on}(?<rest>.*)\z/) do |m|
+					tcol=m[:truecol]; on=m[:on]; string=m[:rest]
+					lcolormode = tcol ? :truecolor : color_mode
+					string=string.to_sym if symbol
+					accu << rgb_class.parse(string, **rgb_parse_opts).ansi(background: !!on, convert: lcolormode)
+				end
+			end
+
+			parse=lambda do |*cols, abbrevs: abbreviations|
+				cols.each do |col|
+					if (scol=abbrevs[col])
+						# Array are special, in a non abbreviation they mean an rgb mode but for abbreviations it just combine several color attributes
+						parse.call(*scol, abbrevs: {}) #we erase abbreviations so :red = :red do not get an infinite loop
+						next
+					end
+					case col
+					when Proc
+						scol=col.call(buffer, accu)
+						parse.call(*scol)
+					when Symbol
+						if colors.key?(col) #ANSI effects
+							accu << colors[col]
+						else
+							parse_rgb.call(col)
+						end
+					when Integer #direct ansi code
+						accu << col.to_s
+					when Array
+						background=false
+						if col.first == :on
+							background=true; col.shift
+						end
+						accu << rgb_class.new(col).ansi(convert: color_mode, background: background)
+					when rgb_class
+						accu << col.ansi(convert: color_mode)
+					when COLOR_REGEXP
+						flush.call
+						buffer<<col
+					when String
+						parse_rgb.call(col)
+					when nil # skip
+					else
+						raise WrongColor.new(col)
+					end
+				end
+			end
+
+			parse.call(*args)
+			flush.call
+
+			case mode
+			when :shell
+				"%{"+buffer+"%}"
+			when :disabled
+				"" # already handled above
+			when :text, :enabled, true
+				buffer
+			else
+				raise WrongParameter.new(mode)
+			end
+		end
+
+		def regexp(type=:color, mode: :text, **_rest)
+			case type
+			when :color
+				if mode == :shell
+					m=regexp(:ansi, mode: mode)
+					/#{m}+/
+				else
+					COLOR_REGEXP
+				end
+			when :match
+				if mode == :shell
+					m=regexp(:ansi, mode: mode)
+					/#{m}*/
+				else
+					COLORMATCH_REGEXP
+				end
+			when :ansi
+				if mode == :shell
+					/%{#{ANSICOLOR_REGEXP}%}/
+				else
+					ANSICOLOR_REGEXP
+				end
+			when :clear
+				if mode == :shell
+					/%{#{CLEAR_REGEXP}%}/
+				else
+					CLEAR_REGEXP
+				end
+			end
+		end
+
+		# Returns a colored version of the string (modified in place),
+		# according to attributes
+		def colorer(s, *attributes, global_color: :after, local_color: :before, **kwds)
+			if s.nil?
+				color_attributes(*attributes,**kwds)
+			elsif s.empty?
+				# We don't color an empty string; use nil to get color attributes
+				s
+			else
+				match_reg=regexp(:match, **kwds)
+				color_reg=regexp(:color, **kwds)
+				clear_reg=regexp(:clear, **kwds)
+				colors=color_attributes(*attributes,**kwds)
+				clear=color_attributes(:clear,**kwds)
+
+				split=SimpleColor.color_strings(s, color_regexp: color_reg)
+				sp, i=split.each_with_index.find do |sp, i|
+					i>=1 && sp.match(/#{color_reg}/)
+				end
+				global=true unless sp and (i<split.length-1 || !sp.match(/#{clear_reg}$/))
+
+				if global
+					case global_color
+					when :keep
+					matched = s.match(match_reg)
+						s.insert(0, colors) unless matched.end(0)>0
+					when :before
+						s.insert(0, colors)
+					when :after
+						# we need to insert the ANSI sequences after existing ones so that
+						# the new colors have precedence
+						matched = s.match(match_reg) #since this has a '*' it matches at the beginning
+						s.insert(matched.end(0), colors)
+					end
+				else
+					pos=0
+					split.each_with_index do |sp,i|
+						if sp.match(/#{clear_reg}$/)
+							#don't reinsert ourselves at end
+							unless i==split.length-1
+								pos+=sp.length
+								s.insert(pos, colors)
+								pos+=colors.length
+							end
+						elsif sp.match(/#{color_reg}/)
+							case local_color
+							when :keep
+								if i!=0
+									# we need to clear ourselves
+									s.insert(pos, clear)
+									pos+=clear.length
+								end
+								pos+=sp.length
+							when :before
+								#we already inserted ourselves except if we are on the
+								#first block
+								if i==0
+									s.insert(pos, colors)
+									pos+=colors.length
+								end
+								pos+=sp.length
+							when :after
+								pos+=sp.length
+								s.insert(pos, colors)
+								pos+=colors.length
+							end
+						else
+							if i==0
+								s.insert(pos, colors)
+								pos+=colors.length
+							end
+							pos+=sp.length
+						end
+					end
+				end
+				s.concat(clear) unless s =~ /#{clear_reg}$/ or colors.empty?
+				s
+			end
+		end
+
+		# Returns an uncolored version of the string, that is all
+		# ANSI-sequences are stripped from the string.
+		# @see: colorer
+		def uncolorer(s, **kwds)
+			s.to_str.gsub!(regexp(:color, **kwds), '') || s.to_str
+		rescue ArgumentError #rescue from "invalid byte sequence in UTF-8"
+			s.to_str
+		end
+
+		def colored?(s, **kwds)
+			!! (s =~ regexp(:color, **kwds))
+		end
+	end
+end

data/lib/simplecolor/colors.rb

@@ -1,109 +1,71 @@
 module SimpleColor
+	module Colorer
 
-  # Regular expression to scan if there is a clear ANSI effect
-  CLEAR_REGEXP = /\e\[0m/
-  # Regular expression that is used to scan for ANSI-sequences
-  ANSICOLOR_REGEXP = /\e\[(?:[\d;]*)m/
-  COLOR_REGEXP = /#{ANSICOLOR_REGEXP}+/
-  COLORMATCH_REGEXP = /#{ANSICOLOR_REGEXP}*/
+		# Regular expression to scan if there is a clear ANSI effect
+		CLEAR = "\e\[0m"
+		CLEAR_REGEXP = /\e\[0m/
+		# Regular expression that is used to scan for ANSI-sequences
+		ANSICOLOR_REGEXP = /\e\[(?:[\d;]*)m/
+		COLOR_REGEXP = /#{ANSICOLOR_REGEXP}+/
+		COLORMATCH_REGEXP = /#{ANSICOLOR_REGEXP}*/
 
-  #Stolen from the paint gem.
-  #See alosa http://en.wikipedia.org/wiki/ANSI_escape_code
+		#Originally stolen from the paint gem.
+		#See also http://en.wikipedia.org/wiki/ANSI_escape_code
 
-  # Basic colors (often, the color differs when using the bright effect)
-  # Final color will be 30 + value for foreground and 40 + value for background
-  # 90+value for intense foreground, 100+value for intense background
-  ANSI_COLORS = {
-    :black   => 0,
-    :red     => 1,
-    :green   => 2,
-    :yellow  => 3,
-    :blue    => 4,
-    :magenta => 5,
-    :cyan    => 6,
-    :white   => 7,
-    :default => 9,
-  }
-  
-  ANSI_EFFECTS = {
-    :reset         => 0,  :nothing         => 0,  # usually supported
-    :clear         => 0,  :normal         => 0,  # usually supported
-    :bright        => 1,  :bold            => 1,  # usually supported
-    :faint         => 2,
-    :italic        => 3,
-    :underline     => 4,                          # usually supported
-    :blink         => 5,  :slow_blink      => 5,
-    :rapid_blink   => 6,
-    :inverse       => 7,  :swap            => 7,  # usually supported
-    :conceal       => 8,  :hide            => 9,
-    :default_font  => 10,
-    :font0 => 10, :font1 => 11, :font2 => 12, :font3 => 13, :font4 => 14,
-    :font5 => 15, :font6 => 16, :font7 => 17, :font8 => 18, :font9 => 19,
-    :fraktur       => 20,
-    :bright_off    => 21, :bold_off        => 21, :double_underline => 21,
-    :clean         => 22,
-    :italic_off    => 23, :fraktur_off     => 23,
-    :underline_off => 24,
-    :blink_off     => 25,
-    :inverse_off   => 26, :positive        => 26,
-    :conceal_off   => 27, :show            => 27, :reveal           => 27,
-    :crossed_off   => 29, :crossed_out_off => 29,
-    :frame         => 51,
-    :encircle      => 52,
-    :overline      => 53,
-    :frame_off     => 54, :encircle_off    => 54,
-    :overline_off  => 55,
-  }
+		# Basic colors (often, the color differs when using the bright effect)
+		# Final color will be 30 + value for foreground and 40 + value for background
+		# 90+value for intense foreground, 100+value for intense background
+		ANSI_COLORS = {
+			:black	 => 0,
+			:red		 => 1,
+			:green	 => 2,
+			:yellow  => 3,
+			:blue		 => 4,
+			:magenta => 5,
+			:cyan		 => 6,
+			:white	 => 7,
+			:default => 9,
+		}
 
-  ANSI_COLORS_FOREGROUND = {
-    :black   => 30,
-    :red     => 31,
-    :green   => 32,
-    :yellow  => 33,
-    :blue    => 34,
-    :magenta => 35,
-    :cyan    => 36,
-    :white   => 37,
-    :default => 39,
-  }
+		ANSI_COLORS_FOREGROUND = Hash[ANSI_COLORS.map {|k,v| [k, 30+v]}]
+		ANSI_COLORS_BACKGROUND = Hash[ANSI_COLORS.map {|k,v| [:"on_#{k}", 40+v]}]
+		# aixterm (not standard)
+		ANSI_COLORS_INTENSE_FOREGROUND = Hash[ANSI_COLORS.map {|k,v| [:"intense_#{k}", 90+v]}]
+		ANSI_COLORS_INTENSE_BACKGROUND = Hash[ANSI_COLORS.map {|k,v| [:"on_intense_#{k}", 100+v]}]
 
-  ANSI_COLORS_BACKGROUND = {
-    :on_black   => 40,
-    :on_red     => 41,
-    :on_green   => 42,
-    :on_yellow  => 43,
-    :on_blue    => 44,
-    :on_magenta => 45,
-    :on_cyan    => 46,
-    :on_white   => 47,
-    :on_default => 49,
-  }
-
-  ANSI_COLORS_INTENSE_FOREGROUND = {
-    :intense_black   => 90,
-    :intense_red     => 91,
-    :intense_green   => 92,
-    :intense_yellow  => 93,
-    :intense_blue    => 94,
-    :intense_magenta => 95,
-    :intense_cyan    => 96,
-    :intense_white   => 97,
-    :intense_default => 99,
-  }
-
-  ANSI_COLORS_INTENSE_BACKGROUND = {
-    :on_intense_black   => 100,
-    :on_intense_red     => 101,
-    :on_intense_green   => 102,
-    :on_intense_yellow  => 103,
-    :on_intense_blue    => 104,
-    :on_intense_magenta => 105,
-    :on_intense_cyan    => 106,
-    :on_intense_white   => 107,
-    :on_intense_default => 109,
-  }
-
-  #attributes that can be specified to the color method
-  COLORS = [ANSI_EFFECTS,ANSI_COLORS_FOREGROUND, ANSI_COLORS_BACKGROUND, ANSI_COLORS_INTENSE_FOREGROUND, ANSI_COLORS_INTENSE_BACKGROUND].inject({}){ |a,b| a.merge(b) }
+		ANSI_EFFECTS = {
+			:reset				 => 0,	:nothing				 => 0,	# usually supported
+			:clear				 => 0,	:normal					=> 0,  # usually supported
+			:bright				 => 1,	:bold						 => 1,	# usually supported
+			:faint				 => 2,
+			:italic				 => 3,
+			:underline		 => 4,													# usually supported
+			:blink				 => 5,	:slow_blink			 => 5,
+			:rapid_blink	 => 6,
+			:inverse       => 7, :reverse => 7, :swap => 7, # usually supported
+			:conceal			 => 8,	:hide						 => 8,
+			:crossed => 9, :crossed_out => 9,
+			:default_font  => 10,
+			:font0 => 10, :font1 => 11, :font2 => 12, :font3 => 13, :font4 => 14,
+			:font5 => 15, :font6 => 16, :font7 => 17, :font8 => 18, :font9 => 19,
+			:fraktur			 => 20,
+			:bright_off		 => 21, :bold_off				 => 21, :double_underline => 21,
+			:clean				 => 22, :regular => 22, #neither bold or faint
+			:italic_off		 => 23, :fraktur_off		 => 23,
+			:underline_off => 24,
+			:blink_off		 => 25,
+			:inverse_off	 => 26, :positive				 => 26,
+			:conceal_off	 => 27, :show						 => 27, :reveal						=> 27,
+			:crossed_off	 => 29, :crossed_out_off => 29,
+			:frame				 => 51, :framed => 51,
+			:encircle			 => 52, :encircled => 52,
+			:overline			 => 53, :overlined => 53,
+			:frame_off		 => 54, :encircle_off		 => 54,
+			:framed_off		 => 54, :encircled_off		 => 54,
+			:overline_off  => 55, :overlined_off  => 55,
+		}
 
+		#attributes that can be specified to the color method
+		COLORS = [ANSI_EFFECTS,ANSI_COLORS_FOREGROUND, ANSI_COLORS_BACKGROUND, ANSI_COLORS_INTENSE_FOREGROUND, ANSI_COLORS_INTENSE_BACKGROUND].inject({}){ |a,b| a.merge(b) }
+	end
 end

data/lib/simplecolor/mixin.rb

@@ -0,0 +1,2 @@
+require 'simplecolor'
+SimpleColor.mix_in_string

data/lib/simplecolor/rgb.rb

@@ -0,0 +1,318 @@
+require 'json'
+require "zlib"
+require 'simplecolor/rgb_colors'
+
+# rgb color conversion
+# taken from the paint gem, all copyright belong to its author
+
+module SimpleColor
+	RGBError=Class.new(SimpleColorError)
+	WrongRGBColor=Class.new(RGBError)
+	WrongRGBParameter=Class.new(RGBError)
+
+	class RGB
+
+		module Parsers
+			# Creates RGB color from a HTML-like color definition string
+			def rgb_hex(string)
+				case string.size
+				when 6
+					string.each_char.each_slice(2).map{ |hex_color| hex_color.join.to_i(16) }
+				when 3
+					string.each_char.map{ |hex_color_half| (hex_color_half*2).to_i(16) }
+				else
+					raise WrongRGBColor.new(string)
+				end
+			end
+
+			def parse(col, color_names: proc {|c| find_color(c)})
+				case col
+				when self
+					return col
+				when Proc
+					scol=col.call(self)
+					return parse(scol, color_names: color_names)
+				when Symbol
+					if ANSI_COLORS_16.key?(col)
+						return self.new(col, mode: 16)
+					end
+				when Array
+					return self.new(col, mode: true)
+				when String
+					if (m=col.match(/\A(?:rgb)?256[+:-]?(?<grey>gr[ae]y)?(?<red>\d+)(?:[+:-](?<green>\d+)[+:-](?<blue>\d+))?\z/))
+						grey=m[:grey]; red=m[:red]&.to_i; green=m[:green]&.to_i; blue=m[:blue]&.to_i
+						if grey
+							return self.new(GREY256+red, mode: 256)
+						elsif green and blue
+							return self.new([red, green, blue], mode: 256)
+						else
+							raise WrongRGBColor.new(col) if green
+							return self.new(red, mode: 256)
+						end
+					elsif (m=col.match(/\A(?:rgb[+:-]?)?(?<red>\d+)[+:-](?<green>\d+)[+:-](?<blue>\d+)\z/))
+						red=m[:red]&.to_i; green=m[:green]&.to_i; blue=m[:blue]&.to_i
+						return self.new([red, green, blue], mode: :truecolor)
+					elsif (m=col.match(/\A#?(?<hex_color>[[:xdigit:]]{3}{1,2})\z/)) # 3 or 6 hex chars
+						return self.new(rgb_hex(m[:hex_color]), mode: :truecolor)
+					end
+				end
+				if color_names && (c=color_names[col])
+					return self.parse(c, color_names: nil)
+				else
+					# fallback to parsing col.to_s?
+					raise WrongRGBColor.new(col)
+				end
+			end
+		end
+		extend Parsers
+
+		module Utils
+			def rgb_random
+				RGB.new((1..3).map { Random.rand(256) })
+			end
+			
+			#c=16 + 36 × r + 6 × g + b
+			def color256_to_rgb(c)
+				bgr=(c-16).digits(6)
+				bgr+=[0]*(3-rgb.length)
+				bgr.reverse
+			end
+
+			def rgb_values(c)
+				case c
+				when self
+					c.to_truecolor.color
+				else
+					self.parse(c).to_truecolor.color
+				end
+			end
+		end
+		extend Utils
+
+		module RGB16
+			def rgb_colors16
+				RGB_COLORS_ANSI_16
+			end
+			def rgb_colors8
+				RGB_COLORS_ANSI
+			end
+		end
+		extend RGB16
+		extend RGB16
+
+		attr_accessor :color, :mode, :background
+
+		private def color_mode(mode)
+			case mode
+			when true, :truecolor, TRUE_COLOR
+				mode=:truecolor
+			end
+			case mode
+			when 8, 16, 256, :truecolor
+				yield mode if block_given?
+				return mode
+			else
+				raise WrongRGBParameter.new(mode)
+			end
+		end
+
+		def initialize(*rgb, mode: :truecolor, background: false)
+			raise WrongRGBColor.new(rgb) if rgb.empty?
+			rgb=rgb.first if rgb.length==1
+			raise WrongRGBColor.new(rgb) if rgb.nil?
+
+			@init=rgb
+			@color=rgb #should be an array for truecolor, a number otherwise
+			@mode=color_mode(mode)
+			@background=!!background
+			
+			case @mode
+			when :truecolor
+				unless @color&.size == 3 && @color&.all?{ |n| n.is_a? Numeric }
+					raise WrongRGBColor.new(rgb)
+				end
+				raise WrongRGBColor.new(rgb) unless rgb.all? do |c|
+					(0..255).include?(c)
+				end
+			when 256 #for 256 colors we are more lenient
+				case rgb
+				when Array
+					unless @color&.size == 3 && @color&.all?{ |n| n.is_a? Numeric }
+						raise WrongRGBColor.new(rgb)
+					end
+					raise WrongRGBColor.new(rgb) unless rgb.all? do |c|
+						(0..5).include?(c)
+					end
+					red, green, blue=rgb
+					@color=16 + 36 * red.to_i + 6 * green.to_i + blue.to_i
+				when String, Symbol #for grey mode
+					if (m=rgb.to_s.match(/\Agr[ae]y(\d+)\z/))
+						@color=GREY256+m[1].to_i
+					else
+						raise WrongRGBColor.new(rgb)
+					end
+				else
+					raise WrongRGBColor.new(rgb) unless @color.is_a?(Numeric)
+				end
+			when 8,16
+				@color=ANSI_COLORS_16[rgb] if ANSI_COLORS_16.key?(rgb)
+				raise WrongRGBColor.new(rgb) unless @color.is_a?(Numeric)
+			end
+		end
+
+		def ==(other)
+			[:color, :mode, :background].all? do |sym|
+				self.public_send(sym) == other.public_send(sym)
+			end
+		end
+
+		def truecolor?
+			@mode == :truecolor
+		end
+
+		def nbcolors
+			return TRUE_COLOR if @mode == :truecolor
+			return @mode
+		end
+
+		def to_hex
+			r,g,b=rgb
+			hexa = ->(c) {h=c.to_s(16).upcase; h.length == 1 ? "0#{h}" : h}
+			"\##{hexa[r]}#{hexa[g]}#{hexa[b]}"
+		end
+
+		def rgb
+			to_truecolor.color
+		end
+
+		# For RGB 256 colors,
+		# Foreground = "\e[38;5;#{fg}m", Background = "\e[48;5;#{bg}m"
+		# where the color code is
+		# 0-	7:	standard colors (as in ESC [ 30–37 m)
+		# 8- 15:	high intensity colors (as in ESC [ 90–97 m)
+		# 16-231:  6 × 6 × 6 cube (216 colors): 16 + 36 × r + 6 × g + b (0 ≤ r, g, b ≤ 5)
+		# 232-255:  grayscale from black to white in 24 steps
+
+		#For true colors:
+		#		ESC[ 38;2;<r>;<g>;<b> m Select RGB foreground color
+		#		ESC[ 48;2;<r>;<g>;<b> m Select RGB background color
+		def ansi(background: @background, convert: nil)
+			return self.convert(convert, only_down: true).ansi(background: background, convert: nil) if convert
+			case @mode
+			when 8, 16
+				if @color < 8
+					"#{background ? 4 : 3}#{@color}"
+				else
+					# Note that on_intense_* is not supported by terminals
+					# it is usually better to convert to 256 colors palette which is
+					# better supported
+					"#{background ? 10 : 9}#{@color-8}"
+				end
+			when 256
+				"#{background ? 48 : 38};5;#{@color}"
+			when :truecolor
+				red, green, blue=@color
+				"#{background ? 48 : 38};2;#{red};#{green};#{blue}"
+			end
+		end
+
+		def convert(mode, only_down: false)
+			case color_mode(mode)
+			when 8
+				return to_8
+			when 16
+				return to_16 unless only_down and nbcolors < 16
+			when 256
+				return to_256 unless only_down and nbcolors < 256
+			when :truecolor
+				return to_truecolor unless only_down and nbcolors < TRUE_COLOR
+			end
+			self
+		end
+
+		def to_truecolor
+			case @mode
+			when 8, 16
+				name=ANSI_COLORS_16.key(@color)
+				rgb=self.class.rgb_colors16[name]
+				self.class.new(rgb)
+			when 256
+				if @color < 16
+					to_16.to_truecolor
+				elsif @color < GREY256
+					red, green, blue=self.class.color256_to_rgb(@color)
+					self.class.new([red, green, blue].map {|c| (c * 256.0/7.0).round})
+				else
+					grey=@color-GREY256
+					self.class.new([(grey*256.0/24.0).round]*3)
+				end
+			else
+				self
+			end
+		end
+
+		def to_256
+			case @mode
+			when 256
+				return self
+			when 8, 16
+				return self.class.new(@color, mode: 256)
+			else
+				red,green,blue=@color
+
+				gray_possible = true
+				sep = 42.5
+
+				while gray_possible
+					if red < sep || green < sep || blue < sep
+						gray = red < sep && green < sep && blue < sep
+						gray_possible = false
+					end
+					sep += 42.5
+				end
+
+				col=if gray
+					GREY256 + ((red.to_f + green.to_f + blue.to_f)/33).round
+				else # rgb
+					[16, *[red, green, blue].zip([36, 6, 1]).map{ |color, mod|
+						(6 * (color.to_f / 256)).to_i * mod
+					}].inject(:+)
+				end
+				self.class.new(col, mode: 256)
+
+			end
+		end
+
+		def to_8
+			rgb8=self.class.rgb_colors8
+			color_pool = rgb8.values
+			closest=rgb_to_pool(color_pool)
+			name=rgb8.key(closest)
+			self.class.new(ANSI_COLORS_16[name], mode: 8)
+		end
+
+		def to_16
+			rgb16=self.class.rgb_colors16
+			color_pool = rgb16.values
+			closest=rgb_to_pool(color_pool)
+			name=rgb16.key(closest)
+			self.class.new(ANSI_COLORS_16[name], mode: 16)
+		end
+
+		def rgb_color_distance(rgb2)
+			if truecolor?
+				@color.zip(self.class.rgb_values(rgb2)).inject(0){ |acc, (cur1, cur2)| acc + (cur1 - cur2)**2 }
+			else
+				to_truecolor.rgb_color_distance(rgb2)
+			end
+		end
+
+		def rgb_to_pool(color_pool)
+			if truecolor?
+				color_pool.min_by{ |col| rgb_color_distance(col) }
+			else
+				to_truecolor.rgb_to_pool(color_pool)
+			end
+		end
+	end
+end