simplecolor 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfab268c3eafcbb1131d267e320e39be80c8483d5b1fc06a15ed9a283f79e68c
-  data.tar.gz: e8d27783b06edb55c59d9c28b1e39f364440a378c3c0d8d65772425d576d2a8a
+  metadata.gz: abed8ef92e28a61aee2c138607ec7e60b693130c2895257ed616dc0e3b2ab832
+  data.tar.gz: 2c06735714e16b94505e0d353261807d1183f6045bf38a1e0bd844da7ec7ecc0
 SHA512:
-  metadata.gz: 35b6df14b721027c4e611b679f3b4499ff0058027e091a641e58e1bcfda7538c90b69ea538c506ba59d84c4c46c5098c93e5253877308aaf02a677cef63a3778
-  data.tar.gz: dec9afeeedced20abd1f6d76b7b948925d31ff877130e99059871dfe46ab5b725428ab9515e93738256c3d5d57f7f1f579ec1a6703615cccf216312ccbd4e38c
+  metadata.gz: 0de099a4abfca75531daeeb03a4a036383ae65f6838323ebd16a4dd7004aefc0072efaa8ee6344fea4b8461629595d029f4b344c33501f179a9232b2218d47a7
+  data.tar.gz: b7272f90678ed239b0d36a8e770057f6908bc62d572ae70c52198640f36d98ca3b07b73c1f6cfe1dbc09a34157291a6374e5f413d2fa2ae034e52d4f9cc5c867

data/.github/workflows/ruby.yml

@@ -0,0 +1,20 @@
+name: Ruby
+
+on: [push]
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ ubuntu-latest, macos-latest ]
+        ruby: [ 2.4, 2.5, 2.6, 2.7, jruby, truffleruby ]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - run: |
+        gem install bundler
+        bundle install --jobs 4 --retry 3
+        bundle exec rake test

data/.travis.yml

@@ -1,10 +1,13 @@
 ---
 language: ruby
 rvm:
-  - 2.4.0
-  - 2.3.3
-  - 2.2.6
-  - 2.1.10
+  - 2.7.0
+  - 2.6.5
+  - 2.5.7
+  - 2.4.9
+  - 2.3.8
+  #- 2.2.10
+  #- 2.1.10
   #- ruby-head
   #- ruby-head-clang
 script: rake test

data/ChangeLog.md

@@ -1,4 +1,142 @@
-### 0.1.0 / 2013-08-23
+== Release v0.4.0 (2020-02-26) ==
 
