Colorindo seu ambiente de terminal e shell?

234

Passo a maior parte do tempo trabalhando em ambientes Unix e usando emuladores de terminal. Eu tento usar cores na linha de comando, porque a cor torna a saída mais útil e intuitiva.

Quais opções existem para adicionar cor ao meu ambiente de terminal? Que truques você usa? Quais armadilhas você encontrou?

Infelizmente, o suporte para cores varia dependendo do tipo de terminal, sistema operacional, configuração do TERM, utilitário, implementações com bugs, etc.

Aqui estão algumas dicas da minha configuração, depois de muita experimentação:

  1. Tenho a tendência de definir TERM=xterm-color , que é suportado na maioria dos hosts (mas não em todos).
  2. Eu trabalho em vários hosts diferentes, diferentes versões do SO, etc. Eu uso tudo do macOS X, Ubuntu Linux, RHEL / CentOS / Linux Científico e FreeBSD. Estou tentando manter as coisas simples e genéricas, se possível.
  3. Eu faço um monte de trabalho usando o GNU screen , que adiciona outra camada de diversão.
  4. Muitos sistemas operacionais configuram coisas como dircolors e, por padrão, não queremos modificar isso em centenas de hosts diferentes. Então eu tento ficar com os padrões. Em vez disso, modifico a configuração de cores do meu terminal.
  5. Use cores para alguns comandos do Unix ( ls , grep , less , vim ) e o Bash prompt . Estes comandos parecem usar o padrão " seqüências de escape ANSI ". Por exemplo:

    alias less='less --RAW-CONTROL-CHARS'
    export LS_OPTS='--color=auto'
    alias ls='ls ${LS_OPTS}
    

Vou postar meu .bashrc e responder minha própria pergunta sobre o Jeopardy Style.

    
por Stefan Lasiewski 10.08.2010 / 23:21

21 resposta

108

Aqui estão algumas coisas que você pode fazer:

Editores + Código
Muitos editores têm suporte a destaque de sintaxe. vim e emacs estão ativados por padrão. Você também pode habilitá-lo em nano .

Você também pode sintonizar o código de destaque no terminal usando Pygments como um comando. ferramenta de linha.

grep
grep --color=auto realça todas as correspondências. Você também pode usar export GREP_OPTIONS='--color=auto' para torná-lo persistente sem um alias. Se você usar --color=always , usará a cor mesmo ao canalizar , que confunde as coisas.

ls

ls --color=always

Cores especificadas por:

export LS_COLORS='rs=0:di=01;34:ln=01;36:mh=00:pi=40;33'

(dica: dircolors pode ser útil)

PS1
Você pode definir seu PS1 (prompt do shell) para usar cores. Por exemplo:

PS1='\e[33;1m\u@\h: \e[31m\W\e[0m\$ '

Produzirá um PS1 como:

[amarelo] lucas @ ubuntu: [vermelho] ~ [normal] $

Você pode ser realmente criativo com isso. Como uma ideia:

PS1='\e[s\e[0;0H\e[1;33m\h    \t\n\e[1;32mThis is my computer\e[u[\u@\h:  \w]\$ '

Coloca uma barra no topo do seu terminal com algumas informações aleatórias. (Para melhores resultados, use também alias clear="echo -e '\e[2J\n\n'" .)

Livrar-se das sequências de escape

Se algo não der certo quando você não quiser, eu uso essa linha sed para remover as sequências de escape:

sed "s/\[^[[0-9;]*[a-zA-Z]//gi"

