Gráficos de ramos git bonitos

Atualização: esta resposta tem recebido muito mais atenção do que merece.  Foi originalmente postado porque eu acho que os gráficos parecem bonitos e eles poderiam ser desenhados-em Ilustrador para uma publicação– e não havia uma solução melhor.  Mas agora existem respostas muito mais aplicáveis a este Q, Como fracz's, Jubobs', ou Harry Lee's!  Por favor, vai votar isso!!

Atualização 2: eu postei uma versão melhorada desta resposta para o Visualizando topologia do ramo na questão do git, já que é muito mais apropriado lá.  Essa versão inclui lg3, o que mostra tanto a informação do autor e do committer, então você realmente deve verificar.  Deixando esta resposta para razões históricas (&rep, eu admito), embora eu estou realmente tentado a apenas apagá-lo.

2¢: tenho dois pseudónimos que costumo colocar no meu ficheiro:

[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 lg1 parece isto.:

E Parece-se com isto.:

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

Não é todo mundo estaria fazendo um git log o tempo todo, mas quando você precisa apenas lembre-se: "Um Cão " = git log --umll --decorate --oneline --graph

Para a saída textual pode tentar:

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

Ou:

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

Ou: aqui está a graphviz alias for drawing the DAG graph.

Eu uso pessoalmente gitx, gitk --all e gitnub.

Gitgraph.o js permite desenhar ramos git bonitos sem um repositório. Basta escrever um código Javascript que configura seus ramos e commits e rendê-lo 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 metro Modelo:

Ou com mensagens de commit, autores e marcas:

Testa - o com JSFiddle .

Gera-o com Git Grapher por @bsara.

Construído em cima de TikZ & PGF, gitdags é um pequeno pacote de LaTeX que lhe permite produzir facilmente gráficos vectoriais de commit, e muito mais.

A geração automática do grafo de commit de um repositório existente é Não {[12] } O objectivo de gitdags; Os gráficos que produz apenas se destinam a fins educativos .

Muitas vezes uso-o para produzir gráficos para as minhas respostas às perguntas Git, como uma alternativa ao commit ASCII gráficos:

• Como posso fazer um bugfix no master e integrá-lo no meu(S) ramo (s) menos estável (s)?
• Como é que o git commit --Emend funciona, exatamente?
• porque é que o Git me diz" não está em nenhum ramo " depois de executar "git checkout origin/"?
• Qual é a diferença entre fundir master em branch e fundir branch em master?
• Git rebase --preserve-merges falha

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

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

Está activamente desenvolvido (a partir de 2012). Permite-lhe ordenar os commits (nós de grafos) cronologicamente ou topologicamente, e esconder os commits que não levam a um ramo seleccionado.

Funciona bem com repositórios grandes e gráficos de dependências complexos.

Imagens de exemplo, mostrando o linux-git e o linux-2. 6 repositorio:

Http://www.sourcetreeapp.com/

Acabei de escrever uma ferramenta que pode gerar git grafo commits usando HTML/Canvas.

E fornecer um plugin jQuery que torna fácil de usar.

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

Antevisão:

git-forest é um excelente script perl que tenho usado por mais de um ano e eu quase não uso o comando git log diretamente mais.

• ele usa caracteres unicode para desenhar as linhas do grafo dando uma olhada mais contínua para as linhas do grafo.
• pode combinar --reverse com o resultado do gráfico, o que não é possível com o comando regular git log.
• ele usa git log internamente para pegue a lista de commits, para que todas as opções que você passa para git log também possam ser passadas para este script.

Tenho um nome falso que usa git-forest como se segue:

[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 num terminal:

Com base num programa de Graphviz que encontrei em uma resposta a uma pergunta relacionada , hackeei um programa em ruby que cria uma vista sumária de um repositório de git. Ele elucida toda a história linear e apenas mostra "interessantes" commits, ou seja, aqueles com múltiplos pais, múltiplos filhos, ou apontados por um ramo ou etiqueta. Aqui está um trecho do gráfico que ele gera para jquery:

Git-big-picture and BranchMaster are similar ferramentas que tentam mostrar apenas a estrutura de alto nível de um grafo, mostrando apenas como tags, ramificações, mesclamentos, etc. são parentes.

Esta questão tem mais algumas opções.

Pode comparar git log --graph vs. gitk numa junção de polvos de 24 vias (originalmente de http://clojure-log.n01se.net/date/2008-12-24.html):

Eu escrevi uma ferramenta web para converter logs git em grafos SVG bonitos: Bit-Booster-Offline Commit Graph Drawing Tool

Enviar o resultado de git log --pretty='%h|%p|%d' directamente para a ferramenta e depois carregar no " grafo de transferência.svg " link.

A ferramenta é pura do lado do cliente, e por isso nenhum dos seus dados Git é partilhado com o meu servidor. Você também pode gravar o HTML + JS localmente e executá-lo usando "file://" URL ' s. verificado no Chrome 48 e Firefox 43 no Ubuntu 12.04.

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

Aqui está uma imagem de um ficheiro HTML de exemplo gerado pela ferramenta:

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

[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 stree e git vtree usei o bash para ajudar com a 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: isto funciona com o git versão 1. 9 a. O valor da cor 'auto' está aparentemente a fazer a sua estreia nesta versão. É uma boa adição, porque os nomes dos ramos vão ter uma cor diferente. Isto torna tudo mais fácil. para distinguir entre ramos locais e remotos, por exemplo.

Para uma produção textual mais detalhada, por favor tente:

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

Pode escrever pseudónimo em $HOME/.gitconfig

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

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

Embora às vezes eu use gitg , Volte sempre para a linha de comandos:

[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 

• -- color: clear look
• --graph: visualize os pais
• -- date-order: most comprehensible look at repo
• decora: quem é quem
• --oneline: muitas vezes tudo o que você precisa saber sobre um commit
• --simplify-by-decoration: basic for a first look (just tags, relevant merges, sucursais)
• -- all: a gravar as teclas com todos os nomes alternativos com e sem esta opção
• -- date=relativo (%ar): compreender a actividade na repo (por vezes, um ramo é poucos commits próximos do mestre, mas há meses atrás dele)

Ver na versão recente do git (1, 8, 5 ou mais) pode beneficiar de %C(auto) na decoração da substituição %D

A potência por trás da linha de comandos é a configuração rápida baseada nas suas necessidades (compreenda que um repo não é uma configuração única de registo de chaves, por isso é necessário adicionar --numstat, ou --raw, ou --name-status. Aqui o git log e os pseudónimos são rápidos, poderosos e (com o tempo) o gráfico mais bonito que você pode alcançar. Ainda mais, com o resultado mostrado por padrão através de um pager (dizer menos) você sempre pode pesquisar rapidamente dentro dos resultados. Não estás convencido? Podes. analisar sempre o resultado com projectos como gitgraph

Imagem:

Utilização:

git hist - mostrar o histórico do ramo actual

git hist --all - mostrar o gráfico de todos os ramos (incluindo os comandos)

git hist master devel - mostrar a relação entre dois ou mais ramos

git hist --branches - Mostrar todos os ramos locais

Adicionar --topo-order para ordenar commits topologicamente, em vez de por data (por omissão neste também conhecido por)

Prestações:

• parece simples --decorate, por isso com cores separadas para nomes de ramos diferentes
• adiciona um e-mail committer
• adiciona a data relativa e absoluta da persistência
• O Sorts compromete-se 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)'"

Tenho este git log pseudónimo em ~/.gitconfig para ver 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 isto no lugar, {[3] } irá produzir algo como:

In Git 2.12+ Você pode até personalizar as cores das linhas do gráfico usando o log.graphColors opção de configuração.

GitGraph

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

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

Muito ligeiramente alterado resposta fantástica do Slipp, Você pode usar seus pseudônimos 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"

Deixando de fora o --all você pode agora fazer

git lgBranch1 <branch name>

Ou mesmo

git lgBranch1 --all

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

Pode usar o homebrew para instalar o tig no macOS:

$ brew install tig
$ tig

Tenta ditaa . Ele pode transformar qualquer diagrama ASCII em uma imagem. Embora não tenha sido projetado com Git branches em mente, fiquei impressionado com os resultados.

Fonte (ficheiro txt):

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

Comando:

java -jar ditaa0_9.jar ascii-graph.txt

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

A demonstração é estática, mas deve ser fácil o suficiente para pegar o código e trocar seus dados estáticos por um conjunto de dados ao vivo -- eu acho que é apenas git commit dados no formato JSON.

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

Para usuários OSX, fiz o @gospes exemplo e ligeiramente modificado para gsed (gnu-sed instalado via homebrew) e ajustado as cores (para trabalhar com um plano de fundo preto, não sei como exemplo original poderia render a forma como ele faz no exemplo, pois especifica o texto 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 tem a opção-r). Mais facilmente feito com o homebrew, que não irá sobrepor o system-installed sed, but will instead install gnu sed as "gsed". Espero que isso ajude @SlippD.Thompson que comentou acima sobre o OSX não funcionar.

Alguns nomes falsos em ~/.Oh-my-zsh/plugins/git / git.Forum.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 além da resposta de 'Slipp D. Thompson', proponho que acrescente este pseudónimo à mesma decoração, mas numa única linha, commit:

git config --global alias.tre "log --graph --decorate --pretty=oneline --abbrev-commit --all --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)'"