-* Initial release:
+	* Fix ruby 2.3 bug
+	* Fix a truffleruby bug
+	* Fix minitest warnings
+	* Add rgb_colors.json.gz
+	* Support old ruby versions
+	* Update for ruby 2.7
+	* Add todo
+	* bin/simplecolor: showcase now show more about the base colors
+
+== Release v0.3.0 (2019-05-02) ==
+
+	* Update Readme
+	* color schemes: move to data/
+	* Add tests for color names
+	* Add lots of color names
+	* More tests
+	* Add tests for local_color/global_color
+	* Replace colorer by colorer2
+	* colorer2: bug fixes
+	* colorer2: better global color detection
+	* colorer2
+	* Add test
+	* attributes_from_colors: support 256 and truecolors
+	* SimpleColor[]
+	* Add :color0 ... :color15
+	* RGB: fix color conversion
+	* Abstract 8/16 color palette
+	* Rgb color names can by symbols
+	* Effects
+	* RGB: can specify default @background
+	* RGB.to_hex
+	* Rename rgb_constants to rgb_colors
+	* SimpleColor.fill
+	* Color names: use a constant
+	* RGB: custom color names
+	* Color names
+	* Random: this is a rgb color rather than an abbreviation
+	* colorer: better recursive handling
+	* Change names of options
+	* Put Colorer in its own fle
+	* Rework the way we construct mixins
+	* Move constants around
+	* Color names: use a Proc
+	* Fixing all tests!
+	* Use constants
+	* More bug fixes
+	* Misc bug fixes
+	* Use new RGB class
+	* Class RGB
+	* Begin new RGB class
+	* New key: colornames
+	* Showcase + solarized shortcut
+	* Bug fixes + tests
+	* bin: --color=number
+	* Add binary
+	* Correctly dup arg
+	* proc in color: return multiple values
+	* Small tweak
+	* Test proc
+	* Add :random, :on_random shortcuts
+	* test: simplify resetting default options
+	* rgb color: support background mode with Array
+	* color_module: copy current options
+	* Shortcuts: be more general
+	* Fix test
+	* Shortcuts
+	* tests
+	* Color names: switch to json data
+	* Improve regexp
+	* Fixes for 256 colors
+	* Add Hex mode
+	* Raise when passed non supported parameters
+	* Add color_mode parameter
+	* 256 colors
+	* Continue rgb handling
+	* Update Rakefile
+	* Rakefile: add mapping
+	* Update Rakefile
+	* Add rgb.rb, from the paint gem
+	* Preliminary for truecolor support
+	* SimpleColor.color_strings
+	* color_module: shortcuts
+	* Add tests
+	* Generate new coloring module
+	* enabled should be a singleton method
+	* Add tests
+	* uncolor, color?: work in shell mode
+	* Add mixin.rb to help mix in String
+	* Copyright
+	* Whitespace
+
+== Release v0.2.0 (2017-02-20) ==
+
+	* Add minitest dependency
+	* Fix binary strings
+	* Correct a bug on uncolor when there was no colors
+	* attribute_from_colors
+	* Bugfixes
+	* Better color regexps
+	* Bug fixes
+	* Mix attributes and ANSI strings
+	* Color entities and add tests
+	* Typos
+	* function to handle existing colors
+	* Concatenate ANSI escape sequences inside the \e
+	* Add possibility to copy colors
+	* Sometimes \e[m is abused for \e[0m
+	* More exceptions
+	* Merge some color regexp and raise exception on bogus colors
+	* Fix SimpleColor#uncolor!
+	* Change ANSI Regexps
+	* rake doc fails for now with Rake 11
+	* Add uncolor tests
+	* ColorWrapper: unify gestion of arg
+	* Correct a bug in uncolor
+	* Add more tests
+	* Add color! and uncolor!
+	* Specify mode even when nothing is passed
+	* Add color?
+	* Add more tests
+	* Split the module into small unit modules
+	* Add warning to use v0.1.0
+	* First step to add a Colorer class
+	* typo
+	* Put simplecolor.rb in lib/ rather than lib/simplecolor/
+	* Improve documentation
+	* Describe SimpleColor.enabled
+	* sh code block
+	* README: use code block
+	* Adding a simple test
+	* Shortcut for mixing in class
+	* Update homepage
+
+== Release v0.1.0 (2013-08-23) ==
+
+	* Add more ANSI effects
+	* Update documentation
+	* First public version
+	* Initial commit.
 

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright © 2013–2017 Damien Robert
+Copyright © 2013–2020 Damien Robert
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -88,6 +88,6 @@ running `data/rgb_colors.rb`.
 
 ## Copyright
 
-Copyright © 2013–2019 Damien Robert
+Copyright © 2013–2020 Damien Robert
 
 MIT License. See [LICENSE.txt](./LICENSE.txt) for details.

data/TODO

@@ -0,0 +1,2 @@
+Add support for url? Cf https://github.com/piotrmurach/tty-link
+Write a more flexible color/truecolor api

data/bin/simplecolor.rb

@@ -3,6 +3,30 @@
 require 'simplecolor/mixin'
 require 'optparse'
 
+def solarized
+	puts
+	print "Solarized on light background: ".color("solarized_base00", "on_solarized_base3")
+	%w(yellow orange red magenta violet blue cyan green).each do |col|
+		print "#{col} ".color("solarized_#{col}", "on_solarized_base3")
+	end
+	puts
+	print "Solarized on dark background: ".color("solarized_base0", "on_solarized_base03")
+	%w(yellow orange red magenta violet blue cyan green).each do |col|
+		print "#{col} ".color("solarized_#{col}", "on_solarized_base03")
+	end
+	puts
+	[3, 2, 1, 0].each do |on|
+		(0..3).each do |cin|
+			puts SimpleColor.fill("Solarized color base0#{cin} on base#{on}").color("solarized_base0#{cin}", "on_solarized_base#{on}")
+		end
+	end
+	[3, 2, 1, 0].each do |on|
+		(0..3).each do |cin|
+			puts SimpleColor.fill("Solarized color base#{cin} on base0#{on}").color("solarized_base#{cin}", "on_solarized_base0#{on}")
+		end
+	end
+end
+
 def showcase
 	empty="  "
 	lorem="Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
@@ -45,19 +69,20 @@ def showcase
 	puts
 	puts
 
-	puts "System palette:"
-	(40..47).each do |color|
-		print SimpleColor.color(empty, color)
-	end
-	print "  =  "
+	print "Background system palette:"
 	%w(black red green yellow blue magenta cyan white).each do |s|
 		print SimpleColor.color(empty, "on_#{s}".to_sym);
 	end
-	# puts (:bold does not change the background color)
+	## This is simply:
+	# (40..47).each do |color|
+	# 	print SimpleColor.color(empty, color)
+	# end
+	## (:bold does not change the background color)
 	# (40..47).each do |color|
 	# 	print SimpleColor.color(empty, color, :bold)
 	# end
-	puts #not supported on vte
+	puts
+	print "High intensity background system palette:"
 	(90..97).each do |color|
 		print SimpleColor.color(empty, color)
 	end
@@ -72,6 +97,15 @@ def showcase
 	print "back to default background."
 	puts
 	puts
+	names=%w(black red green yellow blue magenta cyan white)
+	names+=names.map {|i| "intense_#{i}"}
+	columns=ENV['COLUMN']&.to_i || 80 
+	(0..15).each do |i|
+		color=names[i]
+		rgb=SimpleColor::RGB.new(i, mode: 16)
+		printf "Color%02d = %s %-30s %s\n".color(color.to_sym), i, rgb.to_hex, color, (" "*(columns-49)).color("on_#{color}".to_sym)
+	end
+	puts
 
 	puts "* 256 colors:"
 	puts "System palette:";
@@ -131,28 +165,6 @@ def showcase
 	print SimpleColor.clear
 	puts
 
-	puts
-	print "Solarized on light background: ".color("solarized_base00", "on_solarized_base3")
-	%w(yellow orange red magenta violet blue cyan green).each do |col|
-		print "#{col} ".color("solarized_#{col}", "on_solarized_base3")
-	end
-	puts
-	print "Solarized on dark background: ".color("solarized_base0", "on_solarized_base03")
-	%w(yellow orange red magenta violet blue cyan green).each do |col|
-		print "#{col} ".color("solarized_#{col}", "on_solarized_base03")
-	end
-	puts
-	[3, 2, 1, 0].each do |on|
-		(0..3).each do |cin|
-			puts SimpleColor.fill("Solarized color base0#{cin} on base#{on}").color("solarized_base0#{cin}", "on_solarized_base#{on}")
-		end
-	end
-	[3, 2, 1, 0].each do |on|
-		(0..3).each do |cin|
-			puts SimpleColor.fill("Solarized color base#{cin} on base0#{on}").color("solarized_base#{cin}", "on_solarized_base0#{on}")
-		end
-	end
-
 	puts
 	cube= ->(start, to_end) do
 		direction=(0..2).map {|i| to_end[i]-start[i]}
@@ -185,6 +197,7 @@ def showcase
 
 	print_cube[[0,1,0],[0,1,1], [0,0,1]]
 
+	puts
 	puts "* Effects"
 	effects=SimpleColor::Colorer::ANSI_EFFECTS
 	effects.values.uniq.each do |v|
@@ -196,15 +209,22 @@ def showcase
 			puts "- #{eff.join('/')}: " + "lorem ipsum".color(v)
 		end
 	end
+
+	puts
+	puts "* Terminfo effects"
+	print "- Italic: "; system('tput sitm'); print "lorem ipsum"; system('tput ritm')
 end
 
 optparse = OptionParser.new do |opt|
 	opt.on("--color=number", "-c", "Set number of colors", Integer) do |v|
 		SimpleColor.color_mode=v
 	end
-	opt.on("--showcase", "Showcase color capabilities of terminal") do |_v|
+	opt.on("--showcase", "-s", "Showcase color capabilities of terminal") do |_v|
 		showcase
 	end
+	opt.on("--solarized", "Show solarized colors") do |_v|
+		solarized
+	end
 end
 optparse.parse!
 

data/lib/simplecolor.rb

@@ -30,7 +30,7 @@ module SimpleColor
 		#		SimpleColor.color(:blue,:bold) { "blue" }
 		#		SimpleColor.color(:blue,:bold) << "blue" << SimpleColor.color(:clear)
 		%i(color uncolor color! uncolor! color?).each do |m|
-			define_method m do |*args, &b|
+			define_method m do |*args, **kwds, &b|
 				arg=if b
 					b.call.to_s
 				elsif respond_to?(:to_str)
@@ -47,15 +47,19 @@ module SimpleColor
 				end
 				case m
 				when :color
-					Colorer.colorer(arg.dup,*args)
+				  # the rescue is here for ruby 2.3 which can't dup Nilclass.
+				  # Newer versions of ruby don't need it
+				  duped = arg.dup rescue arg
+					Colorer.colorer(duped,*args,**kwds)
 				when :uncolor
-					Colorer.uncolorer(arg.dup,*args)
+				  duped = arg.dup rescue arg
+					Colorer.uncolorer(duped,*args,**kwds)
 				when :color!
-					Colorer.colorer(arg,*args)
+					Colorer.colorer(arg,*args,**kwds)
 				when :uncolor!
-					Colorer.uncolorer(arg,*args)
+					Colorer.uncolorer(arg,*args,**kwds)
 				when :color?
-					Colorer.colored?(arg,*args)
+					Colorer.colored?(arg,*args,**kwds)
 				end
 			end
 		end
@@ -180,10 +184,13 @@ module SimpleColor
 		def self.define_color_methods(klass, *methods, opts_from: nil, color_module: ColorWrapper)
 			methods=color_module.instance_methods if methods.empty?
 			methods.each do |m|
-				klass.define_method m do |*args, **l_opts, &b|
-					opts= opts_from ? opts_from.opts : self.opts
-					opts=opts.merge(l_opts)
-					color_module.instance_method(m).bind(self).call(*args, **opts, &b)
+				# klass.define_method m do |*args, **l_opts, &b|
+				klass.class_eval do
+					define_method m do |*args, **l_opts, &b|
+						opts= opts_from ? opts_from.opts : self.opts
+						opts=opts.merge(l_opts)
+						color_module.instance_method(m).bind(self).call(*args, **opts, &b)
+					end
 				end
 			end
 		end

data/lib/simplecolor/colorer.rb

@@ -39,7 +39,9 @@ module SimpleColor
 				symbol=s.is_a?(Symbol)
 				truecol=/(?<truecol>(?:truecolor|true|t):)?/
 				on=/(?<on>on_)?/
-				s.match(/\A#{truecol}#{on}(?<rest>.*)\z/) do |m|
+				# the to_s is because of a bug in truffleruby where
+				# `s.match(...) do end` does not work with symbols
+				s.to_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

data/lib/simplecolor/rgb_colors.rb

@@ -99,7 +99,7 @@ module SimpleColor
 						end
 					else
 						c=colors[base]
-						return c[rest]
+						return c[rest] if c
 					end
 				else
 					custom[name]

data/lib/simplecolor/version.rb

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

data/test/test_rgb.rb

@@ -3,33 +3,33 @@ 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"
+		_(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"
+		_(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"
+		_(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"
+		_(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"
+			_(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"
+			_(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"
+			_(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.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"
+			_(SimpleColor::RGB.parse("verydarkbluishgreen").to_hex).must_equal "#002B30"
+			_(SimpleColor::RGB.parse("nbs:verydarkbluishgreen").to_hex).must_equal "#002A29"
 		end
 	end
 end
@@ -40,37 +40,37 @@ describe SimpleColor do
 	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"
+		_(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"
+		_(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"
+		_(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"
+		_(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"
+		_(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
@@ -79,14 +79,14 @@ describe SimpleColor do
 		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"
+			_(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"
+			_(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
 
@@ -96,8 +96,8 @@ describe SimpleColor do
 		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"
+			_(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

@@ -14,60 +14,60 @@ describe SimpleColor do
 	end
 
 	it "Can be used directly" do
-		SimpleColor.color("red",:red).must_equal "\e[31mred\e[0m"
+		_(SimpleColor.color("red",:red)).must_equal "\e[31mred\e[0m"
 	end
 
 	it "Can specify several colors" do
-		SimpleColor.color("red",:red,:bold).must_equal "\e[31;1mred\e[0m"
+		_(SimpleColor.color("red",:red,:bold)).must_equal "\e[31;1mred\e[0m"
 	end
 
 	it "Accepts ANSI sequences" do
-		SimpleColor.color("red","\e[31;1m").must_equal "\e[31;1mred\e[0m"
+		_(SimpleColor.color("red","\e[31;1m")).must_equal "\e[31;1mred\e[0m"
 	end
 
 	it "Can mix ANSI sequences and attributes" do
-		SimpleColor.color("red",:inverse,"\e[31m",:blue,:bold).must_equal "\e[7m\e[31m\e[34;1mred\e[0m"
+		_(SimpleColor.color("red",:inverse,"\e[31m",:blue,:bold)).must_equal "\e[7m\e[31m\e[34;1mred\e[0m"
 	end
 
 	it "Can take a block" do
-		SimpleColor.color(:red) { "red" }.must_equal "\e[31mred\e[0m"
+		_(SimpleColor.color(:red) { "red" }).must_equal "\e[31mred\e[0m"
 	end
 
 	it "Can provide only color values" do
-		SimpleColor.color(:red).must_equal "\e[31m"
+		_(SimpleColor.color(:red)).must_equal "\e[31m"
 	end
 
 	it "Does not change the string when there is no color attributes" do
-		SimpleColor.color("foo").must_equal "foo"
+		_(SimpleColor.color("foo")).must_equal "foo"
 	end
 
 	it "can uncolor" do
-		SimpleColor.uncolor(SimpleColor.color("red",:red)).must_equal "red"
+		_(SimpleColor.uncolor(SimpleColor.color("red",:red))).must_equal "red"
 	end
 
 	it "uncolor does not change uncolored strings" do
-		SimpleColor.uncolor("red").must_equal "red"
+		_(SimpleColor.uncolor("red")).must_equal "red"
 	end
 
 	it "Can detect colored strings" do
-		SimpleColor.color?("red").must_equal false
-		SimpleColor.color?(SimpleColor.color("red",:red)).must_equal true
+		_(SimpleColor.color?("red")).must_equal false
+		_(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"
+		_(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"
+		_(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"
+		_(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)
+		_(SimpleColor.opts).must_equal(SimpleColor::Opts.default_opts)
 	end
 
 	describe "Abbreviations" do
@@ -76,26 +76,26 @@ describe SimpleColor do
 		end
 
 		it "Can use the color1 abbreviations" do
-			SimpleColor.color("foo", :color1).must_equal "\e[38;2;230;230;250mfoo\e[0m"
+			_(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)
+			_(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/)
+			_(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/)
+			_(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")
+			_(SimpleColor.color("foo", :important)).must_equal("\e[31;1mfoo\e[0m")
 		end
 	end
 
@@ -105,24 +105,24 @@ describe SimpleColor do
 		end
 
 		it "Wraps color into shell escapes" do
-			SimpleColor.color("red",:red).must_equal "%{\e[31m%}red%{\e[0m%}"
+			_(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"
+			_(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
+			_(SimpleColor.uncolor(red)).must_equal red
 		end
 
 		it "Can detect colors correctly" do
-			SimpleColor.color?(SimpleColor.color("red",:red)).must_equal true
+			_(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
+			_(SimpleColor.color?("\e[31mred\e[0m")).must_equal false
 		end
 	end
 
@@ -132,35 +132,35 @@ describe SimpleColor do
 		end
 
 		it "Works on strings" do
-			"red".color(:red).must_equal "\e[31mred\e[0m"
+			_("red".color(:red)).must_equal "\e[31mred\e[0m"
 		end
 
 		it "Uncolor works on strings" do
-			"red".color(:red).uncolor.must_equal "red"
+			_("red".color(:red).uncolor).must_equal "red"
 		end
 
 		it "color does not affects the string" do
 			s="red"
 			s.color(:red)
-			s.must_equal "red"
+			_(s).must_equal "red"
 		end
 
 		it "color! does affects the string" do
 			s="red"
 			s.color!(:red)
-			s.must_equal "\e[31mred\e[0m"
+			_(s).must_equal "\e[31mred\e[0m"
 		end
 
 		it "uncolor does not affects the string" do
 			s="\e[31mred\e[0m"
 			s.uncolor
-			s.must_equal "\e[31mred\e[0m"
+			_(s).must_equal "\e[31mred\e[0m"
 		end
 
 		it "uncolor! does not affects the string" do
 			s="\e[31mred\e[0m"
 			s.uncolor!
-			s.must_equal "red"
+			_(s).must_equal "red"
 		end
 	end
 
@@ -171,41 +171,41 @@ describe SimpleColor do
 
 		it "When disabled color should be a noop" do
 			word="red"
-			SimpleColor.color(word,:red).must_equal word
+			_(SimpleColor.color(word,:red)).must_equal word
 		end
 
 		it "When disabled uncolor should still work" do
 			word="\e[31mred\e[0m"
-			SimpleColor.uncolor(word).must_equal "red"
+			_(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"
+			_(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
 		it "It can copy one color" do
-			SimpleColor.copy_colors(SimpleColor.color("red",:red),"blue").must_equal "\e[31mblue\e[0m"
+			_(SimpleColor.copy_colors(SimpleColor.color("red",:red),"blue")).must_equal "\e[31mblue\e[0m"
 		end
 
 		it "Copy several colors" do
-			SimpleColor.copy_colors(SimpleColor.color("red",:red,:bold),"blue").must_equal "\e[31;1mblue\e[0m"
+			_(SimpleColor.copy_colors(SimpleColor.color("red",:red,:bold),"blue")).must_equal "\e[31;1mblue\e[0m"
 		end
 
 		it "Can recover colors" do
 			b,e,l=SimpleColor.current_colors(SimpleColor.color("red",:red,:bold))
-			b.must_equal "\e[31;1m"
-			e.must_equal "\e[0m"
-			l.must_equal "red"
+			_(b).must_equal "\e[31;1m"
+			_(e).must_equal "\e[0m"
+			_(l).must_equal "red"
 		end
 
 		it "Can get colors attributes" do
 			b,e=SimpleColor.current_colors(SimpleColor.color("red",:red,:bold))
-			SimpleColor.attributes_from_colors("\e[m"+b+e).must_equal([:reset,:red,:bright,:reset])
+			_(SimpleColor.attributes_from_colors("\e[m"+b+e)).must_equal([:reset,:red,:bright,:reset])
 		end
 
 		it "Can detect 256 and truecolor attributes" do
@@ -213,17 +213,17 @@ describe SimpleColor do
 			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)
+			_(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"])
+			_(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"])
+			_(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
 
@@ -233,30 +233,30 @@ describe SimpleColor do
 		end
 
 		it "Can color too" do
-			SimpleColor2.color("red", :red).must_equal "\e[31mred\e[0m"
+			_(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"
+			_(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"
+			_(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"
+			_(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"
+			_(string_class.new("red").color(:red)).must_equal "\e[31mred\e[0m"
 			SimpleColor2.enabled=false
-			string_class.new("red").color(:red).must_equal "red"
+			_(string_class.new("red").color(:red)).must_equal "red"
 			SimpleColor2.enabled=true
 		end
 
@@ -268,72 +268,72 @@ describe SimpleColor do
 				extend SimpleColor
 			end
 			SimpleColor.opts=default_opts
-			SimpleColor3.opts.must_equal 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
+			_(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
+			_(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
+			_(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"
+			_(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]
+			_(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"
+			_(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"
+			_(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"
+			_(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"
+			_(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"
+			_(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"
+			_(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"
+			_(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"
+			_(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"
+			_(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"
+			_(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])
+			_(SimpleColor.color(r, :blue)).must_equal(SimpleColor["red", :red])
 		end
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simplecolor
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Damien Robert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-02 00:00:00.000000000 Z
+date: 2020-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -80,6 +80,7 @@ extra_rdoc_files:
 - LICENSE.txt
 - README.md
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".travis.yml"
 - ".yardopts"
@@ -88,6 +89,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- TODO
 - bin/simplecolor.rb
 - data/NBS-ISCC_colors.json
 - data/Resene2010_colors.json
@@ -128,7 +130,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Simple color library