Se você quer uma experiência mais autêntica, você também pode se livrar das linhas que começam com \e[8m , que instrui o terminal a ocultar o texto. (Não amplamente suportado.)

sed "s/^\[^[8m.*$//gi"

Observe também que esses ^ [s devem ser reais, literal ^ [s. Você pode digitá-los pressionando ^ V ^ [no bash, que é Ctrl + V , Ctrl + [ .

    
por 10.08.2010 / 23:28
70

Eu também uso:

export TERM=xterm-color
export GREP_OPTIONS='--color=auto' GREP_COLOR='1;32'
export CLICOLOR=1
export LSCOLORS=ExFxCxDxBxegedabagacad

E se você gosta de colorir seu prompt, as variantes de cores definidas podem ser úteis:

export COLOR_NC='\e[0m' # No Color
export COLOR_WHITE='\e[1;37m'
export COLOR_BLACK='\e[0;30m'
export COLOR_BLUE='\e[0;34m'
export COLOR_LIGHT_BLUE='\e[1;34m'
export COLOR_GREEN='\e[0;32m'
export COLOR_LIGHT_GREEN='\e[1;32m'
export COLOR_CYAN='\e[0;36m'
export COLOR_LIGHT_CYAN='\e[1;36m'
export COLOR_RED='\e[0;31m'
export COLOR_LIGHT_RED='\e[1;31m'
export COLOR_PURPLE='\e[0;35m'
export COLOR_LIGHT_PURPLE='\e[1;35m'
export COLOR_BROWN='\e[0;33m'
export COLOR_YELLOW='\e[1;33m'
export COLOR_GRAY='\e[0;30m'
export COLOR_LIGHT_GRAY='\e[0;37m'

E, então, minha solicitação é algo assim:

case $TERM in
     xterm*|rxvt*)
         local TITLEBAR='\[3]0;\u ${NEW_PWD}
export TERM=xterm-color
export GREP_OPTIONS='--color=auto' GREP_COLOR='1;32'
export CLICOLOR=1
export LSCOLORS=ExFxCxDxBxegedabagacad
7\]' ;; *) local TITLEBAR="" ;; esac local UC=$COLOR_WHITE # user's color [ $UID -eq "0" ] && UC=$COLOR_RED # root's color PS1="$TITLEBAR\n\[${UC}\]\u \[${COLOR_LIGHT_BLUE}\]\${PWD} \[${COLOR_BLACK}\]\$(vcprompt) \n\[${COLOR_LIGHT_GREEN}\]→\[${COLOR_NC}\] "

$ (vcprompt) está chamando um script python no meu ~ / sbin que imprime informações de controle de versão sobre o caminho atual. Inclui suporte para Mercurial, Git, Svn, Cvs, etc. O autor do script tem a fonte aqui .

Estaéa fonte completa da minha configuração de prompt:

    
por 11.08.2010 / 00:57
18

grep e ls já foram mencionados, se você quiser muito mais cores, confira Colorizer genérico , seu objetivo inicial era colorir os arquivos de log, mas logo de cara ele também coloria ping , traceroute , gcc , make , netstat , diff , last , ldap e cvs .

É facilmente estendido se você conhece regexes. Eu adicionei ps e nmap à lista (se você entrar em grc , eu ficarei mais do que feliz em compartilhar os arquivos .conf para essas duas ferramentas)

(Btw, para instalá-lo via synaptic , pacman , e você pode ter mais sorte em pesquisar "grc")

    
por 10.08.2010 / 23:57
11

Eu aperfeiçoei meu .bashrc ao longo dos anos para trabalhar tanto no OSX quanto no Ubuntu.
Eu também reduzi o tamanho para 28 linhas com instruções de condição compactas. Com isso, meu prompt do PS1 se parece com:

comtempoemvermelho,nomedeusuárioemverde,nomedamáquinaemazulclaro,pwdemazulmaisescuroegitbranchemamarelo.

RecursodomeupromptdoPS1:

  • mostraramificaçãogit!
  • caminhosdediretóriolongos(maisde6elementos)são"aparados" para mostrar os três principais diretórios 3 e 3 com _ entre eles (essa é a pwd sed parte de LOCATION).
  • retorno de carro no final para que a solicitação esteja sempre à esquerda!

As linhas relevantes do meu arquivo .bashrc são:

git_branch () { git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)//'; }
HOST='3[02;36m\]\h'; HOST=' '$HOST
TIME='3[01;31m\]\t 3[01;32m\]'
LOCATION=' 3[01;34m\]'pwd | sed "s#\(/[^/]\{1,\}/[^/]\{1,\}/[^/]\{1,\}/\).*\(/[^/]\{1,\}/[^/]\{1,\}\)/\{0,1\}#_#g"''
BRANCH=' 3[00;33m\]$(git_branch)\[3[00m\]\n\$ '
PS1=$TIME$USER$HOST$LOCATION$BRANCH
PS2='\[3[01;36m\]>'

Para ls com cores quando disponíveis e sem erros quando não (ou seja, OSX):

ls --color=al > /dev/null 2>&1 && alias ls='ls -F --color=al' || alias ls='ls -G'
    
por 13.01.2015 / 03:30
8

Defina um aviso em negrito / colorido. De cyberciti.biz e o BashFAQ

# 'tput bold' will work regardless of the foreground and background colors.
# Place the tput output into variables, so they are only execd once.
bold=$(tput bold) # This could also be a color.
reset=$(tput sgr0)
export PS1="\u@\[$bold\]\h\[$reset\]:\w \$ "

Eu também consegui encontrar configurações de cores que são amplamente suportadas, e que não imprimem caracteres de gobbledygook em ambientes antigos (mesmo FreeBSD4!), e parece funcionar bem se TERM = vt100, xterm, xterm-color. (Para a maior parte). Do meu .bashrc:

# Set some options, based on the OS
OS='uname -s' 

case "$OS" in
    "SunOS" ) 
        # Solaris ls doesn't allow color, so use special characters
        LS_OPTS='-F'
        alias  ls='ls ${LS_OPTS}'
        ;;
    "Linux" )
        # GNU ls supports colors!
        # See dircolors to customize colors
        export LS_OPTS='--color=auto' 
        alias  ls='ls ${LS_OPTS}'

        # Get color support for 'less'
        export LESS="--RAW-CONTROL-CHARS"

        # Use colors for less, man, etc.
        [[ -f ~/.LESS_TERMCAP ]] && . ~/.LESS_TERMCAP

        export GREP_OPTIONS="--color=auto"

        ;;
    "Darwin"|"FreeBSD")

        # Most FreeBSD & Apple Darwin supports colors
        export CLICOLOR=true
        # Get color support for 'less'
        export LESS="--RAW-CONTROL-CHARS"

        # Use colors for less, man, etc.
        [[ -f ~/.LESS_TERMCAP ]] && . ~/.LESS_TERMCAP

        export GREP_OPTIONS="--color=auto"
        ;;
    * ) 
        echo "Unknown OS [$OS]"
        ;;
