simplecolor 0.2.0 → 0.3.0

data/lib/simplecolor/rgb_colors.rb

@@ -0,0 +1,111 @@
+module SimpleColor
+	class RGB
+		GREY256=232
+		TRUE_COLOR=0xFFFFFF
+
+		ANSI_COLORS_16 = {
+			:black	 => 0,
+			:red		 => 1,
+			:green	 => 2,
+			:yellow  => 3,
+			:blue		 => 4,
+			:magenta => 5,
+			:cyan		 => 6,
+			:white	 => 7,
+			:intense_black	 => 8,
+			:intense_red		 => 9,
+			:intense_green	 => 10,
+			:intense_yellow  => 11,
+			:intense_blue		 => 12,
+			:intense_magenta => 13,
+			:intense_cyan		 => 14,
+			:intense_white	 => 15,
+		}
+		(0..15).each { |i| ANSI_COLORS_16[:"color#{i}"]=i}
+
+		# A list of color names for standard ansi colors, needed for 16/8 color fallback mode
+		# See https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
+		# These are the xterm color palette
+		RGB_COLORS_ANSI = {
+			:black	 => [  0,		0,	 0],
+			:red		 => [205,		0,	 0],
+			:green	 => [  0, 205,	 0],
+			:yellow  => [205, 205,	 0],
+			:blue		 => [  0,		0, 238],
+			:magenta => [205,		0, 205],
+			:cyan		 => [  0, 205, 205],
+			:white	 => [229, 229, 229],
+			:gray => [229, 229, 229],
+		}.each { |_k, v| v.freeze }.freeze
+
+		RGB_COLORS_ANSI_BRIGHT = {
+			:intense_black	 => [127, 127, 127],
+			:intense_red		 => [255,		0,	 0],
+			:intense_green	 => [  0, 255,	 0],
+			:intense_yellow  => [255, 255,	 0],
+			:intense_blue		 => [ 92,  92, 255],
+			:intense_magenta => [255,		0, 255],
+			:intense_cyan		 => [  0, 255, 255],
+			:intense_white	 => [255, 255, 255],
+			:intense_gray => [255, 255, 255],
+		}.each { |_k, v| v.freeze }.freeze
+
+		RGB_COLORS_ANSI_16 = RGB_COLORS_ANSI.merge(RGB_COLORS_ANSI_BRIGHT)
+
+		COLOR_NAMES={
+			:random => proc { rgb_random },
+		}
+
+		module ColorNames
+			def color_names
+				@color_names ||= COLOR_NAMES.dup
+			end
+
+			def all_color_names
+				return @rgb_color_names if defined? @rgb_color_names
+				# A list of color names, based on X11's rgb.txt
+				rgb_colors = File.dirname(__FILE__) + "/../../data/rgb_colors.json.gz"
+				# Rewrite file:
+				# h={}; rgb.each do |k,v| h[SimpleColor::RGB.rgb_clean(k)]=v end
+				# Pathname.new("data/rgb_colors.json").write(h.to_json)
+				File.open(rgb_colors, "rb") do |file|
+					serialized_data = Zlib::GzipReader.new(file).read
+					# serialized_data.force_encoding Encoding::BINARY
+					@rgb_color_names = JSON.parse(serialized_data)
+				end
+			end
+
+			def color_names_priority
+				@rgb_color_names.keys
+			end
+
+			def rgb_clean(name) #clean up name
+				name.gsub(/\s+/,'').downcase.gsub('gray','grey')
+			end
+
+			def find_color(name)
+				custom=color_names
+				case name
+				when String
+					return custom[name] if custom.key?(name)
+					name=rgb_clean(name)
+					return custom[name] if custom.key?(name)
+					colors=all_color_names
+					base, rest=name.split(':', 2)
+					if rest.nil?
+						color_names_priority.each do |base|
+							c=colors[base]
+							return c[name] if c.key?(name)
+						end
+					else
+						c=colors[base]
+						return c[rest]
+					end
+				else
+					custom[name]
+				end
+			end
+		end
+		extend ColorNames
+	end
+end

data/lib/simplecolor/version.rb

@@ -1,4 +1,4 @@
 module SimpleColor
   # simplecolor version
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/simplecolor.gemspec

@@ -35,6 +35,7 @@ Gem::Specification.new do |gem|
     end
   end
   gem.files = glob[gemspec['files']] if gemspec['files']
