Gráficos de ramo bastante git

Eu já vi alguns livros e artigos terem alguns gráficos muito bonitos de git branches e commits. Como posso criar imagens imprimíveis de alta qualidade do histórico do git?

Atualização: Esta resposta recebeu muito mais atenção do que merece. Foi publicado originalmente porque acho que os gráficos são bonitos e podem ser desenhados no Illustrator para uma publicação - e não havia solução melhor. Mas agora existem respostas muito mais aplicáveis ​​a esse Q, como fracz , Jubobs ou Harry Lee ! Voto por favor aqueles !!

Atualização 2: Publiquei uma versão aprimorada desta resposta na topologia de ramificação Visualizing na pergunta git , pois é muito mais apropriado lá. Essa versão inclui lg3 , que mostra as informações do autor e do committer, então você realmente deve conferir. Deixando esta resposta por razões históricas (e rep, eu admito), embora eu esteja realmente tentado a excluí-la.

Meu 2 ¢ : tenho dois aliases que normalmente uso no meu ~/.gitconfigarquivo:

[alias]
lg1 = log --graph --abbrev-commit --decorate --format=format:'%C(bold blue)%h%C(reset) - %C(bold green)(%ar)%C(reset) %C(white)%s%C(reset) %C(dim white)- %an%C(reset)%C(bold yellow)%d%C(reset)' --all
lg2 = log --graph --abbrev-commit --decorate --format=format:'%C(bold blue)%h%C(reset) - %C(bold cyan)%aD%C(reset) %C(bold green)(%ar)%C(reset)%C(bold yellow)%d%C(reset)%n''          %C(white)%s%C(reset) %C(dim white)- %an%C(reset)' --all
lg = !"git lg1"

git lg/ git lg1fica assim:

e git lg2fica assim:

Muitas das respostas aqui são ótimas, mas para aquelas que querem apenas uma resposta simples de uma linha direta, sem precisar configurar aliases ou qualquer coisa extra, aqui está:

git log --all --decorate --oneline --graph

Nem todo mundo faria isso git logo tempo todo, mas quando você precisar, lembre-se:

" A Dog " = git log - a ll - d ecorate - o neline - g raph

Para saída de texto, você pode tentar:

git log --graph --abbrev-commit --decorate --date=relative --all

ou:

git log --graph --oneline --decorate --all

ou: aqui está um alias do graphviz para desenhar o gráfico do DAG.

Eu pessoalmente uso gitx, gitk --allegitnub .

Gitgraph.js permite desenhar ramificações git bonitas sem um repositório. Basta escrever um código Javascript que configure suas ramificações e confirme e o renderize no navegador.

var gitGraph = new GitGraph({
   template: "blackarrow",
   mode: "compact",
   orientation: "horizontal",
   reverseArrow: true
});

var master = gitGraph.branch("master").commit().commit();
var develop = gitGraph.branch("develop").commit();
master.commit();
develop.commit().commit();
develop.merge(master);

ou com metromodelo:

ou com mensagens, autores e tags de confirmação:

Teste com o JSFiddle .

Gere-o com Git Grapher por @bsara.

Construído sobre o TikZ & PGF , gitdagsexiste um pequeno pacote LaTeX que permite produzir sem esforço gráficos de confirmação de gráficos vetoriais e muito mais.

A geração automática do gráfico de confirmação de um repositório existente não é o objetivo gitdags; os gráficos produzidos são feitos apenas para fins educacionais .

Costumo usá-lo para produzir gráficos para minhas respostas às perguntas do Git, como uma alternativa aos gráficos de confirmação ASCII:

• Como posso corrigir um bug no master e integrá-lo aos meus ramos menos estáveis?
• Como o git commit --amend funciona exatamente?
• Por que o Git me diz "Atualmente não está em nenhum ramo" depois que eu executo "git checkout origin / <branch>"?
• Qual é a diferença entre mesclar mestre em ramificação e mesclar ramificação em mestre?
• Git rebase - falha na preservação da fusão

Aqui está um exemplo de um gráfico demonstrando os efeitos de uma simples rebase:

\documentclass{article}

\usepackage{subcaption}
\usepackage{gitdags}

\begin{document}