esac
    
por 10.08.2010 / 23:24
8

Cores para man pages ( mais detalhes ):

function _colorman() {
  env \
    LESS_TERMCAP_mb=$(printf "\e[1;35m") \
    LESS_TERMCAP_md=$(printf "\e[1;34m") \
    LESS_TERMCAP_me=$(printf "\e[0m") \
    LESS_TERMCAP_se=$(printf "\e[0m") \
    LESS_TERMCAP_so=$(printf "\e[7;40m") \
    LESS_TERMCAP_ue=$(printf "\e[0m") \
    LESS_TERMCAP_us=$(printf "\e[1;33m") \
      "$@"
}
function man() { _colorman man "$@"; }
function perldoc() { command perldoc -n less "$@" |man -l -; }

Cores para grep ( 1;32 é verde brilhante, veja outros posts aqui para outras cores):

GREP_OPTS='--color=auto'      # for aliases since $GREP_OPTIONS is deprecated
GREP_COLOR='1;32'             # (legacy) bright green rather than default red
GREP_COLORS="ms=$GREP_COLOR"  # (new) Matching text in Selected line = green
alias   grep='grep $GREP_OPTS'
alias egrep='egrep $GREP_OPTS'
alias fgrep='fgrep $GREP_OPTS'

Mais cores para GNU ls :

# use the config at ~/.dircolors if it exists, otherwise generate anew
eval "$( dircolors --sh $(ls -d ~/.dircolors 2>/dev/null) )"

# Usage: _ls_colors_add BASE NEW [NEW...]
# Have LS color given NEW extensions the way BASE extension is colored
_ls_colors_add() {
  local BASE_COLOR="${LS_COLORS##*:?.$1=}" NEW
  if [ "$LS_COLORS" != "$BASE_COLOR" ]; then
    BASE_COLOR="${BASE_COLOR%%:*}"
    shift
    for NEW in "$@"; do
      if [ "$LS_COLORS" = "${LS_COLORS#*.$NEW=}" ]; then
        LS_COLORS="${LS_COLORS%%:}:*.$NEW=$BASE_COLOR:"
      fi
    done
  fi
  export LS_COLORS
}

