Module: SimpleColor::Colorer

Extended by:
Colorer
Included in:
Colorer
Defined in:
lib/simplecolor/colorer.rb,
lib/simplecolor/colors.rb

Overview

The Colorer module handle all color outputs

Constant Summary collapse

CLEAR =

Regular expression to scan if there is a clear ANSI effect

"\e\[0m"
CLEAR_REGEXP = 
/\e\[0m/
ANSICOLOR_REGEXP =

Regular expression that is used to scan for ANSI-sequences

/\e\[(?:[\d;]*)m/
COLOR_REGEXP = 
/#{ANSICOLOR_REGEXP}+/
COLORMATCH_REGEXP = 
/#{ANSICOLOR_REGEXP}*/
ANSI_COLORS =

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

{
	:black	 => 0,
	:red		 => 1,
	:green	 => 2,
	:yellow  => 3,
	:blue		 => 4,
	:magenta => 5,
	:cyan		 => 6,
	:white	 => 7,
	:default => 9,
}
ANSI_COLORS_FOREGROUND = 
Hash[ANSI_COLORS.map {|k,v| [k, 30+v]
ANSI_COLORS_BACKGROUND = 

      
        
ANSI_COLORS_INTENSE_FOREGROUND =
          

  

    
aixterm (not standard)



  





  



        

        

      
        
ANSI_COLORS_INTENSE_BACKGROUND =
          
        

        

      
        
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,
}

      
        
COLORS =
          

  

    
attributes that can be specified to the color method



  





  



        

        
[ANSI_EFFECTS,ANSI_COLORS_FOREGROUND, ANSI_COLORS_BACKGROUND, ANSI_COLORS_INTENSE_FOREGROUND, ANSI_COLORS_INTENSE_BACKGROUND].inject({}){ |a,b| a.merge(b) }

      
    

  







  
    

      Instance Method Summary
      collapse
    


    
  



  

    
Instance Method Details


    
      

  

  
    #color_attributes(*args, mode: :text, color_mode: :truecolor, abbreviations: {}, rgb_class: RGB, **rgb_parse_opts)  ⇒ Object 
  

  

  




  

    
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
    • 




  





  



  

    
      


30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

    		
    
      
# File 'lib/simplecolor/colorer.rb', line 30

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_)?/
		# 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
			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

    		
  





    
      

  

  
    #colored?(s, **kwds)  ⇒ Boolean 
  

  

  




  

    

  





  

Returns:


    
  
    
  • 
      
      
        (Boolean)
      
      
      
    
    • 
  





  

    
      


226
227
228

    		
    
      
# File 'lib/simplecolor/colorer.rb', line 226

def colored?(s, **kwds)
	!! (s =~ regexp(:color, **kwds))
end

    		
  





    
      

  

  
    #colorer(s, *attributes, global_color: :after, local_color: :before, **kwds)  ⇒ Object 
  

  

  




  

    
Returns a colored version of the string (modified in place),
according to attributes



  





  



  

    
      


139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215

    		
    
      
# File 'lib/simplecolor/colorer.rb', line 139

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

    		
  





    
      

  

  
    #colors  ⇒ Object 
  

  

  




  

    
      


9
10
11

    		
    
      
# File 'lib/simplecolor/colorer.rb', line 9

def colors
	COLORS
end

    		
  





    
      

  

  
    #regexp(type = :color, mode: :text, **_rest)  ⇒ Object 
  

  

  




  

    
      


106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

    		
    
      
# File 'lib/simplecolor/colorer.rb', line 106

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

    		
  





    
      

  

  
    #uncolorer(s, **kwds)  ⇒ Object 
  

  

  




  

    
Returns an uncolored version of the string, that is all
ANSI-sequences are stripped from the string.
@see: colorer



  





  



  

    
      


220
221
222
223
224

    		
    
      
# File 'lib/simplecolor/colorer.rb', line 220

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