Gráficos de ramo bastante git

1385

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?

krosenvold
fonte
4
Eu criei um script python para criar um gráfico graphiz! Dê uma olhada. github.com/chode/git-graph
Stephan Bechter 14/14
4
Se você deseja alta qualidade e impressão, minha ferramenta ( bit-booster.com/graph.html ) converte "git log" em SVG. Para mais informações, veja minha resposta .
G. Sylvie Davies
2
Você está procurando uma ferramenta para visualizar seu próprio histórico do git - ou - uma ferramenta de gráficos que tenha uma maneira de desenhar "ramificações do Git" bonitas?
Uri Abramson
1
Possível duplicata da visualização da topologia de ramificação no git
trblnc
5
Eu apagar a tag dirigidos-acíclicos-gráficos, porque isso é irrelevante para esta pergunta
Maksim Dmitriev

Respostas:

1843

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:
git lg1

e git lg2fica assim:
git lg2

Slipp D. Thompson
fonte
35
Sim. As cores normal e brilhante / negrito são: preto #202020/ #555555, vermelho: #5d1a14/ #da4939, verde: #424e24/ #a5c261, amarelo: #6f5028/ #ffc66d, azul: #263e4e/ #6d9cbe, magenta: #3e1f50/ #a256c7, ciano: #234e3f/ #62c1a1e branco: #979797/ #ffffff.
precisa saber é o seguinte
3
@Turbo: Para mim, as cores são alteráveis ​​nas configurações de perfil do meu aplicativo de terminal (Terminal.app). O aplicativo de terminal que você está usando pode ou não suportar a alteração de quais cores são exibidas para determinadas cores ANSI. Além disso, o traço (em traço, com precisão) foi criado com a opção shift-[tecla hífen-menos]. Suponho que assumi erroneamente que todas as plataformas atuais estavam atualizando o Unicode.
Slipp D. Thompson
3
Você --date=relativee --abbrev-commité redundante porque você usa explicitamente %cre %h, respectivamente.
graywh
6
Eu adicionaria o %C(auto)modificador aos refnames ( %d) para obter cores mais agradáveis. Veja stackoverflow.com/questions/5889878/color-in-git-log/…
Josef Eisl
2
Ótima resposta. Eu modificado o comando para se parecer mais com a saída do --oneline --decorate comlg = log --graph --abbrev-commit --decorate --format=format:'%C(yellow)%h%C(reset)%C(auto)%d%C(reset) %C(normal)%s%C(reset) %C(dim white)%an%C(reset) %C(dim blue)(%ar)%C (reset)' --all
Craig P. Motlin
1198

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

enter image description here

Patoshi パ ト シ
fonte
252
git config --global alias.adog "log --all --decorate --oneline --graph"
Fracz
4
Estou procurando há --alltanto tempo que estou prestes a chorar (T_T) OBRIGADO!
Felipe Gerard
2
--oneline foi introduzido no Git 1.6.3: github.com/git/git/blob/… --pretty = oneline funcionará com as versões do Git antes da 1.6.3
Pat Myron
13
melhor resposta no SO. Obrigado por mantê-lo alegre.
Tobias Feil
4
Eu acho que "--decorate" agora está incluído por padrão. Mas vou lembrar o acrônimo dessa maneira!
Josiah Yoder
378

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 .

keo
fonte
14
eu acrescentaria --abbrev-commit --decorate, e então é perfeito!
assimétrica
6
--abbrev-commit está implícito em --oneline, não?
dwineman
4
@dwineman sim, você não precisa --abbrev-commitse você usar--oneline
Thomas
2
Parece que na sua segunda linha git log --graph --oneline --decorate --date=relative --allo --dateargumento é inútil. Não vejo nenhuma data mostrada no log.
Lerner Zhang
data não é exibido quando --oneline é especificado
martinkunev
253

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);

gráfico de exemplo gerado com Gitgraph.js

ou com metromodelo:

Tema metro GitGraph.js

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

GitGraph com mensagens de confirmação

Teste com o JSFiddle .

Gere-o com Git Grapher por @bsara.

