Gráficos bonitos de rama git

He visto algunos libros y artículos que tienen gráficos muy bonitos de ramas y commits de git. ¿Cómo puedo hacer imágenes imprimibles de alta calidad del historial de git?

Actualización: esta respuesta ha recibido mucha más atención de la que merece. Originalmente se publicó porque creo que los gráficos se ven bien y podrían dibujarse en Illustrator para una publicación, y no había una mejor solución. ¡Pero ahora existen respuestas mucho más aplicables a esta Q, como las de Frazz , Jubobs o Harry Lee ! ¡Por favor, vota a esos!

Actualización 2: publiqué una versión mejorada de esta respuesta a la topología de rama Visualizing en la pregunta git , ya que es mucho más apropiado allí. Esa versión incluye lg3, que muestra tanto la información del autor como la del confirmador, por lo que realmente debería consultarla. Dejando esta respuesta por razones históricas (y rep, lo admito), aunque estoy realmente tentado de eliminarla.

Mis 2 ¢ : Tengo dos alias que normalmente incluyo en mi ~/.gitconfigarchivo:

[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/ se git lg1ve así:

y se git lg2ve así:

Muchas de las respuestas aquí son geniales, pero para aquellos que solo quieren una respuesta simple de una línea al punto sin tener que configurar alias ni nada extra, aquí está:

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

No todos lo harían git logtodo el tiempo, pero cuando lo necesites solo recuerda:

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

Para la salida de texto puedes probar:

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

o:

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

o: aquí hay un alias graphviz para dibujar el gráfico DAG.

Yo personalmente uso gitx, gitk --ally gitnub.

Gitgraph.js permite dibujar bonitas ramas git sin un repositorio. Simplemente escriba un código Javascript que configure sus ramas y confirmaciones y renderícelo en el 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);

o con metroplantilla:

o con mensajes de confirmación, autores y etiquetas:

Pruébelo con JSFiddle .

Generarlo con Git Grapher por @bsara.

Construido sobre TikZ y PGF , gitdagses un pequeño paquete de LaTeX que le permite producir sin esfuerzo gráficos de confirmación de gráficos vectoriales, y más.

La generación automática del gráfico de confirmación de un repositorio existente no es el propósito de gitdags; los gráficos que produce son solo para fines educativos .

A menudo lo uso para producir gráficos para mis respuestas a las preguntas de Git, como alternativa a los gráficos de compromiso ASCII:

• ¿Cómo puedo hacer una corrección de errores en el maestro e integrarlo en mis ramas menos estables?
• ¿Cómo funciona git commit --amend funciona exactamente?
• ¿Por qué Git me dice "Actualmente no en ninguna rama" después de ejecutar "git checkout origin / <branch>"?
• ¿Cuál es la diferencia entre fusionar master en branch y fusionar branch en master?
• Git rebase --preserve-merges falla

Aquí hay un ejemplo de dicho gráfico que demuestra los efectos de un simple 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 es un clon de Gitk y GitX para GNOME (también funciona en KDE, etc.) que muestra un gráfico bastante coloreado.

Se desarrolla activamente (a partir de 2012). Le permite ordenar las confirmaciones (nodos de gráficos) cronológica o topológicamente , y ocultar las confirmaciones que no conducen a una rama seleccionada.

Funciona bien con repositorios grandes y gráficos de dependencia complejos.

Capturas de pantalla de muestra, que muestran los repositorios linux-git y linux-2.6:

Acabo de escribir una herramienta que puede generar un bonito gráfico de git commits usando HTML / Canvas.

Y proporcione un complemento jQuery que lo haga fácil de usar.

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

Avance:

Sourcetree es realmente bueno. Imprime un historial atractivo y de tamaño mediano y un gráfico de rama: (lo siguiente se hace en un proyecto experimental de Git solo para ver algunas ramas). Admite Windows 7+ y Mac OS X 10.6+.

git-forestes un excelente script perl que he estado usando durante más de un año y ya casi no uso el git logcomando directamente.