+  gem.files = gem.files + gemspec['extra_files'] if gemspec['extra_files']
 
   gem.executables = gemspec.fetch('executables') do
     glob['bin/*'].map { |path| File.basename(path) }
@@ -68,4 +69,5 @@ Gem::Specification.new do |gem|
   end
 
   gem.metadata['yard.run']='yri'
+  gem.metadata['project_name']='SimpleColor'
 end

data/test/test_rgb.rb

@@ -0,0 +1,103 @@
+require 'helper'
+require 'simplecolor'
+
+describe SimpleColor::RGB do
+	it "Should output truecolor code" do
+		SimpleColor::RGB.new(10,20,30).ansi.must_equal "38;2;10;20;30"
+	end
+	it "Can degrade to 256 colors" do
+		SimpleColor::RGB.new(10,20,30).convert(256).ansi.must_equal "38;5;234"
+	end
+	it "Can degrade to 16 colors" do
+		SimpleColor::RGB.new(10,20,160).convert(16).ansi.must_equal "34"
+	end
+	it "Can degrade to 8 colors" do
+		SimpleColor::RGB.new(10,20,30).convert(8).ansi.must_equal "30"
+	end
+
+	describe "List name" do
+		it "Can specify color names" do
+			SimpleColor::RGB.parse("lavender").to_hex.must_equal "#9F90D0"
+		end
+		it "Can specify the dict to use for color names" do
+			SimpleColor::RGB.parse("x11:lavender").to_hex.must_equal "#E6E6FA"
+		end
+		it "Can use custom names" do
+			SimpleColor::RGB.parse("solarized_base03").to_hex.must_equal "#002B36"
+		end
+		it "Custom names have precedence" do
+			SimpleColor::RGB.parse("verydarkbluishgreen").to_hex.must_equal "#002A29"
+			SimpleColor::RGB.color_names["verydarkbluishgreen"]="#002B30"
+			SimpleColor::RGB.parse("verydarkbluishgreen").to_hex.must_equal "#002B30"
+			SimpleColor::RGB.parse("nbs:verydarkbluishgreen").to_hex.must_equal "#002A29"
+		end
+	end
+end
+
+describe SimpleColor do
+	after do #restore default options
+		SimpleColor.opts=nil
+	end
+
+	it "Can parse a true color name" do
+		SimpleColor.color("foo", "rgb:10-20-30").must_equal "\e[38;2;10;20;30mfoo\e[0m"
+		SimpleColor.color("foo", "10-20-30").must_equal "\e[38;2;10;20;30mfoo\e[0m"
+		SimpleColor.color("foo", "10:20:30").must_equal "\e[38;2;10;20;30mfoo\e[0m"
+		SimpleColor.color("foo", [10, 20, 30]).must_equal "\e[38;2;10;20;30mfoo\e[0m"
+	end
+
+	it "Can specify 256 colors" do
+		SimpleColor.color("foo", "rgb256:1-2-3").must_equal "\e[38;5;67mfoo\e[0m"
+		SimpleColor.color("foo", "256:1-2-3").must_equal "\e[38;5;67mfoo\e[0m"
+		SimpleColor.color("foo", "256:grey1").must_equal "\e[38;5;233mfoo\e[0m"
+		SimpleColor.color("foo", "256:10").must_equal "\e[38;5;10mfoo\e[0m"
+	end
+
+	it "Can specify hexa color name" do
+		SimpleColor.color("foo", "#10AABB").must_equal "\e[38;2;16;170;187mfoo\e[0m"
+		SimpleColor.color("foo", "#1AB").must_equal "\e[38;2;17;170;187mfoo\e[0m"
+	end
+
+	it "Can specify x11 color name" do
+		SimpleColor.color("foo", "Lemon Chiffon").must_equal "\e[38;2;255;250;205mfoo\e[0m"
+		SimpleColor.color("foo", "lemonchiffon").must_equal "\e[38;2;255;250;205mfoo\e[0m"
+	end
+
+	it "Can specify background color name" do
+		SimpleColor.color("foo", "on_lemonchiffon").must_equal "\e[48;2;255;250;205mfoo\e[0m"
+		SimpleColor.color("foo", "on_rgb:255+250+205").must_equal "\e[48;2;255;250;205mfoo\e[0m"
+		SimpleColor.color("foo", "on_#CCBBAA").must_equal "\e[48;2;204;187;170mfoo\e[0m"
+		SimpleColor.color("foo", "on_rgb256:1+2+3").must_equal "\e[48;5;67mfoo\e[0m"
+		SimpleColor.color("foo", "on_rgb256:1").must_equal "\e[48;5;1mfoo\e[0m"
+		SimpleColor.color("foo", "on_rgb256:gray1").must_equal "\e[48;5;233mfoo\e[0m"
+		SimpleColor.color("foo", [:on, 10, 20, 30]).must_equal "\e[48;2;10;20;30mfoo\e[0m"
+	end
+
+	describe "It can fallback to 256 colors" do
+		before do
+			SimpleColor.color_mode=256
+		end
+
+		it "Can specify x11 color name" do
+			SimpleColor.color("foo", "Lemon Chiffon").must_equal "\e[38;5;230mfoo\e[0m"
+			SimpleColor.color("foo", "on_Lemon Chiffon").must_equal "\e[48;5;230mfoo\e[0m"
+		end
+
+		it "Can be forced to be truecolor" do
+			SimpleColor.color("foo", "t:Lemon Chiffon").must_equal "\e[38;2;255;250;205mfoo\e[0m"
+			SimpleColor.color("foo", "truecolor:Lemon Chiffon").must_equal "\e[38;2;255;250;205mfoo\e[0m"
+			SimpleColor.color("foo", "true:on_Lemon Chiffon").must_equal "\e[48;2;255;250;205mfoo\e[0m"
+		end
+	end
+
+	describe "It can fallback to 8 colors" do
+		before do
+			SimpleColor.color_mode=8
+		end
+
+		it "Can specify x11 color name" do
+			SimpleColor.color("foo", "Lemon Chiffon").must_equal "\e[37mfoo\e[0m"
+			SimpleColor.color("foo", "on_Lemon Chiffon").must_equal "\e[47mfoo\e[0m"
+		end
+	end
+end