fracz
fonte
3
Sim, isso é totalmente incrível! Colocou no fiddle jsfiddle.net/guan1oz1 para que você possa testá-lo imediatamente.
Berkus
14
As setas devem apontar para os pais, não para os filhos.
Jb0bs
4
@Jobs: Bom ponto. Esse é um obstáculo comum para as pessoas que tentam entender o Git: elas pensam na sequência do tempo em vez da herança. Deixar claro que (quase) tudo no git é relativo a algo anterior ajuda todas as outras partes a se encaixarem.
Slip D. Thompson
6
Em relação à direção da seta, a partir dos documentos: * @ Param {booleana} [options.reverseArrow = false] - setas Faça apontam para antepassados se for verdade
Scott
2
Para sua informação, depois de ver este post e brincar com o gitgraph.js, decidi criar uma pequena ferramenta que basicamente coloca uma interface do usuário no gitgraph.js. Ainda não está concluído, e a interface do usuário ainda não está onde eu quero, mas as contribuições são bem-vindas! dê uma olhada: github.com/bsara/git-grapher
bsara
123

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:

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

insira a descrição da imagem aqui

\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}
jub0bs
fonte
1
@Isso parece ótimo! Gostaria também de algumas linhas sobre como usá-lo: considere um usuário do Windows que não possua o LaTeX instalado. Como produzir um gráfico a partir do zero?
VonC 28/08/14
1
@VonC Eu não tenho certeza, mas se você não quiser instalar o LaTeX, você pode ser capaz de produzir seus gráficos em ShareLatex e WriteLaTeX , e os gostos. Eu vou olhar para ele e expandir o wiki quando tenho mais tempo ... Sinta-se livre para promover o pacote:)
jub0bs
Isso é ótimo! Vou escrever um tutorial em algum momento, mas, por enquanto, eu só queria mencionar que você pode pós-processar seus gráficos usando a classe de documento autônoma (eu uso o recurso de corte), use latex input.texpara gerar um dvi e, finalmente, use dvisvgm input.dvipara gerar um SVG com transparência. A conversão do SVG para um formato raster como PNG é bastante fácil convert -antialias -density 300 -background none input.svg output.png. A propósito, essas imagens parecem incríveis com total transparência. Ainda trabalhando na questão da fonte ... i.imgur.com/1Xu2Ry5.png
vmrob
5
Levei um tempo para começar este trabalho, então eu escrevi um guia passo-a-passo como obter gitdags de trabalho a partir do zero no Ubuntu 14.04
ChrisFreeman
1
@AndreaPolci Consulte github.com/Jubobs/gitdags/issues/3 para obter um exemplo de mesclagem. A documentação para gitdagsestá a caminho!
Jub0bs #
79

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:

linux-git

linux-2.6

Caracol mecânico
fonte
60

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

insira a descrição da imagem aqui

http://www.sourcetreeapp.com/

falta de polaridade
fonte
Também está disponível na App Store, portanto, a atualização deve funcionar automaticamente.
WebOrCode 8/13/13
Eu amo o gráfico do sourcetree, mas prefiro usar a linha de comando, e os padrões do sourcetree sempre mexem com os meus repositórios.
SgtPooki
O SourceTree insiste em que você crie uma conta Atlassian (ou use sua conta do Google e conceda algumas permissões ao Atlassian para obter suas informações de e-mail e perfil) e, após a instalação no Mac (OS X El Capitan v 10.11.5), falha na etapa 'Clonagem': "fatal: nenhum mapeamento de submódulo encontrado em .gitmodules para o caminho '<caminho ignorado>'" e também um aviso estranho: "modelos não encontrados / usr / local / git / share / git-core / templates". Mensagens muito obscuras, não tão boas.
Dmitry Shevkoplyas
3
E depois da desinstalação, não esqueça de arrumar os privilégios de segurança do Google que você concedeu anteriormente: myaccount.google.com/security -> Aplicativos e sites conectados -> Aplicativos conectados à sua conta -> Gerenciar aplicativos
Dmitry Shevkoplyas
60

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:

pré-visualização

Harry Lee
fonte
Parece bom, como você obtém dados pré-formatados para desenhar esse gráfico?
Olga
3
@ Olga Acabei de adicionar o código de back-end ao meu repositório. Você pode visualizá- lo no github.
Harry Lee
56

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:

insira a descrição da imagem aqui

Tuxdude
fonte
3
@ void.pointer - Sim, não será porque o git-forest é um script perl e possui dependências do módulo perl. Correndo git sob cygwin com os módulos Perl necessários instalados pode ser a melhor alternativa que você poderia obter se você realmente quer isso no Windows :)
Tuxdude
1
Uau, esse repositório tem muitas ótimas ferramentas. Obrigado!
Eldelshell 13/09/2015
1
Funciona perfeitamente bem @MinGW (MSYS) em Win $; instale o CPANM; depois Git.pm; crie um alias e você está pronto para começar.
Sektor
o que é esse emulador de terminal muito bom que você usa? Eu gosto das coisas do indicador gráfico de prompt.
NH.
Como instalar este "script"? Estou no ubuntu.
user13107
50

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)

G. Sylvie Davies
fonte
1
@Jay parece que a cor reflete o nível de recuo de um determinado ramo, e que as sucursais podem passar para outra coluna e, portanto, mudar color.s
Thorbjørn Ravn Andersen
44

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 :

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

Matt McHenry
fonte
2
Eu tentei isso, mas não consegui que o dot funcionasse corretamente com a saída do nosso repositório (42 ramos, 175 tags, 42.000 confirmações) ... Pena ... É exatamente isso que eu estava procurando!
Xavier Nodet
1
@XavierNodet, se seu repositório for público e / ou você tiver uma mensagem de erro etc., registre um problema no GitHub. Obrigado!
Matt McHenry
38

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)'

insira a descrição da imagem aqui

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);"'

git_stree


[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);"'

git_vtree


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.

evangelhos
fonte
fatal: bad color value 'auto' for variable '--pretty format':(
Swivel
Acabou sendo uma versão antiga do git. Yum tem uma versão bastante desatualizada do Git em seu repositório. Compilado a partir da fonte (1.9) e funciona muito bem. É lindo também! Obrigado @gospes!
giratória
Não vá no OS X:sed: illegal option -- r
Slipp D. Thompson
@ SlippD.Thompson: Estou usando o linux :). O -r é para expressões regulares estendidas. Aparentemente, a versão OSX do sed não a possui. Talvez você possa atualizar o sed. Caso contrário, você pode simplesmente reescrever o comando sed sem regex estendido.
gospes
1
Para o Mac OS X sed, use -E em vez de -r
Baxter Lopez
37

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

enredo simples

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 ):

Mesclagem de polvo git de 24 vias.  O URL original era <code> http://lwn.net/images/ns/kernel/gitk-octopus.png </code>

Dustin
fonte
49
É engraçado ... Eu teria jurado ouvi-lo dizer "fusão de polvos de 24 vias"!
dty
4
Por curiosidade, alguém tentou extrair as rotinas de desenho do GitX (ou de outra ferramenta GUI git) para um executável independente? Se não me engano, conseguir que o Cocoa desenhe em um arquivo PDF vetorial não seria difícil e satisfaria a necessidade do OP de imagens imprimíveis com alto Q.
Slipp D. Thompson
Foi no S3 via skitch antes que eles refizessem suas coisas. Eu gostaria de ainda ter. :(
Dustin
Apenas substituí-lo por uma versão gitk de gitk lwn.net/images/ns/kernel/gitk-octopus.png , vinculada a clojure-log.n01se.net/date/2008-12-24.html . @Dustin: espero que esteja tudo bem. Não é a mesma imagem, mas serve a um propósito semelhante. A partir da captura de tela, parece que isso é parte do kernel do Linux, então eu acho que você poderia achar que cometer e re-assumir uma imagem gitx equivalente ....
naught101
34

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
Kaoru
fonte
29

Esta é a minha opinião sobre este assunto:

Captura de tela:

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)'"
drzymala
fonte
28

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

saeedgnu
fonte
2
Parece ser um clone GitXe muito bom nisso. Recomendar
Yarek T
28

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