Estas son algunas de las cosas que me encantan de este script:

• Utiliza caracteres unicode para dibujar las líneas en el gráfico, lo que le da un aspecto más continuo a las líneas del gráfico.
• Puede combinarse --reversecon la salida del gráfico, que no es posible con el git logcomando regular .
• Se usa git loginternamente para obtener la lista de confirmaciones, por lo que todas las opciones que pasa git logtambién se pueden pasar a este script.

Tengo un alias usando git-forestlo siguiente:

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

Así es como se ve la salida en un terminal:

Escribí una herramienta web para convertir registros de git en bonitos gráficos SVG: Bit-Booster - Herramienta de dibujo de gráficos de confirmación fuera de línea

Subir salida de git log --pretty='%h|%p|%d' directamente en la herramienta y luego haga clic en el enlace "descargar graph.svg".

La herramienta es del lado del cliente puro, por lo que ninguno de sus datos de Git se comparte con mi servidor. También puede guardar el HTML + JS localmente y ejecutarlo usando URL "file: ///". Verificado en Chrome 48 y Firefox 43 en Ubuntu 12.04.

Genera HTML que se puede publicar directamente en cualquier página (¡incluido el motor de blogs blogspot!). Echa un vistazo a algunas de las publicaciones del blog aquí:

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

Aquí hay una captura de pantalla de un archivo HTML de muestra generado por la herramienta:

http://bit-booster.com/graph.html (la herramienta)

Basado en un script Graphviz que encontré en una respuesta a una pregunta relacionada , he pirateado un script ruby que crea una vista de resumen de un repositorio git. Elimina toda la historia lineal y solo muestra confirmaciones "interesantes", es decir, aquellas con múltiples padres, múltiples hijos o señaladas por una rama o etiqueta. Aquí hay un fragmento del gráfico que genera para jquery :

git-big-picture y BranchMaster son herramientas similares que intentan mostrar solo la estructura de alto nivel de un gráfico, al mostrar solo cómo se relacionan las etiquetas, ramas, fusiones, etc.

Esta pregunta tiene algunas opciones más.

He añadido tres comandos personalizados: git tree, git streey git vtree. Los revisaré en ese orden.

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

Con git streey git vtreehe usado bash para ayudar con el formateo.

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

EDITAR: Esto funciona con git versión 1.9a. El valor de color 'auto' aparentemente está haciendo su debut en este lanzamiento. Es una buena adición porque los nombres de las ramas tendrán un color diferente. Esto facilita la distinción entre ramas locales y remotas, por ejemplo.

Depende de cómo se veían. Yo uso gitx que hace fotos como esta:

