tipos - git ver archivos modificados

Bonitos gráficos de rama git

Question

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

Answer 1

Esta es mi opinión sobre este asunto:

Captura de pantalla:

Uso:

git hist - Mostrar la historia de la rama actual

git hist --all - Muestra la gráfica de todas las ramas (incluidos los controles remotos)

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

git hist --branches - git hist --branches - Mostrar todas las sucursales locales

Agregue --topo-order para ordenar las confirmaciones topológicamente, en lugar de por fecha (por defecto en este alias)

Beneficios:

• Se parece a llano: --decorate , así que con colores separados para diferentes nombres de rama
• Agrega un correo electrónico al remitente
• Agrega la fecha relativa y absoluta de confirmación.
• Clasificaciones 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)''"

Answer 2

¿ gitk o gitk --all ? Sin embargo, no tiene una función de imprimir / guardar img.

Answer 3

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

Y proporciona un complemento de jQuery que lo hace fácil de usar.

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

Avance:

Answer 4

Aunque a veces uso gitg , siempre vuelvo a la línea 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 

Como puede ver, es casi un alias guardando pulsaciones de teclas, basado en:

• --color: mirada clara
• --grafo: visualizar a los padres
• --date-order: mirada más comprensible en repo
• --decorar: quien es quien
• --oneline: muchas veces, todo lo que necesitas saber sobre un compromiso
• --simplificar por decoración: básico para un primer vistazo (solo etiquetas, fusiones relevantes, sucursales)
• --all: guardando pulsaciones con todos los alias con y sin esta opción
• --date = relativo (% ar): Entienda la actividad en el repositorio (a veces, una sucursal está cerca de un maestro pero hace meses)

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

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

