Sortie Rubis colorisé [fermée]

en combinant les réponses ci-dessus, vous pouvez implémenter quelque chose qui fonctionne comme la couleur gemme sans avoir besoin d'une autre dépendance.

class String
  # colorization
  def colorize(color_code)
    "\e[#{color_code}m#{self}\e[0m"
  end

  def red
    colorize(31)
  end

  def green
    colorize(32)
  end

  def yellow
    colorize(33)
  end

  def blue
    colorize(34)
  end

  def pink
    colorize(35)
  end

  def light_blue
    colorize(36)
  end
end

comme méthodes de classe de chaîne (unix seulement):

class String
def black;          "\e[30m#{self}\e[0m" end
def red;            "\e[31m#{self}\e[0m" end
def green;          "\e[32m#{self}\e[0m" end
def brown;          "\e[33m#{self}\e[0m" end
def blue;           "\e[34m#{self}\e[0m" end
def magenta;        "\e[35m#{self}\e[0m" end
def cyan;           "\e[36m#{self}\e[0m" end
def gray;           "\e[37m#{self}\e[0m" end

def bg_black;       "\e[40m#{self}\e[0m" end
def bg_red;         "\e[41m#{self}\e[0m" end
def bg_green;       "\e[42m#{self}\e[0m" end
def bg_brown;       "\e[43m#{self}\e[0m" end
def bg_blue;        "\e[44m#{self}\e[0m" end
def bg_magenta;     "\e[45m#{self}\e[0m" end
def bg_cyan;        "\e[46m#{self}\e[0m" end
def bg_gray;        "\e[47m#{self}\e[0m" end

def bold;           "\e[1m#{self}\e[22m" end
def italic;         "\e[3m#{self}\e[23m" end
def underline;      "\e[4m#{self}\e[24m" end
def blink;          "\e[5m#{self}\e[25m" end
def reverse_color;  "\e[7m#{self}\e[27m" end
end

et usage:

puts "I'm back green".bg_green
puts "I'm red and back cyan".red.bg_cyan
puts "I'm bold and green and backround red".bold.green.bg_red

sur ma console:

def no_colors
  self.gsub /\e\[\d+m/, ""
end

supprime les caractères de formatage

Note

puts "\e[31m" # set format (red foreground)
puts "\e[0m"   # clear format
puts "green-#{"red".red}-green".green # will be green-red-normal, because of \e[0

vous pouvez utiliser des séquences d'échappement ANSI pour faire cela sur la console. Je sais que cela fonctionne sur Linux et OSX, Je ne suis pas sûr que la console Windows (cmd) supporte ANSI.

je l'ai fait en Java, mais les idées sont les mêmes.

//foreground color
public static final String BLACK_TEXT()   { return "3[30m";}
public static final String RED_TEXT()     { return "3[31m";}
public static final String GREEN_TEXT()   { return "3[32m";}
public static final String BROWN_TEXT()   { return "3[33m";}
public static final String BLUE_TEXT()    { return "3[34m";}
public static final String MAGENTA_TEXT() { return "3[35m";}
public static final String CYAN_TEXT()    { return "3[36m";}
public static final String GRAY_TEXT()    { return "3[37m";}

//background color
public static final String BLACK_BACK()   { return "3[40m";}
public static final String RED_BACK()     { return "3[41m";}
public static final String GREEN_BACK()   { return "3[42m";}
public static final String BROWN_BACK()   { return "3[43m";}
public static final String BLUE_BACK()    { return "3[44m";}
public static final String MAGENTA_BACK() { return "3[45m";}
public static final String CYAN_BACK()    { return "3[46m";}
public static final String WHITE_BACK()   { return "3[47m";}

//ANSI control chars
public static final String RESET_COLORS() { return "3[0m";}
public static final String BOLD_ON()      { return "3[1m";}
public static final String BLINK_ON()     { return "3[5m";}
public static final String REVERSE_ON()   { return "3[7m";}
public static final String BOLD_OFF()     { return "3[22m";}
public static final String BLINK_OFF()    { return "3[25m";}
public static final String REVERSE_OFF()  { return "3[27m";}

j'ai écrit une petite méthode pour tester les modes de couleur de base, basée sur les réponses D'Erik Skoglund et d'autres.

#outputs color table to console, regular and bold modes
def colortable
  names = %w(black red green yellow blue pink cyan white default)
  fgcodes = (30..39).to_a - [38]

  s = ''
  reg  = "\e[%d;%dm%s\e[0m"
  bold = "\e[1;%d;%dm%s\e[0m"
  puts '                       color table with these background codes:'
  puts '          40       41       42       43       44       45       46       47       49'
  names.zip(fgcodes).each {|name,fg|
    s = "#{fg}"
    puts "%7s "%name + "#{reg}  #{bold}   "*9 % [fg,40,s,fg,40,s,  fg,41,s,fg,41,s,  fg,42,s,fg,42,s,  fg,43,s,fg,43,s,  
      fg,44,s,fg,44,s,  fg,45,s,fg,45,s,  fg,46,s,fg,46,s,  fg,47,s,fg,47,s,  fg,49,s,fg,49,s ]
  }
end

exemple de sortie:

alors que les autres réponses feront l'affaire pour la plupart des gens, la façon Unix "correcte" de le faire doit être mentionnée. Puisque tous les types de terminaux de texte ne supportent pas ces séquences, vous pouvez interroger la base de données terminfo , une abstraction sur les capacités de divers terminaux de texte. Cela peut sembler principalement d'intérêt historique – les terminaux logiciels utilisés aujourd'hui supportent généralement les séquences ANSI – mais cela a (au moins) un effet pratique: il est parfois utile de pouvoir définir la variable d'environnement TERM à dumb pour éviter tout style similaire, par exemple lors de l'enregistrement de la sortie dans un fichier texte. En outre, il se sent bien de faire des choses droit . :- )

vous pouvez utiliser le ruby-terminfo gem. Il a besoin d'un peu de C Compiler pour installer; j'ai été en mesure de l'installer sous mon système Ubuntu 14.10 avec:

$ sudo apt-get install libncurses5-dev
$ gem install ruby-terminfo --user-install

alors vous pouvez demander la base de données comme ceci (voir la terminfo man page pour une liste des codes disponibles):

require 'terminfo' 
TermInfo.control("bold")
puts "Bold text"
TermInfo.control("sgr0")
puts "Back to normal."
puts "And now some " + TermInfo.control_string("setaf", 1) + 
     "red" + TermInfo.control_string("sgr0") + " text."

Voici une petite classe d'emballage que j'ai mis ensemble pour rendre les choses un peu plus simple à utiliser.

require 'terminfo'

class Style
  def self.style() 
    @@singleton ||= Style.new
  end

  colors = %w{black red green yellow blue magenta cyan white}
  colors.each_with_index do |color, index|
    define_method(color) { get("setaf", index) }
    define_method("bg_" + color) { get("setab", index) }
  end

  def bold()  get("bold")  end
  def under() get("smul")  end
  def dim()   get("dim")   end
  def clear() get("sgr0")  end

  def get(*args)
    begin
      TermInfo.control_string(*args)
    rescue TermInfo::TermInfoError
      ""
    end
  end
end

Utilisation:

c = Style.style
C = c.clear
puts "#{c.red}Warning:#{C} this is #{c.bold}way#{C} #{c.bg_red}too much #{c.cyan + c.under}styling#{C}!"
puts "#{c.dim}(Don't you think?)#{C}"

(edit) enfin, si vous préférez ne pas avoir de Gemme, vous pouvez vous fier au programme tput , comme décrit ici - exemple de Ruby:

puts "Hi! " + `tput setaf 1` + "This is red!" + `tput sgr0`

j'en ai trouvé quelques-uns:

http://github.com/ssoroka/ansi/tree/master

exemples:

puts ANSI.color(:red) { "hello there" }
puts ANSI.color(:green) + "Everything is green now" + ANSI.no_color

http://flori.github.com/term-ansicolor /

exemples:

print red, bold, "red bold", reset, "\n"
print red(bold("red bold")), "\n"
print red { bold { "red bold" } }, "\n"

http://github.com/sickill/rainbow

exemple:

puts "this is red".foreground(:red) + " and " + "this on yellow bg".background(:yellow) + " and " + "even bright underlined!".underline.bright

si vous sont sur Windows, vous pouvez avoir besoin de faire un "gem installer win32console" pour activer le soutien des couleurs.

aussi l'article coloriser la sortie Ruby-script de la console est utile si vous avez besoin de créer votre propre gemme. Il explique comment ajouter la coloration ANSI aux cordes. Vous pouvez utiliser cette connaissance pour l'envelopper dans une classe qui étend la chaîne ou quelque chose.

voici ce que j'ai fait pour le faire fonctionner sans avoir besoin de gemmes:

def red(mytext) ; "\e[31m#{mytext}\e[0m" ; end
puts red("hello world")

alors seulement le texte dans les guillemets il est coloré, et vous êtes retourné à votre programme régulier.

j'ai fait cette méthode qui pourrait aider. Ce n'est pas grand chose mais ça marche:

def colorize(text, color = "default", bgColor = "default")
    colors = {"default" => "38","black" => "30","red" => "31","green" => "32","brown" => "33", "blue" => "34", "purple" => "35",
     "cyan" => "36", "gray" => "37", "dark gray" => "1;30", "light red" => "1;31", "light green" => "1;32", "yellow" => "1;33",
      "light blue" => "1;34", "light purple" => "1;35", "light cyan" => "1;36", "white" => "1;37"}
    bgColors = {"default" => "0", "black" => "40", "red" => "41", "green" => "42", "brown" => "43", "blue" => "44",
     "purple" => "45", "cyan" => "46", "gray" => "47", "dark gray" => "100", "light red" => "101", "light green" => "102",
     "yellow" => "103", "light blue" => "104", "light purple" => "105", "light cyan" => "106", "white" => "107"}
    color_code = colors[color]
    bgColor_code = bgColors[bgColor]
    return "3[#{bgColor_code};#{color_code}m#{text}3[0m"
end

Voici comment l'utiliser:

puts "#{colorize("Hello World")}"
puts "#{colorize("Hello World", "yellow")}"
puts "#{colorize("Hello World", "white","light red")}"

améliorations possibles pourraient être:

• colors et bgColors sont définis chaque fois que la méthode est appelée et ils ne changent pas.
• ajouter d'autres options comme bold , underline , dim , etc.

cette méthode ne fonctionne pas pour p , comme p fait un inspect à son argument. Par exemple:

p "#{colorize("Hello World")}"

"\e[0;38mHello Monde\e[0m"

Je l'ai testé avec puts , print , et le logger gem, et il fonctionne très bien.

j'ai amélioré cela et fait une classe de sorte que colors et bgColors sont des constantes de classe et colorize est une méthode de classe:

EDIT: amélioration du style de code, définition des constantes au lieu des variables de classe, utilisation de symboles au lieu de chaînes, ajout d'options telles que, gras, italiques, etc.

class Colorizator
    COLOURS = { default: '38', black: '30', red: '31', green: '32', brown: '33', blue: '34', purple: '35',
                cyan: '36', gray: '37', dark_gray: '1;30', light_red: '1;31', light_green: '1;32', yellow: '1;33',
                light_blue: '1;34', light_purple: '1;35', light_cyan: '1;36', white: '1;37' }.freeze
    BG_COLOURS = { default: '0', black: '40', red: '41', green: '42', brown: '43', blue: '44',
                   purple: '45', cyan: '46', gray: '47', dark_gray: '100', light_red: '101', light_green: '102',
                   yellow: '103', light_blue: '104', light_purple: '105', light_cyan: '106', white: '107' }.freeze

    FONT_OPTIONS = { bold: '1', dim: '2', italic: '3', underline: '4', reverse: '7', hidden: '8' }.freeze

    def self.colorize(text, colour = :default, bg_colour = :default, **options)
        colour_code = COLOURS[colour]
        bg_colour_code = BG_COLOURS[bg_colour]
        font_options = options.select { |k, v| v && FONT_OPTIONS.key?(k) }.keys
        font_options = font_options.map { |e| FONT_OPTIONS[e] }.join(';').squeeze
        return "\e[#{bg_colour_code};#{font_options};#{colour_code}m#{text}\e[0m".squeeze(';')
    end
end

Vous pouvez l'utiliser en faisant:

Colorizator.colorize "Hello World", :gray, :white
Colorizator.colorize "Hello World", :light_blue, bold: true
Colorizator.colorize "Hello World", :light_blue, :white, bold: true, underline: true

cela peut vous aider: sortie de rubis colorisé

j'ai trouvé les réponses ci-dessus pour être utile, mais ne correspondait pas à la facture si je voulais coloriser quelque chose comme la sortie de journal sans en utilisant des bibliothèques tierces. Ce qui suit a résolu le problème pour moi:

red = 31
green = 32
blue = 34

def color (color=blue)
  printf "3[#{color}m";
  yield
  printf "3[0m"
end

color { puts "this is blue" }
color(red) { logger.info "and this is red" }

j'espère que ça aidera!