Puede comparar git log --graphvs gitk en una combinación de pulpo de 24 vías (originalmente de http://clojure-log.n01se.net/date/2008-12-24.html ):

Para una salida textual más detallada, intente:

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

Puede escribir un alias en $ HOME / .gitconfig

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

Esta es mi opinión sobre este asunto:

Captura de pantalla:

Uso:

git hist - Mostrar el historial de la sucursal actual

git hist --all - Mostrar el gráfico de todas las ramas (incluidos los controles remotos)

git hist master devel - Mostrar la relación entre dos o más ramas

git hist --branches - Mostrar todas las sucursales locales

Agregar --topo-orderpara ordenar confirmaciones topológicamente, en lugar de por fecha (predeterminado en este alias)

Beneficios:

• Parece simple --decorate, por lo que con colores separados para diferentes nombres de ramas
• Agrega correo electrónico de confirmación
• Agrega confirmación de fecha relativa y absoluta
• Ordena confirmaciones por fecha

Preparar:

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 : un visor de repositorio basado en gtk, eso es nuevo pero interesante y útil
http://git.gnome.org/browse/gitg
Lo uso actualmente

Aunque a veces uso gitg , siempre vuelvo a la línea 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 puede ver, es casi un alias para guardar pulsaciones de teclas, basado en:

• --color: aspecto claro
• - gráfico: visualizar padres
• --date-order: el aspecto más comprensible en el repositorio
• --decorar: quien es quien
• --en línea: muchas veces todo lo que necesitas saber sobre un commit
• - simplificar por decoración: básico para un primer vistazo (solo etiquetas, fusiones relevantes, ramas)
• --todos: guardar pulsaciones de teclas con todos los alias con y sin esta opción
• --date = relative (% ar): comprende la actividad en el repositorio (a veces una rama tiene pocos commits cerca del master pero hace meses de él)

Consulte en la versión reciente de git (1.8.5 y superior) que puede beneficiarse de% C (automático) en el marcador de posición de decoración% d

Desde aquí, todo lo que necesita es una buena comprensión de gitrevisions para filtrar lo que necesite (algo así como master..develop, donde --simplify-merges podría ayudar con ramas a largo plazo)

El poder detrás de la línea de comando es la configuración rápida basada en sus necesidades (comprenda que un repositorio no es una configuración de registro de clave única, por lo que a veces es necesario agregar --numstat, o --raw, o --name-status. Aquí git log y los alias son rápidos, potentes y (con el tiempo) el gráfico más bonito que puede lograr. Aún más, con la salida mostrada por defecto a través de un localizador (digamos menos) siempre puede buscar rápidamente dentro de los resultados. ¿No está convencido? Siempre puede analizar el resultado con proyectos como gitgraph

Muy ligeramente ajustando la increíble respuesta de Slipp , puedes usar sus alias para registrar solo una rama:

[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"

Al dejar de lado --all, ahora puedes hacer

git lgBranch1 <branch name>

o incluso

git lgBranch1 --all

Sugiero tig https://github.com/jonas/tig , una herramienta de línea de comando mucho mejor para git.

Puede usar homebrew para instalar tig en macOS:

$ brew install tig
$ tig

Tengo este git logalias ~/.gitconfigpara ver el historial del gráfico:

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

Con esto en su lugar, git lgenerará algo como:

En Git 2.12 + puedes incluso personalizar los colores de línea del gráfico usando la log.graphColorsopción de configuración.

En cuanto al formato de los registros, es similar a --oneline, con la adición del nombre del autor (respetando .mailmap) y la fecha relativa del autor . Tenga en cuenta que la %C(auto)sintaxis, que le dice a Git que use los colores predeterminados para commit hash, etc., es compatible con Git> = 1.8.3 .

¿Intentaste gitko gitk --all? Sin embargo, no tiene una función imprimir / guardar img como función.

GitGraph

Genera una representación PNG o SVG del historial de confirmación de su repositorio Git.

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

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

Esta es mi variación terminal, similar a muchas respuestas aquí. Me gusta ajustar las banderas que se pasan lesspara evitar el ajuste de palabras.

Establecí esto en un alias para acceso rápido ya que el comando es un poco engorroso.

Prueba ditaa . Puede transformar cualquier diagrama ASCII en una imagen. Aunque no se diseñó teniendo en cuenta las ramas de Git, los resultados me impresionaron.

Fuente (archivo txt):

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

Mando:

java -jar ditaa0_9.jar ascii-graph.txt

Resultado:

También admite colores de fondo, líneas discontinuas, diferentes formas y más. Ver los ejemplos .

Si su repositorio se encuentra en Gitlab, puede usar su representación gráfica, ya que se representa como SVG en su navegador.

• Vaya a la vista gráfica de su repositorio, por ejemplo, https://gitlab.com/gitlab-org/gitter/webapp/network/develop

• Desplácese hacia abajo hasta el gráfico (¡vagas cargas confirmadas!)

• Use el inspector de su navegador para copiar el elemento SVG a un nuevo archivo

• Ábralo en un procesador de su elección, por ejemplo, Inkscape

No conozco una herramienta directa, pero tal vez puedas hackear un script para exportar los datos en formato de puntos y renderizarlos con graphviz.

Hay un gráfico de compromiso Git funky como una de las demos de la biblioteca de gráficos web Raphael .

La demostración es estática, pero debería ser bastante fácil tomar el código e intercambiar sus datos estáticos por un conjunto de datos en vivo; creo que son solo datos de confirmación de Git en formato JSON.

La demostración está aquí: http://dmitrybaranovskiy.github.io/raphael/github/impact.html

Una salida de gráfico git similar a una tabla agradable y limpia para conchas

con hashes habitualmente además del árbol de gráficos

o en una columna extra

Editar : ¿Quieres comenzar de inmediato sin leer las explicaciones? Use fragmentos de código de alias, script o funciones de git de la sección EDIT 5 a continuación o incluso la forma más cómoda con EDIT 6 .

Hasta ahora, en todas las respuestas a esta pregunta, ninguna mostró un resultado de aspecto de tabla limpio para los depósitos. Lo más cercano fue esta respuesta de los evangelios desde donde comencé.

El punto central de mi enfoque es contar solo los caracteres del árbol que se muestran al usuario. Luego, llénelos a una longitud personal con espacios en blanco.

Aparte de git, necesitas estas herramientas

• grep
• pegar
• printf
• sed
• seq
• tr
• baño

principalmente a bordo con cualquier distribución de Linux.

El fragmento de código es

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 los espacios en blanco necesarios usamos

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

para obtener todos los caracteres (hasta 1000 por línea) que seleccione solo los caracteres del árbol: * | / \ _ y espacios en blanco con

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

finalmente contarlos y restar el resultado de nuestro valor de longitud elegido, que es 9 en el ejemplo.

Para producir la cantidad calculada de espacios en blanco utilizamos

  seq -s' ' $whitespaces

y truncar los números de posición con

  tr -d '[:digit:]'

que agregarlos al final de nuestra línea gráfica. ¡Eso es!

Git tiene la buena opción de formatear la longitud de los especificadores de salida ya con la sintaxis'%><(amount_of_characters,truncate_option)' , que agrega espacios en blanco desde el lado izquierdo '>' o derecho '<' y puede truncar caracteres desde el inicio 'ltrunc', 'mtrunc' medio o final 'trunc'.

Es importante que los cmd de printf anteriores usen los mismos valores de longitud para la columna git correspondiente.

Diviértete para diseñar tu propia salida de aspecto limpio a tus necesidades.

Extra:

Para obtener el valor de longitud correcto, puede usar el siguiente fragmento

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

y use $ max_chars como el valor de longitud correcto arriba.

EDITAR 1 : Acabo de notar que el carácter subrayado también se usa en el árbol git y edita los fragmentos de código anteriores en consecuencia. Si faltan otros caracteres, deje un comentario.

EDIT 2 : si desea deshacerse de los corchetes alrededor de las entradas de rama y etiqueta, simplemente use "% D" en lugar de "% d" en el comando git, como en EDIT 3.

EDITAR 3 : ¿Quizás la opción de color "automático" es la que más prefiere para las entradas de rama y etiqueta?

Cambiar esta parte del comando git (color 214 )

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

a auto

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

EDIT 4 : ¿O te gusta tu propia mezcla de colores para esa parte, una salida elegante con cabeza parpadeante?

Para poder diseñar primero el encabezado, los nombres de las ramas y las etiquetas, necesitamos la opción de color "automático" en nuestro comando git como en EDIT 3.

Luego podemos reemplazar los valores de color conocidos con los nuestros agregando estas 3 líneas

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

justo antes de la línea

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

en nuestro fragmento de código. Los valores de reemplazo producen los colores anteriores.

Por ejemplo, el valor de reemplazo para la cabeza es

3;5;1;38;5;196

donde 3; significa cursiva, 5; para parpadear y 1; 38; 5; 196 para el color. Para más información comienza aquí. Nota: Este comportamiento depende de su terminal favorito y, por lo tanto, puede no ser utilizable.

PERO puedes elegir el valor de color que prefieras.

DESCRIPCIÓN GENERAL de los valores de color git y equivalentes ANSI

Aquí encontrará una lista con la opción de color / estilo git .

Si necesita la salida en su consola para obtener colores precisos (la imagen de arriba se reduce mediante stackoverflow) puede producir la salida con

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

en su ruta de proyecto git que usa el primer commit de su salida de registro git.

EDITAR 5 : Como mencionó el miembro "Andras Deak", hay algunas formas de usar este código:

1) como un alias :

alias no acepta parámetros, pero una función puede , por lo tanto, solo defina en su .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" ###

   }

y llame a la función git_tably (derivada de tablelike) directamente debajo de su ruta de proyecto git o desde donde desee con su ruta de proyecto git como primer parámetro.

2) como un script de shell :