_ls_colors_add zip jar xpi            # archives
_ls_colors_add jpg ico JPG PNG webp   # images
_ls_colors_add ogg opus               # audio (opus now included by default)

CLICOLOR=1   # BSD auto-color trigger (like  ls -G  but for everything)
if ls -ld --color=auto / >/dev/null 2>&1
  then alias ls="ls -ph --color=auto"
  else alias ls="ls -ph"
fi

Instale o grc ( Generic Colouriser ) e adicione-o aos seus aliases:

# using this as a variable allows easier calling down lower
export GRC='grc -es --colour=auto'

# loop through known commands plus all those with named conf files
for cmd in g++ head ld ping6 tail traceroute6 'locate grc/conf.'; do
  cmd="${cmd##*grc/conf.}"  # we want just the command
  # if the command exists, alias it to pass through grc
  type "$cmd" >/dev/null 2>&1 && alias "$cmd"="$GRC $cmd"
done

# This needs run-time detection. We even fake the 'command not found' error.
configure() {
  if [[ -x ./configure ]]; then
    colourify ./configure "$@"
  else
    echo "configure: command not found" >&2
    return 127
  fi
}

# GRC plus LS awesomeness (assumes you have an alias for ls)
unalias ll 2>/dev/null
if ls -ld --color=always / >/dev/null 2>&1; then GNU_LS="--color=always"; fi

ll() {
  if [[ -t 1 ]] || [[ -n "$CLICOLOR_FORCE" ]]
    then colourify ls -l $GNU_LS "$@"
    else ls -l "$@"
  fi
}

Cores para diff : Muito conteúdo para uma função, use um script e alias no seu arquivo rc (desnecessário se você instalou grc ):

#!/usr/bin/perl
use strict;
use warnings;

open (DIFF, "-|", "diff", @ARGV) or die $!;

my $ydiff = 1;
while (<DIFF>) {
  if (not -t 1) {
    print;
    next;
  }
  chomp;
  $ydiff = 0 if /^[ <>\@+-]/ or ($. == 1 && /^\d+[a-z]{1,5}\d+$/);
  my $color = "";
  if (! $ydiff && /^[\@+-<>]/) {
    $color = (/^[<-](?!--$)/ ? 1 : /^[+>]/ ? 2 : 5);
  } elsif ($ydiff && /\t {6}([<|>])(?:\t|$)/) {
    $color = ($1 eq "<" ? 1 : $1 eq ">" ? 2 : 4);
  }
  $color ? printf ("\e[1;3%dm%s\e[0;0m\n",$color,$_) : print "$_\n";
}
close DIFF;

Cores para prompt do bash :

# Shorten home dir, cygwin drives, paths that are too long
if [ -d /cygdrive ] && uname -a |grep -qi cygwin; then CYGWIN_OS=1; fi
function PSWD() {
  local p="$*" space A B cols="${COLUMNS:-'tput cols 2>/dev/null || echo 80'}"
  p="${p/$HOME/\~}"         # shrink home down to a tilde
  if [ -n "$CYGWIN_OS" ] && [ "${p#/cygdrive/?/}" != "$p" ]; then
    p="${p:10:1}:${p:11}"   # /cygdrive/c/hi -> c:/hi
  fi
  space="$((${#USER}+${#HOSTNAME}+6))"  # width w/out the path
  if [ "$cols" -lt 60 ]; then echo -n "$N "; space=-29; p="$p$N\b"; fi
  if [ "$cols" -lt "$((space+${#p}+20))" ]; then # < 20 chars for the command
    A=$(( (cols-20-space)/4 ))      # a quarter of the space (-20 for cmd)
    if [ $A -lt 4 ]; then A=4; fi   # 4+ chars from beginning
    B=$(( cols-20-space-A*2 ))      # half (plus rounding) of the space
    if [ $B -lt 8 ]; then B=8; fi   # 8+ chars from end
    p="${p:0:$A}..${p: -$B}"
  fi
  echo "$p"
}

PSC() { echo -ne "\[3[${1:-0;38}m\]"; }
PR="0;32"       # default color used in prompt is green
if [ "$(id -u)" = 0 ]; then
    sudo=41     # root is red background
  elif [ "$USER" != "${SUDO_USER:-$USER}" ]; then
    sudo=31     # not root, not self: red text
  else sudo="$PR"   # standard user color