data/test/test_simplecolor.rb

@@ -2,18 +2,15 @@ require 'helper'
 require 'simplecolor'
 
 class TestSimpleColor < MiniTest::Test
-
 	def test_version
 		version = SimpleColor.const_get('VERSION')
-
 		assert(!version.empty?, 'should have a VERSION constant')
 	end
-
 end
 
 describe SimpleColor do
-	before do
-		SimpleColor.enabled=true
+	after do #restore default options
+		SimpleColor.opts=nil
 	end
 
 	it "Can be used directly" do
@@ -57,6 +54,50 @@ describe SimpleColor do
 		SimpleColor.color?(SimpleColor.color("red",:red)).must_equal true
 	end
 
+	it "Can only show color escape when passed nil" do
+		SimpleColor.color(nil, "x11:lavender").must_equal "\e[38;2;230;230;250m"
+	end
+
+	it "Accepts a block as color parameter" do
+		SimpleColor.color("foo", proc { "x11:lavender" }).must_equal "\e[38;2;230;230;250mfoo\e[0m"
+	end
+
+	it "Proc as color parameter can return multiple values" do
+		SimpleColor.color("foo", proc { ["x11:lavender", :bold] }).must_equal "\e[38;2;230;230;250;1mfoo\e[0m"
+	end
+
+	it "Has default options" do
+		SimpleColor.opts.must_equal(SimpleColor::Opts.default_opts)
+	end
+
+	describe "Abbreviations" do
+		before do
+			SimpleColor.abbreviations={red: SimpleColor.color(:green), color1: SimpleColor.color(nil, "x11:lavender")}
+		end
+
+		it "Can use the color1 abbreviations" do
+			SimpleColor.color("foo", :color1).must_equal "\e[38;2;230;230;250mfoo\e[0m"
+		end
+		it "Abbrevations have precedence" do
+			SimpleColor.color("foo", :red).must_equal SimpleColor.color("foo", :green)
+		end
+	end
+
+	describe "Random" do
+		it "Has a :random color" do
+			SimpleColor.color("foo", :random).must_match(/\e\[38;2;\d+;\d+;\d+mfoo\e\[0m/)
+		end
+		it "Has a :on_random color" do
+			SimpleColor.color("foo", :on_random).must_match(/\e\[48;2;\d+;\d+;\d+mfoo\e\[0m/)
+		end
+	end
+
+	describe "Abbreviations" do
+		it "Can specify abbreviations" do
+			SimpleColor.abbreviations[:important]=[:red, :bold]
+			SimpleColor.color("foo", :important).must_equal("\e[31;1mfoo\e[0m")
+		end
+	end
 
 	describe "Shell mode" do
 		before do
@@ -66,6 +107,23 @@ describe SimpleColor do
 		it "Wraps color into shell escapes" do
 			SimpleColor.color("red",:red).must_equal "%{\e[31m%}red%{\e[0m%}"
 		end
+
+		it "Can uncolor correctly" do
+			SimpleColor.uncolor(SimpleColor.color("red",:red)).must_equal "red"
+		end
+
+		it "Only uncolor shell wrapped colors" do
+			red="\e[31mred\e[0m"
+			SimpleColor.uncolor(red).must_equal red
+		end
+
+		it "Can detect colors correctly" do
+			SimpleColor.color?(SimpleColor.color("red",:red)).must_equal true
+		end
+
+		it "Only detect shell wrapped colors" do
+			SimpleColor.color?("\e[31mred\e[0m").must_equal false
+		end
 	end
 
 	describe "It can be mixed in strings" do
@@ -104,10 +162,8 @@ describe SimpleColor do
 			s.uncolor!
 			s.must_equal "red"
 		end
-
 	end
 
-
 	describe "It can be disabled" do
 		before do
 			SimpleColor.enabled=false
@@ -122,6 +178,13 @@ describe SimpleColor do
 			word="\e[31mred\e[0m"
 			SimpleColor.uncolor(word).must_equal "red"
 		end
+
+		it "Can be disabled punctually" do
+			SimpleColor.enabled=true
+			word="red"
+			SimpleColor.color(word,:red, mode: false).must_equal word
+			SimpleColor.color(word,:red).must_equal "\e[31mred\e[0m"
+		end
 	end
 
 	describe "It has colors helpers utilities" do
@@ -145,10 +208,132 @@ describe SimpleColor do
 			SimpleColor.attributes_from_colors("\e[m"+b+e).must_equal([:reset,:red,:bright,:reset])
 		end
 
+		it "Can detect 256 and truecolor attributes" do
+			test=SimpleColor[nil, "rgb256:3", "on_rgb:1:2:3", :green, :bold, :conceal, :color15]
+			expected=[SimpleColor::RGB.new(3, mode: 256),
+				SimpleColor::RGB.new([1,2,3], background: true),
+				:green, :bright, :conceal, :intense_white]
+			SimpleColor.attributes_from_colors(test).must_equal(expected)
+		end
+
 		it "Can split a string into color entities" do
 			SimpleColor.color_entities(SimpleColor.color("red",:red,:bold)+SimpleColor.color("blue",:blue)).must_equal(["\e[31;1m", "r", "e", "d", "\e[0m\e[34m", "b", "l", "u", "e", "\e[0m"])
 			SimpleColor.color_entities("blue "+SimpleColor.color("red",:red,:bold)+" green").must_equal(["b", "l", "u", "e", " ", "\e[31;1m", "r", "e", "d", "\e[0m", " ", "g", "r", "e", "e", "n"])
 		end
+
+		it "Can split a string into color strings" do
+			SimpleColor.color_strings(SimpleColor.color("red",:red,:bold)+SimpleColor.color("blue",:blue)).must_equal(["\e[31;1m", "red", "\e[0m\e[34m", "blue", "\e[0m"])
+			SimpleColor.color_strings("blue "+SimpleColor.color("red",:red,:bold)+" green").must_equal(["blue ", "\e[31;1m", "red", "\e[0m", " green"])
+		end
+	end
+
+	describe "It can use a different color module" do
+		module SimpleColor2
+			extend SimpleColor
+		end
+
+		it "Can color too" do
+			SimpleColor2.color("red", :red).must_equal "\e[31mred\e[0m"
+		end
+
+		it "Still works if SimpleColor is disabled" do
+			SimpleColor.enabled=false
+			SimpleColor2.color("red", :red).must_equal "\e[31mred\e[0m"
+			SimpleColor.color("red", :red).must_equal "red"
+		end
+
+		it "Can be disabled without disabling SimpleColor" do
+			SimpleColor2.enabled=false
+			SimpleColor.color("red", :red).must_equal "\e[31mred\e[0m"
+			SimpleColor2.color("red", :red).must_equal "red"
+			SimpleColor2.enabled=true
+		end
+
+		it "Can be mixed in a class" do
+			string_class=Class.new(String)
+			SimpleColor2.mix_in(string_class)
+			string_class.new("red").color(:red).must_equal "\e[31mred\e[0m"
+			SimpleColor.enabled=false
+			string_class.new("red").color(:red).must_equal "\e[31mred\e[0m"
+			SimpleColor2.enabled=false
+			string_class.new("red").color(:red).must_equal "red"
+			SimpleColor2.enabled=true
+		end
+
+		it "Setting a different color module copy the defaults opts and not the current opts" do
+
+			default_opts=SimpleColor.opts
+			SimpleColor.opts={mode: false, colormode: 16}
+			module SimpleColor3
+				extend SimpleColor
+			end
+			SimpleColor.opts=default_opts
+			SimpleColor3.opts.must_equal default_opts
+		end
 	end
 
+	describe "It raises invalid parameters" do
+		it "Raises when we pass invalid parameter" do
+			proc { SimpleColor.color("foo", mode: :garbage)}.must_raise SimpleColor::WrongParameter
+		end
+
+		it "Raises when we pass invalid rgb parameter" do
+			proc { SimpleColor.color("foo", "x11:lavender", color_mode:10)}.must_raise SimpleColor::WrongRGBParameter
+		end
+
+		it "Raises when we pass an invalid color" do
+			proc { SimpleColor.color("foo", SimpleColor)}.must_raise SimpleColor::WrongColor
+			proc { SimpleColor.color("foo", "nonexistingcolorname")}.must_raise SimpleColor::WrongRGBColor
+		end
+	end
+
+	describe "Chain colors" do
+		it "Can chain global colors" do
+			r=SimpleColor["red", :red]
+			SimpleColor.color(r, :blue).must_equal "\e[31m\e[34mred\e[0m"
+		end
+
+		it "Can keep global colors" do
+			r=SimpleColor["red", :red]
+			SimpleColor.color(r, :blue, global_color: :keep).must_equal SimpleColor["red", :red]
+		end
+
+		it "Can give precedence to existing global colors" do
+			r=SimpleColor["red", :red]
+			SimpleColor.color(r, :blue, global_color: :before).must_equal "\e[34m\e[31mred\e[0m"
+		end
+
+		it "Will give precedence to local colors" do
+			r="foo "+SimpleColor["red", :red]+" bar"
+			SimpleColor.color(r, :blue).must_equal "\e[34mfoo \e[31mred\e[0m\e[34m bar\e[0m"
+			r="foo "+SimpleColor["red", :red]
+			SimpleColor.color(r, :blue).must_equal "\e[34mfoo \e[31mred\e[0m"
+			r=+SimpleColor["red", :red]+" bar"
+			SimpleColor.color(r, :blue).must_equal "\e[34m\e[31mred\e[0m\e[34m bar\e[0m"
+		end
+
+		it "Can get precedence over local colors" do
+			r="foo "+SimpleColor["red", :red]+" bar"
+			SimpleColor.color(r, :blue, local_color: :after).must_equal "\e[34mfoo \e[31m\e[34mred\e[0m\e[34m bar\e[0m"
+			r="foo "+SimpleColor["red", :red]
+			SimpleColor.color(r, :blue, local_color: :after).must_equal "\e[34mfoo \e[31m\e[34mred\e[0m"
+			r=+SimpleColor["red", :red]+" bar"
+			SimpleColor.color(r, :blue, local_color: :after).must_equal "\e[31m\e[34mred\e[0m\e[34m bar\e[0m"
+		end
+
+		it "Can keep local colors" do
+			r="foo "+SimpleColor["red", :red]+" bar"
+			SimpleColor.color(r, :blue, local_color: :keep).must_equal "\e[34mfoo \e[0m\e[31mred\e[0m\e[34m bar\e[0m"
+			r="foo "+SimpleColor["red", :red]
+			SimpleColor.color(r, :blue, local_color: :keep).must_equal "\e[34mfoo \e[0m\e[31mred\e[0m"
+			r=+SimpleColor["red", :red]+" bar"
+			SimpleColor.color(r, :blue, local_color: :keep).must_equal "\e[31mred\e[0m\e[34m bar\e[0m"
+		end
+
+		it "Can store precedence settings" do
+			SimpleColor.opts[:global_color]=:keep
+			r=SimpleColor["red", :red]
+			SimpleColor.color(r, :blue).must_equal(SimpleColor["red", :red])
+		end
+	end
 end