Lo uso con la opción de pasar un directorio de proyecto git como primer parámetro o, si está vacío, tomar el directorio de trabajo como el comportamiento normal. En su totalidad tenemos

# 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 un alias git :

Quizás la forma más cómoda es agregar un alias git en su .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\");                                          \
                '"

Que simplemente llamar git tablybajo cualquier ruta de proyecto.

Git es tan poderoso que puede cambiar la cabeza, las etiquetas, ... directamente como se muestra arriba y tomada desde aquí .

Otra opción elegante es seleccionar los colores de árbol que más prefieras con

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

eso te da una apariencia loca pero siempre salidas de registro git como una tabla

Demasiado parpadeo! Solo para demostrar lo que es posible. Muy pocos colores especificados conducen a repeticiones de color.

Una referencia completa de .gitconfig está a solo un clic de distancia.

EDITAR 6 : Debido a sus votos positivos, mejoré el fragmento. Ahora puede alimentarlo con casi cualquier comando git log y ya no tiene que adaptar el código. ¡Intentalo!

¿Cómo funciona?

• defina sus comandos de registro git en su .gitconfig como siempre
• definir un número de columna de árbol positivo (opcional), donde se muestra el gráfico git

Entonces solo llama

git tably YourLogAlias

o

git tably YourLogAlias TreeColNumber