El poder detrás de la línea de comandos es la configuración rápida basada en sus necesidades (comprender 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. Más aún, con la salida mostrada por defecto a través de un buscapersonas (digamos menos) siempre puede buscar rápidamente dentro de los resultados. ¿No está convencido? Siempre puede analizar el resultado con proyectos como gitgraph

Answer 5

Basado en un script de Graphviz que encontré en una respuesta a una pregunta relacionada , he pirateado un script de ruby que crea una vista de resumen de un repositorio de git. Elimina toda la historia lineal y solo muestra confirmaciones "interesantes", es decir, aquellas con varios padres, múltiples hijos o apuntadas 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 una gráfica, al mostrar solo cómo se relacionan las etiquetas, las ramas, las fusiones, etc.

Esta pregunta tiene algunas opciones más.

Answer 6

Construido sobre TikZ & PGF , gitdags es un pequeño paquete de LaTeX que te permite producir sin esfuerzo gráficos de gráficos vectoriales, y mucho más.

La generación automática de un gráfico de compromiso de un repositorio existente no es el propósito de gitdags ; Las gráficas 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 confirmación ASCII:

• ¿Cómo puedo hacer una corrección de errores en el maestro e integrarla en mis sucursales menos estables?
• ¿Cómo funciona git commit --amend, exactamente?
• ¿Por qué Git me dice "Actualmente no estoy en ninguna rama" después de ejecutar "git checkout origin / <branch>"?
• ¿Cuál es la diferencia entre fusionar maestro en rama y fusionar rama en maestro?
• Rebase de Git - las fusiones de reserva fallan

Este es un ejemplo de un gráfico de este tipo que demuestra los efectos de una rebase simple:

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

Answer 7

Depende de cómo se vieran. Yo uso gitx que hace imágenes como esta:

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

Answer 8

Escribí una herramienta web para convertir los registros de git en bonitos gráficos SVG: bit-booster.com/graph.html

Cargue la salida del 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 Git se comparte con mi servidor. También puede guardar el HTML + JS localmente y ejecutarlo utilizando las URL de "file: ///". Verificado en Chrome 48 y Firefox 43 en Ubuntu 12.04.

Genera HTML que puede publicarse directamente en cualquier página (incluido el motor de blogspot blogging). 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:

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

Answer 9

GitGraph

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

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

Answer 10

Hay una gráfica de compromiso funky de Git como una de las demostraciones de la biblioteca de gráficos web de Raphael .

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

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

Answer 11

He añadido tres comandos personalizados: git tree , git stree y git vtree . Los repasaré 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 stree y git vtree he 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 la versión 1.9a de git. El valor de color ''auto'' aparentemente está haciendo su debut en esta versión. Es una buena adición porque los nombres de las ramas obtendrán un color diferente. Esto hace que sea más fácil distinguir entre sucursales locales y remotas, por ejemplo.

Answer 12

Muchas de las respuestas aquí son excelentes, pero para aquellos que solo desean una respuesta simple de una línea a otra sin tener que configurar alias o algo adicional, aquí está:

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

No todos harían un git log todo el tiempo, pero cuando lo necesite recuerde:

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

Answer 13

No conozco una herramienta directa, pero quizás pueda hackear un script para exportar los datos a formato de puntos y renderizarlos con graphviz.

Answer 14

Para salida textual puedes probar:

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

o:

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

o: here''s un alias de graphviz para dibujar el gráfico DAG.

Personalmente uso gitx , gitk --all y gitnub .

Answer 15

Para una salida de texto más detallada, intente:

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

Puedes escribir alias en $ HOME / .gitconfig

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

Answer 16

Para usuarios de OSX, tomé el ejemplo de @gospes y lo modifiqué ligeramente para gsed ( gnu-sed instalado 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 representar la forma en el ejemplo, ya que especifica texto negro en una 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). Lo más fácil es hacerlo con homebrew, que no sobrescribirá el sed instalado por el sistema, sino que instalará gnu sed como "gsed". Espero que esto ayude a @ SlippD.Thompson que comentó anteriormente acerca de que OSX no funciona.

Answer 17

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

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. Vea ditaa .

Answer 18

SourceTree es realmente bueno. Imprime un buen historial de tamaño mediano y un gráfico de sucursales: (lo siguiente se hace en un proyecto experimental de Git solo para ver algunas sucursales). Compatible con Windows 7+ y Mac OS X 10.6+.

http://www.sourcetreeapp.com/

Answer 19

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

Puedes usar homebrew para instalar tig en macOS:

$ brew install tig
$ tig

Answer 20

Tengo este alias de git log en ~/.gitconfig para 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 l producirá algo como:

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

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

Answer 21

Gitgraph.js permite dibujar bonitas ramas de git sin un repositorio. Simplemente escriba un código de Javascript que configure sus sucursales y confirme y procéselas 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 plantilla de metro :

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

JSFiddle con JSFiddle .

Generarlo con Git Grapher por @bsara.

Answer 22

git-forest es un excelente script en perl que he estado usando durante más de un año y ya casi no uso el comando git log directamente.

Estas son algunas de las cosas que me gustan de este guión:

• Utiliza caracteres Unicode para dibujar las líneas en el gráfico dando una apariencia más continua a las líneas del gráfico.
• Puede combinar --reverse con la salida del gráfico, lo que no es posible con el comando regular git log .
• Utiliza git log internamente para capturar la lista de confirmaciones, por lo que todas las opciones que pase a git log también se pueden pasar a esta secuencia de comandos.

Tengo un alias que usa git-forest siguiente manera:

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

Answer 23

Gitg es un clon de Gitk y GitX para GNOME (también funciona en KDE, etc.) que muestra un gráfico de colores bonitos.

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

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

Ejemplos de capturas de pantalla, que muestran los repositorios linux-git y linux-2.6:

Answer 24

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 se podrían dibujar en Illustrator para una publicación, y no había mejor solución. ¡Pero ahora existen muchas más respuestas aplicables a esta Q, como las de fracz , Jubobs o Harry Lee ! Por favor, sube y vota esos !!

Actualización 2: He publicado una versión mejorada de esta respuesta en la topología de rama Visualizing en git question, ya que es mucho más apropiada allí. Esa versión incluye lg3 , que muestra tanto la información del autor como del autor, por lo que realmente deberías comprobarlo. Dejando esta respuesta por razones históricas (y rep, lo admitiré), aunque estoy realmente tentado de eliminarlo.

2 ¢ : tengo dos alias que normalmente tiro en mi archivo ~/.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 ve así:

y git lg2 ve así:

Answer 25

Una respuesta asombrosa de Slipp muy retocada , puede 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 todo lo que ahora puedes hacer

git lgBranch1 <branch name>

o incluso

git lgBranch1 --all

Answer 26

gitg : un visor de repositorio basado en gtk, eso es nuevo pero interesante y útil
http://git.gnome.org/browse/gitg
Lo uso actualmente

Answer 27

Además de la respuesta de ''Slipp D. Thompson'', le propongo que agregue este alias para tener la misma decoración pero en una sola línea por cometer:

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

Answer 28

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

Answer 29

Mirando esta conversación intenté usar mi favorito git-colay git-dag. Ejecutar View->DAG...desde git-colay reemplazar el registro: master -- con --allmuestra bonito gráfico con todas las ramas.

Answer 30

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 pasadas a less para evitar el ajuste de palabras.

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