\begin{figure}
  \begin{subfigure}[b]{\textwidth}
    \centering
    \begin{tikzpicture}
      % Commit DAG
      \gitDAG[grow right sep = 2em]{
        A -- B -- { 
          C,
          D -- E,
        }
      };
      % Tag reference
      \gittag
        [v0p1]       % node name
        {v0.1}       % node text
        {above=of A} % node placement
        {A}          % target
      % Remote branch
      \gitremotebranch
        [origmaster]    % node name
        {origin/master} % node text
        {above=of C}    % node placement
        {C}             % target
      % Branch
      \gitbranch
        {master}     % node name and text 
        {above=of E} % node placement
        {E}          % target
      % HEAD reference
      \gitHEAD
        {above=of master} % node placement
        {master}          % target
    \end{tikzpicture}
    \subcaption{Before\ldots}
  \end{subfigure}

  \begin{subfigure}[b]{\textwidth}
    \centering
    \begin{tikzpicture}
      \gitDAG[grow right sep = 2em]{
        A -- B -- { 
          C -- D' -- E',
          {[nodes=unreachable] D -- E },
        }
      };
      % Tag reference
      \gittag
        [v0p1]       % node name
        {v0.1}       % node text
        {above=of A} % node placement
        {A}          % target
      % Remote branch
      \gitremotebranch
        [origmaster]    % node name
        {origin/master} % node text
        {above=of C}    % node placement
        {C}             % target
      % Branch
      \gitbranch
        {master}      % node name and text 
        {above=of E'} % node placement
        {E'}          % target
      % HEAD reference
      \gitHEAD
        {above=of master} % node placement
        {master}          % target
    \end{tikzpicture}
    \subcaption{\ldots{} and after \texttt{git rebase origin/master}}
  \end{subfigure}
  \caption{Demonstrating a typical \texttt{rebase}}
\end{figure}

\end{document}

Gitg é um clone do Gitk e do GitX para GNOME (também funciona no KDE etc.), que mostra um gráfico bastante colorido.

É desenvolvido ativamente (a partir de 2012). Ele permite que você classifique as confirmações (nós do gráfico) cronologicamente ou topologicamente e oculte as confirmações que não levam a uma ramificação selecionada.

Ele funciona bem com grandes repositórios e gráficos de dependência complexos.

Exemplos de capturas de tela, mostrando os repositórios linux-git e linux-2.6:

O SourceTree é realmente bom. Ele imprime um histórico de boa aparência e tamanho médio e gráfico de ramificações: (o seguinte é feito em um projeto experimental do Git apenas para ver algumas ramificações). Suporta Windows 7+ e Mac OS X 10.6+.

http://www.sourcetreeapp.com/

Acabei de escrever uma ferramenta que pode gerar um gráfico bonito de commit git usando HTML / Canvas.

E forneça um plugin jQuery que facilite o uso.

[github] https://github.com/tclh123/commits-graph

Pré-visualização:

git-foresté um excelente script perl que uso há mais de um ano e quase não uso o git logcomando diretamente.

Estas são algumas das coisas que eu amo nesse script:

• Ele usa caracteres unicode para desenhar as linhas no gráfico, dando uma aparência mais contínua às linhas do gráfico.
• Você pode combinar --reversecom a saída do gráfico, o que não é possível com o git logcomando regular .
• Ele é usado git loginternamente para obter a lista de confirmações, para que todas as opções para as quais você passa git logtambém possam ser passadas para esse script.

Eu tenho um alias usando da git-forestseguinte maneira:

[alias]
tree = "forest --pretty=format:\"%C(red)%h %C(magenta)(%ar) %C(blue)%an %C(reset)%s\" --style=15 --reverse"

É assim que a saída se parece em um terminal:

Eu escrevi uma ferramenta da web para converter logs do git em gráficos SVG bonitos: Bit-Booster - Ferramenta de desenho de confirmação de gráfico off-line

Carregar saída de git log --pretty='%h|%p|%d' diretamente na ferramenta e clique no link "download graph.svg".

A ferramenta é do lado do cliente puro e, portanto, nenhum dos seus dados do Git é compartilhado com o meu servidor. Você também pode salvar o HTML + JS localmente e executá-lo usando os URLs "file: ///". Verificado no Chrome 48 e Firefox 43 no Ubuntu 12.04.

Ele gera HTML que pode ser postado diretamente em qualquer página (incluindo o mecanismo de blog do blogspot!). Dê uma olhada em algumas das postagens do blog aqui:

http://bit-booster.blogspot.ca/

Aqui está uma captura de tela de um arquivo HTML de amostra gerado pela ferramenta:

http://bit-booster.com/graph.html (a ferramenta)

Com base em um script Graphviz que encontrei em uma resposta a uma pergunta relacionada , hackeei um script ruby que cria uma exibição resumida de um repositório git. Ele elimina toda a história linear e apenas mostra confirmações "interessantes", ou seja, aquelas com vários pais, vários filhos ou apontadas por um ramo ou etiqueta. Aqui está um trecho do gráfico que ele gera para o jquery :

O git-big-picture e o BranchMaster são ferramentas semelhantes que tentam mostrar apenas a estrutura de alto nível de um gráfico, exibindo apenas como as tags, ramificações, mesclagens etc. estão relacionadas.

Esta pergunta tem mais algumas opções.

Eu adicionei três comandos personalizados: git tree, git streee git vtree. Vou examiná-los nessa ordem.

[alias]
    tree = log --all --graph --decorate=short --color --format=format:'%C(bold blue)%h%C(reset) %C(auto)%d%C(reset)\n         %C(black)[%cr]%C(reset)  %x09%C(black)%an: %s %C(reset)'

Com git streee git vtreeusei o bash para ajudar na formatação.

[alias]
    logx = log --all --graph --decorate=short --color --format=format:'%C(bold blue)%h%C(reset)+%C(dim black)(%cr)%C(reset)+%C(auto)%d%C(reset)++\n+++       %C(bold black)%an%C(reset)%C(black): %s%C(reset)'
    stree = !bash -c '"                                                                             \
        while IFS=+ read -r hash time branch message; do                                            \
            timelength=$(echo \"$time\" | sed -r \"s:[^ ][[]([0-9]{1,2}(;[0-9]{1,2})?)?m::g\");     \
            timelength=$(echo \"16+${#time}-${#timelength}\" | bc);                                 \
            printf \"%${timelength}s    %s %s %s\n\" \"$time\" \"$hash\" \"$branch\" \"\";          \
        done < <(git logx && echo);"'

[alias]
    logx = log --all --graph --decorate=short --color --format=format:'%C(bold blue)%h%C(reset)+%C(dim black)(%cr)%C(reset)+%C(auto)%d%C(reset)++\n+++       %C(bold black)%an%C(reset)%C(black): %s%C(reset)'
    vtree = !bash -c '"                                                                             \
        while IFS=+ read -r hash time branch message; do                                            \
            timelength=$(echo \"$time\" | sed -r \"s:[^ ][[]([0-9]{1,2}(;[0-9]{1,2})?)?m::g\");     \
            timelength=$(echo \"16+${#time}-${#timelength}\" | bc);                                 \
            printf \"%${timelength}s    %s %s %s\n\" \"$time\" \"$hash\" \"$branch\" \"$message\";  \
        done < <(git logx && echo);"'

EDIT: Funciona com a versão 1.9a do git. O valor da cor 'auto' está aparentemente fazendo sua estréia nesta versão. É uma boa adição, porque os nomes das ramificações terão uma cor diferente. Isso facilita a distinção entre ramificações locais e remotas, por exemplo.

Depende da aparência deles. Eu uso o gitx, que faz fotos como esta:

Você pode comparar com o git log --graphgitk em uma mesclagem de polvo de 24 vias (originalmente de http://clojure-log.n01se.net/date/2008-12-24.html ):

Para uma saída textual mais detalhada, tente:

git log --graph --date-order -C -M --pretty=format:"<%h> %ad [%an] %Cgreen%d%Creset %s" --all --date=short

Você pode escrever o alias em $ HOME / .gitconfig

[alias]
    graph = log --graph --date-order -C -M --pretty=format:\"<%h> %ad [%an] %Cgreen%d%Creset %s\" --all --date=short

Esta é a minha opinião sobre este assunto:

Captura de tela:

Uso:

git hist - Mostra o histórico do ramo atual

git hist --all - Mostrar o gráfico de todas as ramificações (incluindo controles remotos)

git hist master devel - Mostrar o relacionamento entre dois ou mais ramos

git hist --branches - Mostrar todas as filiais locais

Adicionar --topo-orderà classificação confirma topologicamente, em vez de por data (padrão neste alias)

Benefícios:

• Parece simples --decorate, portanto, com cores separadas para diferentes nomes de filiais
• Adiciona email de confirmação
• Adiciona data relativa e absoluta de confirmação
• Classifica confirmações por data

Configuração:

git config --global alias.hist "log --graph --date-order --date=short \
--pretty=format:'%C(auto)%h%d %C(reset)%s %C(bold blue)%ce %C(reset)%C(green)%cr (%cd)'"

gitg : um visualizador de repositório baseado em gtk, que é novo, mas interessante e útil
http://git.gnome.org/browse/gitg
Eu o uso atualmente

Embora às vezes eu use o gitg , sempre volte à linha de comando:

[alias]
    #quick look at all repo
    loggsa = log --color --date-order --graph --oneline --decorate --simplify-by-decoration --all
    #quick look at active branch (or refs pointed)
    loggs  = log --color --date-order --graph --oneline --decorate --simplify-by-decoration
    #extend look at all repo
    logga  = log --color --date-order --graph --oneline --decorate --all
    #extend look at active branch
    logg   = log --color --date-order --graph --oneline --decorate
    #Look with date
    logda  = log --color --date-order --date=local --graph --format=\"%C(auto)%h%Creset %C(blue bold)%ad%Creset %C(auto)%d%Creset %s\" --all
    logd   = log --color --date-order --date=local --graph --format=\"%C(auto)%h%Creset %C(blue bold)%ad%Creset %C(auto)%d%Creset %s\"        
    #Look with relative date
    logdra = log --color --date-order --graph --format=\"%C(auto)%h%Creset %C(blue bold)%ar%Creset %C(auto)%d%Creset %s\" --all
    logdr = log --color --date-order --graph --format=\"%C(auto)%h%Creset %C(blue bold)%ar%Creset %C(auto)%d%Creset %s\"  

    loga   = log --graph --color --decorate --all

    # For repos without subject body commits (vim repo, git-svn clones)
    logt  = log --graph --color --format=\"%C(auto)%h %d %<|(100,trunc) %s\"
    logta  = log --graph --color --format=\"%C(auto)%h %d %<|(100,trunc) %s\" --all        
    logtsa = log --graph --color --format=\"%C(auto)%h %d %<|(100,trunc) %s\" --all --simplify-by-decoration 

Como você pode ver, é quase um pressionamento de tecla salvar aliases, com base em:

• --color: olhar claro
• --graph: visualize os pais
• --date-order: visão mais compreensível do repositório
• --decorate: quem é quem
• --oneline: muitas vezes tudo o que você precisa saber sobre um commit
• - simplificar por decoração: básico para uma primeira olhada (apenas tags, mesclagens relevantes, ramificações)
• --all: salvando pressionamentos de teclas com todos os aliass com e sem esta opção
• --date = relativo (% ar): entenda a atividade no repositório (às vezes um ramo é poucos confirmados perto do mestre, mas meses atrás dele)

Veja na versão recente do git (1.8.5 e superior) que você pode se beneficiar do% C (automático) no espaço reservado para decoração% d

A partir daqui, tudo o que você precisa é entender bem as decisões de git para filtrar tudo o que você precisa (algo como master..develop, onde --simplify-merges pode ajudar com ramificações de longo prazo)

O poder por trás da linha de comando é a configuração rápida, com base nas suas necessidades (entender que um repo não é uma configuração exclusiva de log de chaves, portanto, às vezes, é necessário adicionar --numstat ou --raw ou --namename. e os aliases são rápidos, poderosos e (com o tempo) o gráfico mais bonito que você pode obter.Além disso, com a saída mostrada por padrão por meio de um pager (diga menos), você sempre pode pesquisar rapidamente em resultados. Não está convencido? Você sempre pode analisar o resultado com projetos como gitgraph

Muito ligeiramente ajustes resposta incrível do Slipp , você pode usar seus aliases para registrar apenas um ramo:

[alias]
lgBranch1 = log --graph --format=format:'%C(bold blue)%h%C(reset) - %C(bold green)(%ar)%C(reset) %C(white)%s%C(reset) %C(bold white)— %an%C(reset)%C(bold yellow)%d%C(reset)' --abbrev-commit --date=relative
lgBranch2 = log --graph --format=format:'%C(bold blue)%h%C(reset) - %C(bold cyan)%aD%C(reset) %C(bold green)(%ar)%C(reset)%C(bold yellow)%d%C(reset)%n''          %C(white)%s%C(reset) %C(bold white)— %an%C(reset)' --abbrev-commit
lg = !"git lg1"

Ao deixar de lado, --allagora você pode

git lgBranch1 <branch name>

ou mesmo

git lgBranch1 --all

Sugiro tig https://github.com/jonas/tig , uma ferramenta de linha de comando muito melhor para o git.

Você pode usar o homebrew para instalar o tig no macOS:

$ brew install tig
$ tig

Eu tenho esse git logalias ~/.gitconfigpara visualizar o histórico do gráfico:

[alias]
l = log --all --graph --pretty=format:'%C(auto)%h%C(auto)%d %s %C(dim white)(%aN, %ar)'

Com isso, git lproduzirá algo como:

No Git 2.12 +, você pode personalizar as cores das linhas do gráfico usando a log.graphColorsopção de configuração.

Quanto ao formato dos logs, é semelhante a --oneline, com a adição do nome do autor (respeitando .mailmap) e a data relativa do autor . Observe que a %C(auto)sintaxe, que diz ao Git para usar as cores padrão para o hash de confirmação, etc., é suportada no Git> = 1.8.3 .

Você tentou gitkou gitk --all? No entanto, ele não possui uma img print / save como função.

GitGraph

Gera uma representação PNG ou SVG do histórico de consolidação do seu repositório Git.

https://code.google.com/p/gitgraph

git -c core.pager='less -SRF' log --oneline --graph --decorate

Esta é a minha variação terminal, semelhante a muitas respostas aqui. Gosto de ajustar os sinalizadores passados lesspara impedir a quebra de linha.

Defino isso como um alias para acesso rápido, pois o comando é um pouco complicado.

Tente ditaa . Ele pode transformar qualquer diagrama ASCII em uma imagem. Embora não tenha sido projetado com as ramificações do Git em mente, fiquei impressionado com os resultados.

Origem (arquivo txt):

        +--------+
        | hotfix |
        +---+----+
            |
--*<---*<---*
       ^ 
       |
       \--*<---*
               |
           +---+----+
           | master |
           +--------+

Comando:

java -jar ditaa0_9.jar ascii-graph.txt

Resultado:

Ele também suporta cores de fundo, linhas tracejadas, formas diferentes e muito mais. Veja os exemplos .

Se o seu repositório estiver no Gitlab, você poderá usar sua representação gráfica como ela é renderizada como SVG no seu navegador.

• Vá para a visualização gráfica do seu repositório, por exemplo, https://gitlab.com/gitlab-org/gitter/webapp/network/develop

• Role o gráfico para baixo (ele carrega lentamente!)

• Use o inspetor do navegador para copiar o elemento SVG para um novo arquivo

• Abra-o em um renderizador de sua escolha, por exemplo, Inkscape

Eu não sei sobre uma ferramenta direta, mas talvez você possa hackear um script para exportar os dados para o formato de pontos e renderizá-los com graphviz.

Há um funky gráfico de confirmação do Git como uma das demos da biblioteca de gráficos da Web Raphael .

A demonstração é estática, mas deve ser fácil pegar o código e trocar seus dados estáticos por um conjunto de dados ao vivo - acho que são apenas os dados de confirmação do Git no formato JSON.

A demonstração está aqui: http://dmitrybaranovskiy.github.io/raphael/github/impact.html

Um gráfico git agradável e limpo com aparência de tablel para conchas

com hashes geralmente, além da árvore gráfica

ou em uma coluna extra

Edit : Você quer começar imediatamente sem ler explicações? Use alias git, trechos de código de script ou função da seção EDIT 5 abaixo.

Em todas as respostas a essa pergunta, nenhuma mostrou uma saída limpa, semelhante a uma mesa, procurando conchas até agora. O mais próximo foi essa resposta dos evangelhos de onde eu comecei.

O ponto principal da minha abordagem é contar apenas os caracteres da árvore mostrados ao usuário. Em seguida, preencha-os com um espaço pessoal.

Além do git, você precisa dessas ferramentas

• grep
• colar
• printf
• sed
• seq
• tr
• banheiro

principalmente a bordo com qualquer distribuição linux.

O trecho de código é

while IFS=+ read -r graph hash time branch message;do

  # count needed amount of whitespaces and create them
  whitespaces=$((9-$(sed -nl1000 'l' <<< "$graph" | grep -Eo '\\\\|\||\/|\ |\*|_' | wc -l)))
  whitespaces=$(seq -s' ' $whitespaces|tr -d '[:digit:]')

  # show hashes besides the tree ...
  #graph_all="$graph_all$graph$(printf '%7s' "$hash")$whitespaces \n"

  # ... or in an own column
  graph_all="$graph_all$graph$whitespaces\n"
  hash_all="$hash_all$(printf '%7s' "$hash")  \n"

  # format all other columns
  time_all="$time_all$(printf '%12s' "$time") \n"
  branch_all="$branch_all$(printf '%15s' "$branch")\n"
  message_all="$message_all$message\n"
done < <(git log --all --graph --decorate=short --color --pretty=format:'+%C(bold 214)%<(7,trunc)%h%C(reset)+%C(dim white)%>(12,trunc)%cr%C(reset)+%C(214)%>(15,trunc)%d%C(reset)+%C(white)%s%C(reset)' && echo);

# paste the columns together and show the tablelike output
paste -d' ' <(echo -e "$time_all") <(echo -e "$branch_all") <(echo -e "$graph_all") <(echo -e "$hash_all") <(echo -e "$message_all")

Para calcular os espaços em branco necessários, usamos

  sed -nl500 'l' <<< "$graph"

para obter todos os caracteres (até 500 por linha) do que selecionar apenas os caracteres da árvore: * | / \ _ e espaços em branco com

  grep -Eo '\\\\|\||\/|\ |\*|_'

finalmente conte-os e subtraia o resultado do nosso valor de comprimento escolhido, que é 9 no exemplo.

Para produzir a quantidade calculada de espaços em branco que usamos

  seq -s' ' $whitespaces

e truncar os números de posição com

  tr -d '[:digit:]'

do que adicioná-los ao final de nossa linha de gráfico. É isso aí!

O Git tem a boa opção de formatar o tamanho dos especificadores de saída já com a sintaxe '%><(amount_of_characters,truncate_option)', que adiciona espaços em branco do lado esquerdo '>' ou direito '<' e pode truncar caracteres desde o início 'ltrunc', meio 'mtrunc' ou final 'trunc'.

É importante que os printf cmd's acima usem os mesmos valores de comprimento para a coluna git correspondente.

Divirta-se modelando sua própria aparência limpa, de aparência de tablete, de acordo com suas necessidades.

Extra:

Para obter o valor certo de comprimento, você pode usar o seguinte snippet

while read -r graph;do
    chars=$(sed -nl1000 'l' <<< "$graph" | grep -Eo '\\\\|\||\/|\ |\*|_' | wc -l)
    [[ $chars -gt ${max_chars:-0} ]] && max_chars=$chars
done < <(git log --all --graph --pretty=format:' ')

e use $ max_chars como o valor de comprimento correto acima.

EDIT 1 : Acabei de notar que o caractere sublinhado também é usado na árvore git e edite os trechos de código acima em conformidade. Se houver outros caracteres ausentes, deixe um comentário.

EDIT 2 : Se você quiser se livrar dos colchetes em torno das entradas branch e tag, use "% D" em vez de "% d" no comando git, como na EDIT 3.

EDIÇÃO 3 : Talvez a opção de cor "automática" seja a que você mais prefere para entradas de ramificação e etiqueta?

Mude esta parte do comando git (cor 214 )

%C(214)%>(15,trunc)%D%C(reset)

para auto

%C(auto)%>(15,trunc)%D%C(reset)

EDIT 4 : Ou você gosta da sua própria mistura de cores para essa parte, uma saída elegante com a cabeça piscando?

Para poder estilizar a cabeça, nomes de ramificações e tags primeiro, precisamos da opção de cor "auto" em nosso comando git, como na EDIT 3.

Em seguida, podemos substituir os valores conhecidos das cores pelos nossos adicionando essas 3 linhas

 # branch name styling
 branch=${branch//1;32m/38;5;214m}
 # head styling
 branch=${branch//1;36m/3;5;1;38;5;196m}
 # tag styling
 branch=${branch//1;33m/1;38;5;222m}

logo antes da linha

 branch_all="$branch_all$(printf '%15s' "$branch")\n"

no nosso snippet de código. Os valores de substituição produzem as cores acima.

Por exemplo, o valor de substituição da cabeça é

3;5;1;38;5;196

onde 3; significa itálico, 5; para piscar e 1; 38; 5; 196 para a cor. Para mais informações, comece aqui. Nota: Esse comportamento depende do seu terminal favorito e, portanto, pode não ser utilizável.

MAS você pode escolher qualquer valor de cor que preferir.

VISÃO GERAL dos valores de cores git e equivalentes ANSI

Você encontra uma lista com a opção git color / style aqui .

Se você precisar da saída no console para obter cores precisas (a imagem acima é reduzida pelo stackoverflow), você pode produzir a saída com

for ((i=0;i<=255;i++));do
  while IFS='+' read -r tree hash;do 
    echo -e "$(printf '%-10s' "(bold $i)") $hash  $(sed -nl500 'l' <<< "$hash"|grep -Eom 1 '[0-9;]*[0-9]m'|tr -d 'm')"
  done < <(git log --all --graph --decorate=short --color --pretty=format:'+%C(bold '$i')%h%C(reset)'|head -n 1)
done

no caminho do projeto git, que usa o primeiro commit da saída do seu log git.

Edição 5 : Como o membro "Andras Deak" mencionou, existem algumas maneiras de usar esse código:

1) como um apelido :

O alias não aceita parâmetros, mas uma função pode , portanto, apenas definir no seu .bashrc

   function git_tably () {
     unset branch_all graph_all hash_all message_all time_all max_chars

     ### add here the same code as under "2) as a shell-script" ###

   }

e chame a função git_tably (derivada de tablelike) diretamente sob o caminho do projeto git ou de onde você quiser, com o caminho do projeto git como primeiro parâmetro.

2) como um shell-script :

Eu o uso com a opção de passar um diretório de projeto git como primeiro parâmetro para ele ou, se vazio, pegue o diretório de trabalho como o comportamento normal. Na sua totalidade, temos

# edit your color/style preferences here or use empty values for git auto style
tag_style="1;38;5;222"
head_style="1;3;5;1;38;5;196"
branch_style="38;5;214"

# determine the max character length of your git tree
while IFS=+ read -r graph;do
  chars_count=$(sed -nl1000 'l' <<< "$graph" | grep -Eo '\\\\|\||\/|\ |\*|_' | wc -l)
  [[ $chars_count -gt ${max_chars:-0} ]] && max_chars=$chars_count
done < <(cd "${1:-"$PWD"}" && git log --all --graph --pretty=format:' ')

# create the columns for your prefered tablelike git graph output
while IFS=+ read -r graph hash time branch message;do

  # count needed amount of whitespaces and create them
  whitespaces=$(($max_chars-$(sed -nl1000 'l' <<< "$graph" | grep -Eo '\\\\|\||\/|\ |\*|_' | wc -l)))
  whitespaces=$(seq -s' ' $whitespaces|tr -d '[:digit:]')

  # show hashes besides the tree ...
  #graph_all="$graph_all$graph$(printf '%7s' "$hash")$whitespaces \n"

  # ... or in an own column
  graph_all="$graph_all$graph$whitespaces\n"
  hash_all="$hash_all$(printf '%7s' "$hash")  \n"

  # format all other columns
  time_all="$time_all$(printf '%12s' "$time") \n"
  branch=${branch//1;32m/${branch_style:-1;32}m}
  branch=${branch//1;36m/${head_style:-1;36}m}
  branch=${branch//1;33m/${tag_style:-1;33}m}
  branch_all="$branch_all$(printf '%15s' "$branch")\n"
  message_all="$message_all$message\n"

done < <(cd "${1:-"$PWD"}" && git log --all --graph --decorate=short --color --pretty=format:'+%C(bold 214)%<(7,trunc)%h%C(reset)+%C(dim white)%>(12,trunc)%cr%C(reset)+%C(auto)%>(15,trunc)%D%C(reset)+%C(white)%s%C(reset)' && echo);

# paste the columns together and show the tablelike output
paste -d' ' <(echo -e "$time_all") <(echo -e "$branch_all") <(echo -e "$graph_all") <(echo -e "$hash_all") <(echo -e "$message_all")

3) como um alias do git :

Talvez a maneira mais confortável seja adicionar um alias git no seu .gitconfig

[color "decorate"]
    HEAD = bold blink italic 196
    branch = 214
    tag = bold 222

[alias]
    count-log = log --all --graph --pretty=format:' '
    tably-log = log --all --graph --decorate=short --color --pretty=format:'+%C(bold 214)%<(7,trunc)%h%C(reset)+%C(dim white)%>(12,trunc)%cr%C(reset)+%C(auto)%>(15,trunc)%D%C(reset)+%C(white)%s%C(reset)'
    tably     = !bash -c '"                                                                                                    \
                  while IFS=+ read -r graph;do                                                                                 \
                    chars_count=$(sed -nl1000 \"l\" <<< \"$graph\" | grep -Eo \"\\\\\\\\\\\\\\\\|\\||\\/|\\ |\\*|_\" | wc -l); \
                    [[ $chars_count -gt ${max_chars:-0} ]] && max_chars=$chars_count;                                          \
                  done < <(git count-log && echo);                                                                             \
                  while IFS=+ read -r graph hash time branch message;do                                                        \
                    chars=$(sed -nl1000 \"l\" <<< \"$graph\" | grep -Eo \"\\\\\\\\\\\\\\\\|\\||\\/|\\ |\\*|_\" | wc -l);       \
                    whitespaces=$(($max_chars-$chars));                                                                        \
                    whitespaces=$(seq -s\" \" $whitespaces|tr -d \"[:digit:]\");                                               \
                    graph_all=\"$graph_all$graph$whitespaces\n\";                                                              \
                    hash_all=\"$hash_all$(printf \"%7s\" \"$hash\")  \n\";                                                     \
                    time_all=\"$time_all$(printf \"%12s\" \"$time\") \n\";                                                     \
                    branch_all=\"$branch_all$(printf \"%15s\" \"$branch\")\n\";                                                \
                    message_all=\"$message_all$message\n\";                                                                    \
                  done < <(git tably-log && echo);                                                                             \
                  paste -d\" \" <(echo -e \"$time_all\") <(echo -e \"$branch_all\") <(echo -e \"$graph_all\")                  \
                                <(echo -e \"$hash_all\") <(echo -e \"$message_all\");                                          \
                '"

Do que apenas chamar git tablyem qualquer caminho do projeto.

O Git é tão poderoso que você pode mudar de cabeça, tags, ... diretamente, como mostrado acima e retirado daqui .

Outra opção sofisticada é selecionar as cores das árvores que você preferir com

[log]
    graphColors = bold 160, blink 231 bold 239, bold 166, bold black 214, bold green, bold 24, cyan

que fornece saídas de log git loucas, mas sempre com aparência de tablel

Muito piscando! Apenas para demonstrar o que é possível. Muito poucas cores especificadas levam a repetições de cores.

Uma referência completa ao .gitconfig está a apenas um clique de distância.

NOVAMENTE: Divirta-se criando sua própria aparência limpa, com aparência de tablete, de acordo com suas necessidades.

alguns aliases em ~ / .oh-my-zsh / plugins / git / git.plugin.zsh

gke='\gitk --all $(git log -g --pretty=%h)'
glg='git log --stat'
glgg='git log --graph'
glgga='git log --graph --decorate --all'
glgm='git log --graph --max-count=10'
glgp='git log --stat -p'
glo='git log --oneline --decorate'
glog='git log --oneline --decorate --graph'
gloga='git log --oneline --decorate --graph --all'
glol='git log --graph --pretty='\''%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset'\'' --abbrev-commit'
glola='git log --graph --pretty='\''%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset'\'' --abbrev-commit --all'

Para usuários do OSX, peguei o exemplo @gospes e o modifiquei levemente para gsed ( gnu-sedinstalado via homebrew) e ajustei as cores (para trabalhar com um plano de fundo preto, sem ter certeza de como o exemplo original poderia renderizar da maneira que ele faz no exemplo, uma vez que especifica texto em preto em um terminal com fundo preto).

[alias]
    # tree, vtree, stree support
    logx = log --all --graph --decorate=short --color --format=format:'%C(bold blue)%h%C(reset)+%C(bold black)(%cr)%C(reset)+%C(auto)%d%C(reset)++\n+++       %C(bold black)%an%C(reset)%C(bold black): %s%C(reset)'
    tree = log --all --graph --decorate=short --color --format=format:'%C(bold blue)%h%C(reset) %C(auto)%d%C(reset)\n         %C(bold black)[%cr]%C(reset)  %x09%C(bold black)%an: %s %C(reset)'
    stree = !bash -c '" \
    while IFS=+ read -r hash time branch message; do \
        timelength=$(echo \"$time\" | gsed -r \"s:[^ ][[]([0-9]{1,2}(;[0-9]{1,2})?)?m::g\"); \
        timelength=$(echo \"16+${#time}-${#timelength}\" | bc); \
        printf \"%${timelength}s    %s %s %s\n\" \"$time\" \"$hash\" \"$branch\" \"\"; \
    done < <(git logx && echo);"' | less -r
    vtree = !bash -c '" \
    while IFS=+ read -r hash time branch message; do \
      timelength=$(echo \"$time\" | gsed -r \"s:[^ ][[]([0-9]{1,2}(;[0-9]{1,2})?)?m::g\"); \
      timelength=$(echo \"16+${#time}-${#timelength}\" | bc); \
      printf \"%${timelength}s    %s %s %s\n\" \"$time\" \"$hash\" \"$branch\" \"$message\"; \
    done < <(git logx && echo);"' | less -r

A chave para o OSX é instalar primeiro o gnu sed (que possui a opção -r). O mais fácil é fazer o homebrew, que não substituirá o sed instalado no sistema, mas instalará o gnu sed como "gsed". Espero que isso ajude o @ SlippD.Thompson que comentou acima sobre o OSX não funcionar.