albfan
fonte
Muito agradável. Adicionando-os à minha configuração. Mas eu recomendo mudar% Cred% d% Creset ser% C (automático)% d% Creset que vai dar cores diferentes para nomes remotos ou locais
MarkB42
17

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
Peter Ajtai
fonte
15

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

insira a descrição da imagem aqui

nodejh
fonte
14

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:

insira a descrição da imagem aqui

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 .

Eugene Yarmash
fonte
1
git log --graph --oneline só para ter certeza oneliner não se perder
tsenapathy
existe uma maneira de colocar nomes de filiais no lado esquerdo?
anaval
12

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

Adrian Panasiuk
fonte
3
O gitk é eficiente, mas não muito bonito.
289 de Johan
O fato de ele ser embutido o torna agradável e sem complicações para mim. --allMostra especialmente todos os ramos.
BcK 4/01/19
12

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

EddieG098
fonte
@AndyHayden: Não é. Totalmente diferente. Cria um gráfico história git usando Dia
rzymek
11
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.

saída de exemplo

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

Andy
fonte
8

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:

insira a descrição da imagem aqui

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

fracz
fonte
1
Da mesma forma, casual-effects.com/markdeep é muito poderoso para aprimorar os diagramas de arte ascii arranjados à mão.
Beni Cherniavsky-Paskin
7

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

insira a descrição da imagem aqui

bugmenot123
fonte
6

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.

Thomas
fonte
Experimente este github.com/gugod/bin/blob/master/git-graphviz . Eu não tinha todas as dependências no meu ambiente corporativo, então alterar esses iocomandos para comandos perl `git log [...] simples funcionou para mim.
Ross Rogers
Se você estiver em um Mac e quiser experimentar esse script, poderá pegar o perl brew install perl dote cpan common::sense IO::allobter as dependências. Em seguida, basta canalizar a saída para um comando apropriado, como git-graphviz | dot -Tpng -o repo.png. No entanto, a saída não é muito diferente do que o git-big-picture .
Jrhorn424 #
6

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

Spudley
fonte
1
Esse é o mesmo código gráfico usado nos gráficos de impacto do GitHub, não? (por exemplo, github.com/DmitryBaranovskiy/raphael/graphs/impact )
Slipp D. Thompson
@ Sven: Obrigado por apontar isso. Corrigi os links quebrados para você, embora tenha em mente que esta resposta tem cinco anos e, portanto, pode haver uma solução melhor mais recentemente.
Spudley
@ SlippD.Thompson este código está agora no github.com/DmitryBaranovskiy/raphaeljs.com/tree/master/github
Vadim Kotov
6

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

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

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

ou em uma coluna extra

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?

cabeça de cor automática sem suporte git e saída de casca semelhante a tablete

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?

árvore git fantasia estilo saída de tablelike

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

insira a descrição da imagem aqui

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

fanciest_git_tree_tablelike_image

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.

mais uma pergunta
fonte
Você deve explicar em sua resposta como esses snippets do bash se transformarão em comandos sofisticados do tipo git log. Pode-se descobrir usos olhando para a resposta que você vinculou, mas as respostas devem ser independentes
Andras Deak
Você quer dizer que eu deveria explicar o cmd do log do git em detalhes? Ou você poderia me dar um exemplo do que está perdendo, por favor.
onemorequestion
Nota: A saída do comando awesome git log é usada por esse snippet para receber a saída semelhante a tablel em um terminal. Então, ao contrário, como você mencionou;)
onemorequestion
Imaginei que você não estivesse digitando 20 linhas de bash cada vez que precisar. Faz sentido definir isso como uma função bash ou um alias do git. A maioria dos leitores não se preocupa em tentar completar seu código para torná-lo facilmente utilizável. Foi isso que eu quis dizer. Se você apenas colocar o código em um arquivo sh aleatório no seu caminho, poderá me ignorar.
Andras Deak
1
Eu vejo. Obrigado pelo seu conselho. Vou editar minha resposta e adicionar um apelido. Normalmente eu uso arquivos para comandos "longos", como você mencionou. Mas escrever os dois lados aqui é muito mais confortável, eu concordo.
onemorequestion
5

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'
shuaihanhungry
fonte
4

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.

markeissler
fonte