module Colorize::InstanceMethods

def background_color(color)


Color for background (offset 10)
def background_color(color)
  self.class.color_codes[color] + 10 if self.class.color_codes[color]
end

def color(color)


Color for foreground
def color(color)
  self.class.color_codes[color]
end

def color_from_symbol(match, symbol)


Set color from params symbol
def color_from_symbol(match, symbol)
  if self.class.prevent_colors && color(symbol)
    match[1] ||= color(symbol)
  else
    match[1] = color(symbol)
  end
end

def colorize(params)


puts "This is uncolorized".blue.on_red.uncolorize
puts "This is blue text on red".blue.on_red.blink
puts "This is red on blue and underline".colorize(:red).on_blue.underline
puts "This is red on blue".colorize(:red).on_blue
puts "This is blue text on red".blue.on_red
puts "This is light blue with red background".colorize(:light_blue ).colorize( :background => :red)
puts "This is light blue with red background".colorize(:color => :light_blue, :background => :red)
puts "This is also blue".colorize(:color => :blue)
puts "This is light blue".colorize(:light_blue)
puts "This is blue".colorize(:blue)

Examples:

Change color of string
def colorize(params)
  return self if self.class.disable_colorization
  scan_for_colors.inject(self.class.new) do |str, match|
    colors_from_params(match, params)
    defaults_colors(match)
    str << "\001\033[#{match[0]};#{match[1]};#{match[2]}m\002#{match[3]}\001\033[0m\002"
  end
end

def colorized?


Return true if string is colorized
def colorized?
  scan_for_colors.inject([]) do |colors, match|
    colors << match.tap(&:pop)
  end.flatten.compact.any?
end

def colors_from_hash(match, hash)


Set colors from params hash
def colors_from_hash(match, hash)
  if self.class.prevent_colors
    match[0] ||= mode(hash[:mode])                   if mode(hash[:mode])
    match[1] ||= color(hash[:color])                 if color(hash[:color])
    match[2] ||= background_color(hash[:background]) if background_color(hash[:background])
  else
    match[0] = mode(hash[:mode])                   if mode(hash[:mode])
    match[1] = color(hash[:color])                 if color(hash[:color])
    match[2] = background_color(hash[:background]) if background_color(hash[:background])
  end
end

def colors_from_params(match, params)


Set color from params
def colors_from_params(match, params)
  case params
  when Hash then colors_from_hash(match, params)
  when Symbol then color_from_symbol(match, params)
  end
end

def defaults_colors(match)


Set default colors
def defaults_colors(match)
  match[0] ||= mode(:default)
  match[1] ||= color(:default)
  match[2] ||= background_color(:default)
end

def mode(mode)


Mode
def mode(mode)
  self.class.mode_codes[mode]
end

def require_windows_libs


Require windows libs
def require_windows_libs
  require 'Win32/Console/ANSI' if RUBY_VERSION < '2.0.0' && RUBY_PLATFORM.include?('win32')
rescue LoadError
  raise 'You must gem install win32console to use colorize on Windows'
end

def scan_for_colors


Scan for colorized string
def scan_for_colors
  scan(/\001\033\[([0-9;]+)m\002(.+?)\001\033\[0m\002|([^\001\033]+)/m).map do |match|
    split_colors(match)
  end
end

def split_colors(match) 

def split_colors(match)
  colors = (match[0] || '').split(';')
  array = Array.new(3)
  array[0], array[1], array[2] = colors if colors.length == 3
  array[1] = colors                     if colors.length == 1
  array[3] = match[1] || match[2]
  array
end

def uncolorize


Return uncolorized string
def uncolorize
  scan_for_colors.inject(self.class.new) do |str, match|
    str << match[3]
  end
end