donde TreeColNumber sobrescribe un valor siempre definido desde arriba.

Limitación

• para cada especificador en su comando de registro debe usar esta sintaxis

  %><(<N>[,ltrunc|mtrunc|trunc])

  además del último y solo si la columna de árbol elegida no debería ser la última

  (para explicaciones, consulte https://git-scm.com/docs/pretty-formats )

• Debe elegir y usar un delimitador de columna que puede causar problemas si no es único
• el nombre de su número de columna de árbol definido para un alias de registro específico debe ser YourLogAlias-col

Ahora el fragmento mejorado para su .gitconfig

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

[alias]

    # delimiter used in every mylog alias as column seperator
    delim     = ^
    # short overview about the last hashes without graph
    mylog     = log --all --decorate=short --color --pretty=format:'^%C(dim white)%>(12,trunc)%cr%C(reset)^%C(bold 214)%<(7,trunc)%h%C(reset)' -5
    # log with hashes besides graph tree
    mylog2    = 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)%<(80,trunc)%s%C(reset)'
    mylog2-col= 3
    # log with hashes in an own column and more time data
    mylog3    = log --all --graph --decorate=short --color --pretty=format:'^%C(dim white)%>(12,trunc)%cr%C(reset)^%C(cyan)%<(10,trunc)%cs%C(reset)^%C(bold 214)%<(7,trunc)%h%C(reset)^%C(auto)%<(15,trunc)%D%C(reset)^%C(white)%s%C(reset)'
    mylog3-col= 4

    tably     = !bash -c '"                                                                                                            \
                  delim=$(git config alias.delim);                                                                                     \
                  git_log_cmd=$(git config alias.$1);                                                                                  \
                  git_tre_col=${2:-$(git config alias.$1-col)};                                                                        \
                                                                                                                                       \
                  i=0;                                                                                                                 \
                  while read -d\"$delim\" -r col_info;do                                                                               \
                    ((i++));                                                                                                           \
                    col_length[$i]=$(grep -Eo \"\\([0-9]*,[lm]*trunc\\)\" <<< \"$col_info\" | grep -Eo \"[0-9]*\" | head -n 1);        \
                  done <<< \"$(grep -Eo \"pretty=format.*\" <<< \"$git_log_cmd$delim\")\";                                             \
                                                                                                                                       \
                  while IFS= read -r graph;do                                                                                          \
                    chars_count=$(sed -nl1000 \"l\" <<< \"$graph\" | grep -Eo \"\\\\\\\\\\\\\\\\|\\||\\/|\\ |\\*|_\" | wc -l);         \
                    [[ ${chars_count:-0} -gt ${col_length[1]:-0} ]] && col_length[1]=$chars_count;                                     \
                  done < <([[ -n \"$(grep -F graph <<< \"$git_log_cmd\")\" ]] && git log --all --graph --pretty=format:\" \" && echo); \
                                                                                                                                       \
                  while IFS= read -r line;do                                                                                           \
                    j=0;                                                                                                               \
                    while IFS= read -d\"$delim\" -r col_content;do                                                                     \
                      ((j++));                                                                                                         \
                      if [[ $j -eq 1 ]];then                                                                                           \
                        chars=$(sed -nl1000 \"l\" <<< \"$col_content\" | grep -Eo \"\\\\\\\\\\\\\\\\|\\||\\/|\\ |\\*|_\" | wc -l);     \
                        whitespaces=$((${col_length[1]}-$chars));                                                                      \
                        whitespaces=$(seq -s\" \" $whitespaces|tr -d \"[:digit:]\");                                                   \
                        col_content[1]=\"${col_content[1]}$col_content$whitespaces\n\";                                                \
                      else                                                                                                             \
                        col_content[$j]=\"${col_content[$j]}$(printf \"%${col_length[$j]}s\" \"$col_content\") \n\";                   \
                      fi;                                                                                                              \
                    done <<< \"$line$delim\";                                                                                          \
                    for ((k=$j+1;k<=$i;k++));do                                                                                        \
                      col_content[$k]=\"${col_content[$k]}$(printf \"%${col_length[$k]}s\" \"\") \n\";                                 \
                    done;                                                                                                              \
                  done < <(git $1 && echo);                                                                                            \
                                                                                                                                       \
                  while read col_num;do                                                                                                \
                    if [[ -z \"$cont_all\" ]];then                                                                                     \
                      cont_all=${col_content[$col_num]};                                                                               \
                    else                                                                                                               \
                      cont_all=$(paste -d\" \" <(echo -e \"$cont_all\") <(echo -e \"${col_content[$col_num]}\"));                      \
                    fi;                                                                                                                \
                  done <<< $(seq 2 1 ${git_tre_col:-1};seq 1;seq $((${git_tre_col:-1}+1)) 1 $i);                                       \
                  echo -e \"$cont_all\";                                                                                               \
                  "' "git-tably"

Resultados:

o con el nuevo TreeColNumber sobre la marcha

OTRA VEZ: diviértete para diseñar tu propia salida de aspecto limpio a tus necesidades.

algunos alias en ~ / .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 los usuarios de OSX, tomé el ejemplo de @gospes y lo modifiqué ligeramente para gsed ( gnu-sedinstalado a través de homebrew) y ajusté los colores (para trabajar con un fondo negro, no estoy seguro de cómo el ejemplo original podría representarse de la manera que lo hace en el ejemplo, ya que especifica texto negro en un terminal con un fondo negro).

[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

La clave para OSX es instalar primero gnu sed (que tiene la opción -r). Se hace más fácilmente con homebrew, que no sobrescribirá el sed instalado en el sistema, sino que instalará gnu sed como "gsed". Espero que esto ayude a @ SlippD.Thompson, quien comentó anteriormente sobre OSX no funciona.