git-log how - Git branch branch





to get (25)


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

http://www.sourcetreeapp.com/

Eu 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?




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




Você tentou gitk ou gitk --all ? No entanto, ele não possui uma função imprimir / salvar img.




Gitgraph.js permite desenhar lindos ramos sem um repositório. Basta escrever um código Javascript que configure seus branches e commits e renderize-o 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 template metro :

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

Teste com JSFiddle .

Gere-o com Git Grapher by @bsara.




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

Está ativamente desenvolvido (a partir de 2012). Ele permite classificar os commits (nós do gráfico) cronologicamente ou topologically e ocultar commits que não levam a um branch selecionado.

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

Capturas de tela de amostra, mostrando os repositórios linux-git e linux-2.6:




Eu adicionei três comandos personalizados: git tree , git stree e git vtree . Eu vou passar por eles 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 stree e git vtree eu usei 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: Isso funciona com git versão 1.9a. O valor de cor 'auto' está aparentemente fazendo sua estréia nesta versão. É uma boa adição porque os nomes das ramificações receberão uma cor diferente. Isso facilita a distinção entre ramificações locais e remotas, por exemplo.




Eu 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




Além da resposta de 'Slipp D. Thompson', proponho que você adicione este alias para ter a mesma decoração, mas em uma única linha por 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)'"



Esta é a minha opinião sobre este assunto:

Captura de tela:

Uso:

git hist - Mostra o histórico do ramo atual

git hist --all - Mostra o gráfico de todas as filiais (incluindo controles remotos)

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

git hist --branches - Mostrar todas as agências locais

Add --topo-order para ordenar commits topologicamente, ao invés de por date (default neste alias)

Benefícios:

  • Parece exatamente como - --decorate , então com cores separadas para diferentes nomes de ramificações
  • Adiciona o email do committer
  • Adiciona confirmação relativa e data absoluta
  • Classifica commits 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)'"



Olhando para esta conversa tentei usar o meu favorito git-cola& git-dag. Correndo View->DAG...de git-colae substituir Log: master -- com --allmostra o gráfico bonito com todos os ramos.







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

Fonte (arquivo txt):

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

Comando:

java -jar ditaa0_9.jar ascii-graph.txt

Resultado:

Também suporta cores de fundo, linhas tracejadas, formas diferentes e muito mais. Veja ditaa .




Para saída textual, você pode tentar:

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

ou:

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

ou: here's um alias graphviz para desenhar o gráfico DAG.

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




Baseado em um script Graphviz eu encontrei em uma resposta para uma questão relacionada , eu hackeei um script ruby que cria uma visão resumida de um repositório git. Elimina todo o histórico linear e apenas mostra commits "interessantes", ou seja, aqueles com vários pais, vários filhos ou apontados por um branch ou tag. Aqui está um trecho do gráfico que gera para jquery :

git-big-picture e BranchMaster são ferramentas similares 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 questão tem mais algumas opções.




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

A demo é 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 é apenas o Git commit data no formato JSON.

A demo está aqui: http://dmitrybaranovskiy.github.io/raphael/github/impact.html




Atualização: Esta resposta recebeu muito mais atenção do que merece. Ele foi publicado originalmente porque acho que os gráficos são legais e poderiam ser desenhados no Illustrator para uma publicação - e não havia uma solução melhor. Mas agora existem respostas muito mais aplicáveis ​​a este Q, como o de fracz , Jubobs ou Harry Lee ! Por favor, vá upvote aqueles !!

Atualização 2: publiquei uma versão aprimorada desta resposta para a topologia de ramificação Visualizando na questão git , já que é muito mais apropriada lá. Essa versão inclui o lg3 , que mostra as informações do autor e do committer, então você realmente deveria dar uma olhada. Deixando essa resposta para razões históricas (e rep, eu admito), embora eu esteja realmente tentado a simplesmente deletar.

2 ¢ : Eu tenho dois aliases que eu normalmente jogo no meu arquivo ~/.gitconfig :

[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 aparece assim:

e git lg2 parece com isso:




git-forest é um excelente script perl que estou usando há mais de um ano e dificilmente uso o comando git log 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 --reverse com a saída do gráfico, o que não é possível com o comando git log regular.
  • Ele usa o git log internamente para pegar a lista de commits, então todas as opções que você passa para o git log também podem ser passadas para este script.

Eu tenho um alias usando git-forest seguinte forma:

[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 tenho este alias de git log 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, o git l mostrará algo como:

No Git 2.12 + você pode até personalizar as cores da linha do gráfico usando a opção de configuração log.graphColors .

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




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

Esta é a minha variação terminal, semelhante a muitas respostas aqui. Eu gosto de ajustar os sinalizadores passados ​​para less para evitar quebra automática.

Eu configurei isso para um alias para acesso rápido, pois o comando é um pouco incômodo.




Muitas das respostas aqui são ótimas, mas para aqueles que querem apenas uma simples resposta de uma linha ao ponto sem ter que configurar aliases ou algo extra, aqui está:

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

Nem todo mundo estaria fazendo um git log o tempo todo, mas quando você precisar, lembre-se:

" Um Cachorro " = git log - a - d - ecorate - o neline - g rap




Para os usuários do OSX, eu peguei o exemplo @gospes e o modifiquei ligeiramente para gsed ( gnu-sedinstalado via homebrew) e ajustei as cores (para trabalhar com um fundo preto, não sei como o exemplo original poderia renderizar da maneira que ele faz no exemplo, uma vez que especifica 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 é primeiro instalar o gnu sed (que tem a opção -r). Mais facilmente feito com o homebrew, que não sobrescreve o sed instalado pelo sistema, mas instalará o gnu sed como "gsed". Espero que isso ajude @ SlippD.Thompson que comentou acima sobre OSX não está funcionando.




Eu escrevi uma ferramenta web para converter git logs em bonitos gráficos SVG: bit-booster.com/graph.html

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

A ferramenta é do lado do cliente 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 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 blogspot blogging engine!). Dê uma olhada em alguns dos posts aqui:

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

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

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




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



Etapas para excluir um ramo:

para excluir o ramo remoto:

git push origin --delete <your_branch> 

para excluir o ramo local , você tem três maneiras:

1: git branch -D <branch_name> 

2: git branch --delete --force <branch_name>  //same as -D

3: git branch --delete  <branch_name>         //error on unmerge

Explique: OK, apenas explique o que está acontecendo aqui!

Simplesmente git push origin --delete para deletar sua filial remota APENAS , adicione o nome da ramificação no final e isso irá deletar e empurrá-la para o controle remoto ao mesmo tempo ...

Além disso, git branch -D , que simplesmente exclui a filial local SOMENTE ! ...

-D significa --delete --force que irá deletar o branch mesmo que ele não esteja mesclado (force delete), mas você também pode usar -d que significa --delete que --delete um erro respectivo do status de mesclagem do branch ...

Eu também criei a imagem abaixo para mostrar os passos:





git git-log