Kolorowane wyjście Rubiego do terminala [zamknięte]

Używając Ruby, w jaki sposób mogę wykonać kolorowanie tekstu tła i pierwszego planu w celu uzyskania wyników w terminalu?

Pamiętam, że podczas programowania Pascal wszyscy pisaliśmy własne textcolor(…)procedury, aby nasze małe programy edukacyjne wyglądały ładniej i prezentacyjniej.

Jak mam kodować odpowiednik tego w Ruby?

Colorize to mój ulubiony klejnot! :-)

Sprawdź to:

https://github.com/fazibear/colorize

Instalacja:

gem install colorize

Stosowanie:

require 'colorize'

puts "I am now red".red
puts "I am now blue".blue
puts "Testing".yellow

Łącząc powyższe odpowiedzi, możesz zaimplementować coś, co działa jak koloryzacja klejnotów bez potrzeby innej zależności.

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

Jako metody klasy String (tylko Unix):

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

i użycie:

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

na mojej konsoli:

dodatkowy:

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

usuwa znaki formatujące

Uwaga

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

Napisałem małą metodę testowania podstawowych trybów kolorów, opartą na odpowiedziach Erika Skoglunda i innych.

#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

przykładowe dane wyjściowe:

Możesz użyć sekwencji ucieczki ANSI, aby to zrobić na konsoli. Wiem, że działa to w systemach Linux i OSX, nie jestem pewien, czy konsola Windows (cmd) obsługuje ANSI.

Zrobiłem to w Javie, ale pomysły są takie same.

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

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

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

Podczas gdy inne odpowiedzi dobrze wykonają zadanie dla większości ludzi, należy wspomnieć o „poprawnym” uniksowym sposobie zrobienia tego. Ponieważ wszystkie typy terminali tekstowych nie obsługują tych sekwencji, możesz przeszukać bazę danych terminfo , co jest abstrakcją dotyczącą możliwości różnych terminali tekstowych. To może wydawać się głównie historycznych odsetki - terminale oprogramowania stosowanego obecnie powszechnie wspierać sekwencje ANSI - ale to ma (przynajmniej) jeden efekt praktyczny: czasem jest to użyteczne, aby móc ustawić zmienną środowiskową TERMaby dumbuniknąć wszelkich takiej stylizacji, na przykład podczas zapisywania wyniku w pliku tekstowym. Ponadto dobrze jest robić dobrze . :-)

Możesz użyć klejnotu ruby-terminfo . Do zainstalowania wymaga kompilacji w języku C; Byłem w stanie zainstalować go w moim systemie Ubuntu 14.10 z:

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

Następnie możesz wykonać zapytanie do bazy danych w ten sposób (zobacz stronę podręcznika terminfo, aby uzyskać listę dostępnych kodów):

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."

Oto mała klasa opakowań, którą ułożyłem, aby uczynić rzeczy nieco prostszymi w użyciu.

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

Stosowanie:

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

(edytuj) Wreszcie, jeśli wolisz nie wymagać klejnotu, możesz polegać na tputprogramie, jak opisano tutaj - przykład Rubiego:

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

Zrobiłem tę metodę, która może pomóc. To nie jest wielka sprawa, ale działa:

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 "\033[#{bgColor_code};#{color_code}m#{text}\033[0m"
end

Oto jak go użyć:

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

Możliwe ulepszenia mogą być:

• colorsi bgColorssą definiowane za każdym razem, gdy wywoływana jest metoda, i nie zmieniają się.
• Dodaj inne opcje jak bold, underline, dim, itd.

Ta metoda nie działa p, tak jak probi inspectdo jego argumentacji. Na przykład:

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

pokaże „\ e [0; 38mWitaj świat \ e [0m”

Przetestowałem to za pomocą puts, printi klejnot Logger, i działa dobrze.

Poprawiłem to i tak wykonane klasę colorsi bgColorssą stałymi klasy i colorizejest to metoda klasy:

EDYCJA: Lepszy styl kodu, zdefiniowane stałe zamiast zmiennych klas, użycie symboli zamiast łańcuchów, dodano więcej opcji, takich jak, pogrubienie, kursywa itp.

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

Możesz z niego skorzystać, wykonując:

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

Oto, co zrobiłem, aby działało bez potrzeby używania klejnotów:

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

Wtedy tylko tekst w cytatach jest kolorowy i wracasz do regularnie zaplanowanego programu.

Znalazłem kilka:

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

Przykłady:

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

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

Przykłady:

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

http://github.com/sickill/rainbow

Przykład:

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

Jeśli korzystasz z systemu Windows, może być konieczne wykonanie „gem install win32console”, aby włączyć obsługę kolorów.

Również artykuł Kolorowanie danych wyjściowych skryptu Ruby-skrypt jest przydatne, jeśli chcesz stworzyć własny klejnot. Wyjaśnia, jak dodać kolorowanie ANSI do łańcuchów. Możesz wykorzystać tę wiedzę do zawinięcia jej w jakąś klasę, która rozszerza łańcuch znaków lub coś takiego.

To może ci pomóc: Pokolorowane wyjście ruby

Uznałem, że powyższe odpowiedzi są przydatne, ale nie pasowały do ​​rachunku, gdybym chciał pokolorować dane wyjściowe dziennika bez korzystania z bibliotek stron trzecich. Dla mnie problem został rozwiązany:

red = 31
green = 32
blue = 34

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

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

Mam nadzieję, że to pomoże!