fi
PROMPT_COMMAND='[ $? = 0 ] && PS1=${PS1[1]} || PS1=${PS1[2]}'
PSbase="$(PSC $sudo)\u$(PSC $PR)@\h $(PSC 33)\$(PSWD \w)"
PS1[1]="$PSbase$(PSC $PR)\$ $(PSC)"
PS1[2]="$PSbase$(PSC  31)\$ $(PSC)"
PS1="${PS1[1]}"
unset sudo PR PSbase

    
por 13.01.2015 / 03:04
5

Há uma boa ferramenta para configurar suas cores para o comando ls - link

    
por 11.08.2010 / 13:46
5

Coisas que ainda não foram ditas aqui:

Para colorir a saída de suas compilações com o gcc, há o colorgcc de Johannes Schlüter

Para colorir os logs, há multitail

Para colorir qualquer stdout, eu reunimos xcol

Eupessoalmenteusoissodaferramentaxcol.

#normal=$(tputsgr0)#normaltextnormal=$'\e[0m'#(worksbettersometimes)bold=$(tputbold)#makecolorsbold/brightred="$bold$(tput setaf 1)"                # bright red text
green=$(tput setaf 2)                     # dim green text
fawn=$(tput setaf 3); beige="$fawn"       # dark yellow text
yellow="$bold$fawn"                       # bright yellow text
darkblue=$(tput setaf 4)                  # dim blue text
blue="$bold$darkblue"                     # bright blue text
purple=$(tput setaf 5); magenta="$purple" # magenta text
pink="$bold$purple"                       # bright magenta text
darkcyan=$(tput setaf 6)                  # dim cyan text
cyan="$bold$darkcyan"                     # bright cyan text
gray=$(tput setaf 7)                      # dim white text
darkgray="$bold"$(tput setaf 0)           # bold black = dark gray text
white="$bold$gray"                        # bright white text

Eu uso essas variáveis em meus scripts como

echo "${red}hello ${yellow}this is ${green}coloured${normal}"

Eu também gosto dessa pequena função coloredEcho (encontrada no Stack Overflow)

function coloredEcho(){
    local exp=$1;
    local color=$2;
    if ! [[ $color =~ '^[0-9]$' ]] ; then
       case $(echo $color | tr '[:upper:]' '[:lower:]') in
        black) color=0 ;;
        red) color=1 ;;
        green) color=2 ;;
        yellow) color=3 ;;
        blue) color=4 ;;
        magenta) color=5 ;;
        cyan) color=6 ;;
        white|*) color=7 ;; # white or invalid color
       esac
    fi
    tput setaf $color;
    echo $exp;
    tput sgr0;
}

coloredEcho "This text is green" green

Desculpe, não é permitido postar mais links

    
por 25.01.2017 / 12:37
4

Sugiro que verifique o ZSH e o seu plug-in oh-meu-zsh que possui um dos recursos de console mais poderosos que eu vi. Um deles é escolher o tema para o seu terminal. Este é o exemplo do meu tema ... Em tty as cores não são tão quentes, mas são as mesmas como nesta foto ... De qualquer maneira você vai adorar!

    
por 15.05.2015 / 21:59
3

Alguma decoração de texto (negrito) para diferenciar facilmente entre casca raiz e não-raiz. Para Zsh:

if test $UID = 0
    then PS1="%B${PS1}%b "
fi

Para Bash:

if test $UID = 0
    then PS1="3[1m${PS1}3[0m"
fi
    
por 26.01.2012 / 10:10
3

Eu só queria saber a mesma coisa. Eu tenho minha própria abordagem, mas estou procurando alternativas.

Eu escrevo wrappers bash em torno de chamadas de programa e canalizo sua saída através de sed . O que eu gosto sobre sed é que ele irá modificar e ecoar cada linha imediatamente = > não muito buffer. No entanto, eu não gosto que para cada chamada para um programa embrulhado o código sed é analisado e compilado.

Por exemplo, isso é o que eu faço para colorir a saída de ip :

#
# Colorcodes
#
NORMAL='echo -e '3[0m''
RED='echo -e '3[31m''
GREEN='echo -e '3[0;32m''
LGREEN='echo -e '3[1;32m''
BLUE='echo -e '3[0;34m''
LBLUE='echo -e '3[1;34m''
YELLOW='echo -e '3[0;33m''


#
# command: ip
# highlight ip addresses, default route and interface names
#

IP4=$GREEN
IP6=$LBLUE
IFACE=${YELLOW}
DEFAULT_ROUTE=$LBLUE

IP_CMD=$(which ip)

function colored_ip()
{
${IP_CMD} $@ | sed \
    -e "s/inet [^ ]\+ /${IP4}&${NORMAL}/g"\
    -e "s/inet6 [^ ]\+ /${IP6}&${NORMAL}/g"\
    -e "s/^default via .*$/${DEFAULT_ROUTE}&${NORMAL}/"\
    -e "s/^\([0-9]\+: \+\)\([^ \t]\+\)/${IFACE}${NORMAL}/"
}

alias ip='colored_ip'
    
por 09.04.2013 / 17:49
3

Para ver a saída do diff em cores, use colordiff .

sudo apt-get install colordiff

Canaliza qualquer saída no formato diff para o colordiff:

Isso inclui alguns dos formatos alternativos do diff, como -y (lado a lado).

Como alternativa, se for invocado de modo autônomo (sem que nada seja enviado), ele atuará como um wrapper em torno de 'diff' e colore a saída. Daí eu tenho isso no meu .bashrc, para alias 'diff' para colordiff.

# if colordiff is installed, use it
if type colordiff &>/dev/null ; then
    alias diff=colordiff
    
por 25.07.2015 / 22:12
2

Você também pode tentar um projeto que ajude a colorir a saída de scripts, chamado ScriptEchoColor na fonte forge: link

ex .:

echoc "@{lr}text output in light red"
echoc "@{bLGu}text outpus in blue, light green background and underlined"
echoc "you @{lr} can @{bLGu} mix @{-a} it all too"
echoc -x "ls" #executes ls command and colorizes it automatically to be easy to be seen

As cores automáticas são configuráveis.

Este é um exemplo feito com ele:

    
por 26.04.2013 / 05:27
2

Para definir o prompt, eu tenho isso no meu arquivo .bashrc.

#Set variables for foreground colors
fgRed=$(tput setaf 1)     ; fgGreen=$(tput setaf 2)  ; fgBlue=$(tput setaf 4)
fgMagenta=$(tput setaf 5) ; fgYellow=$(tput setaf 3) ; fgCyan=$(tput setaf 6)
fgWhite=$(tput setaf 7)   ; fgBlack=$(tput setaf 0)
#Set variables for background colors
bgRed=$(tput setab 1)     ; bgGreen=$(tput setab 2)  ; bgBlue=$(tput setab 4)
bgMagenta=$(tput setab 5) ; bgYellow=$(tput setab 3) ; bgCyan=$(tput setab 6)
bgWhite=$(tput setab 7)   ; bgBlack=$(tput setab 0)
#Set variables for font weight and text decoration
B=$(tput bold) ; U=$(tput smul) ; C=$(tput sgr0)
#NOTE: ${C} clears the current formatting

if [[ $USER = "root" ]]; then
  PS1="${B}${fgRed}\u${C}@\h(\s): ${fgGreen}\w${C} > "
else
  PS1="${B}${fgCyan}\u${C}@\h(\s): ${fgGreen}\w${C} > "
fi

Isso me fornece um prompt parecido com isto:

user@host(bash): ~/bin >

O diretório de trabalho está em verde. E o nome do usuário é em negrito e ciano, a menos que eu execute o shell com sudo . Nesse caso, o nome do usuário ("root") é exibido em negrito e vermelho.

Pessoalmente, gosto de ter os caracteres de controle de formatação armazenados em variáveis porque isso facilita a leitura do código para definir o prompt. Isso também torna a edição do prompt muito mais fácil.

O motivo pelo qual eu uso o tput é que ele deveria ser mais universalmente suportado do que as estranhas 033[01;31m\] seqüências. Além disso, como um bônus adicional, se você executar echo $PS1 no prompt, verá o prompt bruto com cores em vez das sequências de controle ininteligíveis.

    
por 15.05.2015 / 03:35
2

Uma excelente ferramenta Python para colorir a saída de comandos é a colout '

Você dá uma regex com N grupos, seguido por uma lista separada por vírgulas de N cores. Qualquer texto que corresponda a um grupo será exibido na cor correspondente.

Por exemplo, se você está olhando para algum resultado de teste:

python -m unittest discover -v

entãovocêpodeenfeitá-locom:

python-munittestdiscover-v2>&1|colout'(.*ERROR$)|(.*FAIL$)|(\(.*\))'red,yellow,blackbold

Veja como meu regex tem três grupos (o parêntese) seguidos de três cores (e, opcionalmente, três estilos, mas usei um atalho para definir todas as cores como 'negrito'), para que o grupo 'preto' corresponda texto entre parênteses, sai em cinza escuro.)

Note também como eu tive que adicionar 2>&1 ao final da invocação do Python, porque a saída do unittest está no stderr, então eu o transferi para o stdout para que eu pudesse canalizar para o colout.

Geralmente isso é tão fácil de usar que muitas vezes me vejo criando novas invocações colout on-the-fly, e reutilizando ou modificando-as do meu histórico de linha de comando.

A única desvantagem é que ele vem como um pacote Python, não um executável autônomo, então você precisa instalá-lo usando pip, ou sudo python setup.py install .

    
por 25.07.2015 / 21:52
2

Acho que o Solarized é útil. É um projeto limpo com cores uniformes para muitas aplicações.

link link

    
por 31.08.2016 / 01:06
1

Eu uso o color wrapper .

cw is a non-intrusive real-time ANSI color wrapper for common unix-based commands on GNU/linux. cw is designed to simulate the environment of the commands being executed, so that if a person types 'du', 'df', 'ping', etc. in their shell it will automatically color the output in real-time according to a definition file containing the color format desired. cw has support for wildcard match coloring, tokenized coloring, headers/footers, case scenario coloring, command line dependent definition coloring, and includes over 50 pre-made definition files.

É quase perfeito, mas quando descobri que o ps no shell interativo retorna resultados diferentes comparando ps em um pipe.

    
por 27.04.2018 / 08:09
0

Para Mac, você pode usar o seguinte, conforme especificado aqui

if [ "$TERM" = xterm ]; then TERM=xterm-256color; fi
    
por 10.03.2015 / 19:44
0

Se você quiser tornar seu vim colorido como eu, sugiro que siga duas etapas:

  1. saiba como ativar o recurso seguindo este link: ligar Sintaxe de cor destacada no vi ou no vim .

key steps in the link:

  1. Edit ~/.vimrc file by typing the command: vi ~/.vimrc

  2. Append the following option:syntax on

  3. Save and close the file

  4. Test it by running vim command: vim foo.sh

  1. encontre um esquema de cores que você goste e use-o. O esquema que eu uso: o esquema que estou usando
por 03.09.2018 / 08:27
0

Se bash for sua escolha, recomendo oh-my-bash . Se zsh for sua escolha, recomendo oh-my-zsh . Ambos suportam a colorização do seu terminal e saídas diferentes.

    
por 20.11.2018 / 21:18
0

Gostaria de anunciar com humildade minha publicação recente de ta ou textattr , uma biblioteca e ferramenta de linha de comando que tem como objetivo adicionar cores e atributos para embelezar a saída do terminal de seu programa mais facilmente, traduzindo as especificações legíveis por humanos em códigos de escape ANSI.

Por exemplo:

echo "The Git repo $(ta yellow)${CUR_REPO}$(ta off) is $(ta green)up-to-date$(ta off)"

ou ainda mais curto:

echo "The Git repo $(ta y)${CUR_REPO}$(ta f) is $(ta g)up-to-date$(ta f)"

ou um substituto:

tawrite "The Git repo " @y ${CUR_REPO} @f " is " @g up-to-date @f "\n"

lhe dará algo como:

Atualmente,estabibliotecapodeserusadaemquatrolinguagensC,C++,DePython,alémdousodelinhadecomandodoseushellfavorito.

Observequenãoéautomaticamentecoloridoasaídadenenhumoutroprograma.É,antes,umutilitárioparaajudá-loanãoterqueselembrardoscódigosabstratos.Vocêsóprecisausarosnomesdecoresóbviosousuasabreviaturasrgbcmykw(hite)(de)ffáceisdelembrar.

Paramaisdetalhes,visite o repositório textattr .

    
por 23.11.2018 / 13:01