Hübsche Git-Zweiggraphen

Ich habe gesehen, dass einige Bücher und Artikel einige wirklich hübsch aussehende Grafiken von Git-Zweigen und Commits enthalten. Wie kann ich qualitativ hochwertige druckbare Bilder der Git-Geschichte erstellen?

Update: Diese Antwort hat weit mehr Aufmerksamkeit erhalten, als sie verdient. Es wurde ursprünglich veröffentlicht, weil ich denke, dass die Grafiken gut aussehen und in Illustrator für eine Veröffentlichung gezeichnet werden könnten - und es gab keine bessere Lösung. Aber es gibt jetzt viel zutreffendere Antworten auf diese Frage, wie die von fracz , Jubobs oder Harry Lee ! Bitte stimmen Sie diese ab !!

Update 2: Ich habe eine verbesserte Version dieser Antwort auf die Visualisierung der Branchentopologie in der Git- Frage veröffentlicht, da sie dort weitaus angemessener ist. Diese Version enthält lg3Informationen zum Autor und zum Committer. Sie sollten sie also unbedingt überprüfen. Ich lasse diese Antwort aus historischen (& rep, ich gebe zu) Gründen, obwohl ich wirklich versucht bin, sie einfach zu löschen.

Meine 2 ¢ : Ich habe zwei Aliase, die ich normalerweise in meine ~/.gitconfigDatei werfe :

[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 lg1Sieht wie folgt aus :

und git lg2sieht so aus:

Viele der Antworten hier sind großartig, aber für diejenigen, die nur eine einfache, einzeilige Antwort wünschen, ohne Aliase oder etwas anderes einrichten zu müssen, hier ist es:

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

Nicht jeder würde die git logganze Zeit etwas tun , aber wenn Sie es brauchen, denken Sie daran:

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

Für die Textausgabe können Sie versuchen:

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

oder:

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

oder: Hier ist ein Graphviz-Alias ​​zum Zeichnen des DAG-Graphen.

Ich persönlich benutze gitx, gitk --allund gitnub.

Mit Gitgraph.js können hübsche Git-Zweige ohne Repository gezeichnet werden . Schreiben Sie einfach einen Javascript-Code, der Ihre Zweige und Commits konfiguriert, und rendern Sie ihn im Browser.

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

oder mit metroVorlage:

oder mit Commit-Nachrichten, Autoren und Tags:

Testen Sie es mit JSFiddle .

Generiere es mit Git Grapher von @bsara.

Aufbauend auf der TikZ & PGF , gitdagsist ein kleines LaTeX - Paket , das Sie mühelos ermöglicht produzieren Vektor-Grafiken Diagramme begehen, und vieles mehr.

Die automatische Generierung des Commit-Diagramms eines vorhandenen Repositorys ist nicht der Zweck von gitdags; Die von ihm erstellten Grafiken sind nur für Bildungszwecke gedacht .

Ich verwende es oft, um Diagramme für meine Antworten auf Git-Fragen zu erstellen, als Alternative zu ASCII-Festschreibungsdiagrammen:

• Wie kann ich einen Bugfix auf dem Master durchführen und ihn in meine weniger stabilen Zweige integrieren?
• Wie funktioniert git commit --amend genau?
• Warum sagt Git mir "Derzeit in keinem Zweig", nachdem ich "git checkout origin / <branch>" ausgeführt habe?
• Was ist der Unterschied zwischen dem Zusammenführen von Master und Zweig und dem Zusammenführen von Zweig und Master?
• Git rebase --preserve-merges schlägt fehl

Hier ist ein Beispiel für ein solches Diagramm, das die Auswirkungen einer einfachen Rebase zeigt:

\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 ist ein Klon von Gitk und GitX für GNOME (funktioniert auch mit KDE usw.), der ein hübsches farbiges Diagramm zeigt.

Es wird aktiv weiterentwickelt (Stand 2012). Sie können die Commits (Diagrammknoten) entweder chronologisch oder topologisch sortieren und Commits ausblenden, die nicht zu einem ausgewählten Zweig führen.

Es funktioniert gut mit großen Repositorys und komplexen Abhängigkeitsgraphen.

Beispiel-Screenshots mit den Repositorys linux-git und linux-2.6:

SourceTree ist wirklich gut. Es druckt ein gut aussehendes und mittelgroßes Verlaufs- und Zweigdiagramm aus: (Das Folgende wird in einem experimentellen Git-Projekt durchgeführt, um nur einige Zweige zu sehen). Unterstützt Windows 7+ und Mac OS X 10.6+.

http://www.sourcetreeapp.com/

Ich habe gerade ein Tool geschrieben, das mit HTML / Canvas ein hübsches Git-Commit-Diagramm erstellen kann.

Und stellen Sie ein jQuery-Plugin bereit, das die Verwendung vereinfacht.

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

Vorschau:

git-forestist ein exzellentes Perl-Skript, das ich seit mehr als einem Jahr verwende und den git logBefehl kaum noch direkt direkt verwende.

Dies sind einige der Dinge, die ich an diesem Skript liebe:

• Es werden Unicode-Zeichen verwendet, um die Linien im Diagramm zu zeichnen und den Diagrammlinien ein kontinuierlicheres Aussehen zu verleihen.
• Sie können --reversemit der Diagrammausgabe kombinieren , was mit dem regulären git logBefehl nicht möglich ist .
• Es wird git logintern verwendet, um die Liste der Commits abzurufen, sodass alle Optionen, an die Sie übergeben, git logauch an dieses Skript übergeben werden können.

Ich habe einen Alias git-forestwie folgt:

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

So sieht die Ausgabe auf einem Terminal aus:

Ich habe ein Web-Tool zum Konvertieren von Git-Protokollen in hübsche SVG-Diagramme geschrieben: Bit-Booster - Offline Commit Graph Drawing Tool

Laden Sie die Ausgabe git log --pretty='%h|%p|%d'direkt in das Tool hoch und klicken Sie dann auf den Link "graph.svg herunterladen".

Das Tool ist rein clientseitig und daher werden keine Ihrer Git-Daten für meinen Server freigegeben. Sie können HTML + JS auch lokal speichern und mit den URLs "file: ///" ausführen. Verifiziert unter Chrome 48 und Firefox 43 unter Ubuntu 12.04.

Es generiert HTML, das direkt auf jeder Seite veröffentlicht werden kann (einschließlich der Blogspot-Blogging-Engine!). Schauen Sie sich hier einige Blog-Beiträge an:

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

Hier ist ein Screenshot einer vom Tool generierten HTML-Beispieldatei:

http://bit-booster.com/graph.html (das Tool)

Basierend auf einem Graphviz-Skript, das ich in einer Antwort auf eine verwandte Frage gefunden habe , habe ich ein Ruby-Skript gehackt , das eine zusammenfassende Ansicht eines Git-Repositorys erstellt. Es entfernt die gesamte lineare Geschichte und zeigt nur "interessante" Commits an, dh solche mit mehreren Eltern, mehreren Kindern oder auf die durch einen Zweig oder ein Tag hingewiesen wird. Hier ist ein Ausschnitt des Diagramms, das für jquery generiert wird :

git-big-picture und BranchMaster sind ähnliche Tools, die versuchen, nur die allgemeine Struktur eines Diagramms anzuzeigen, indem nur angezeigt wird, wie Tags, Zweige, Zusammenführungen usw. zusammenhängen.

Diese Frage hat einige weitere Optionen.

Ich habe drei benutzerdefinierte Befehle hinzugefügt : git tree, git streeund git vtree. Ich werde sie in dieser Reihenfolge durchgehen.

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

Mit git streeund git vtreeich benutze Bash, um bei der Formatierung zu helfen.

[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: Dies funktioniert mit Git Version 1.9a. Der Farbwert 'auto' feiert offenbar sein Debüt in dieser Version. Es ist eine schöne Ergänzung, da Zweignamen eine andere Farbe erhalten. Dies erleichtert beispielsweise die Unterscheidung zwischen lokalen und entfernten Zweigen.

Kommt darauf an, wie sie aussahen. Ich benutze gitx , das Bilder wie dieses macht:

Sie können mit git log --graphgitk bei einer 24-Wege-Octopus-Zusammenführung vergleichen (ursprünglich von http://clojure-log.n01se.net/date/2008-12-24.html ):

Für eine detailliertere Textausgabe versuchen Sie bitte:

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

Sie können einen Alias ​​in $ HOME / .gitconfig schreiben

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

Dies ist meine Einstellung zu diesem Thema:

Bildschirmfoto:

Verwendungszweck:

git hist - Zeigt den Verlauf der aktuellen Niederlassung an

git hist --all - Zeigen Sie die Grafik aller Zweige (einschließlich Fernbedienungen) an.

git hist master devel - Zeigen Sie die Beziehung zwischen zwei oder mehr Zweigen

git hist --branches - Alle lokalen Niederlassungen anzeigen

Hinzufügen --topo-order, um Commits topologisch statt nach Datum zu sortieren (Standard in diesem Alias)

Leistungen:

• Sieht genauso aus wie normal --decorate, also mit separaten Farben für verschiedene Filialnamen
• Fügt eine Committer-E-Mail hinzu
• Fügt das relative und absolute Festschreibungsdatum hinzu
• Sortiert Commits nach Datum

Installieren:

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 : Ein GTK-basierter Repository-Viewer, der neu, aber interessant und nützlich ist.
http://git.gnome.org/browse/gitg
Ich verwende ihn derzeit

Obwohl ich manchmal gitg benutze , kehre immer zur Kommandozeile zurück:

[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 

Wie Sie sehen können, handelt es sich fast um einen Tastendruck, der Aliase speichert, basierend auf:

• - Farbe: klarer Blick
• --graph: Eltern visualisieren
• --date-order: verständlichster Blick auf Repo
• --decorate: wer ist wer
• --oneline: Oft alles, was Sie über ein Commit wissen müssen
• --simplify-by-Decoration: Grundlegend für einen ersten Blick (nur Tags, relevante Zusammenführungen, Zweige)
• --all: Speichern von Tastenanschlägen mit allen Aliasnamen mit und ohne diese Option
• --date = relative (% ar): Verstehe die Aktivität im Repo (manchmal hat ein Zweig nur wenige Commits in der Nähe des Masters, aber vor Monaten von ihm)

In der neuesten Version von git (1.8.5 und höher) können Sie von% C (auto) profitieren, wenn Sie den Platzhalter% d dekorieren

Von hier aus brauchen Sie nur noch ein gutes Verständnis der Gitrevisionen , um alles zu filtern, was Sie brauchen (so etwas wie master..develop, wo --simplify-merges bei langfristigen Verzweigungen helfen könnte).

Die Leistung hinter der Befehlszeile ist die schnelle Konfiguration, die auf Ihren Anforderungen basiert (verstehen Sie, dass ein Repo keine eindeutige Schlüsselprotokollkonfiguration ist, daher ist manchmal das Hinzufügen von --numstat oder --raw oder --name-status erforderlich. Hier git log und Aliase sind schnell, leistungsstark und (mit der Zeit) das schönste Diagramm, das Sie erzielen können. Darüber hinaus können Sie mit der Ausgabe, die standardmäßig über einen Pager angezeigt wird (sagen wir weniger), immer schnell in Ergebnissen suchen. Nicht überzeugt? Sie können das Ergebnis immer analysieren mit Projekten wie Gitgraph

Wenn Sie Slipps großartige Antwort leicht anpassen , können Sie seine Aliase verwenden, um nur einen Zweig zu protokollieren:

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

Wenn Sie das --allweglassen, können Sie es jetzt tun

git lgBranch1 <branch name>

oder auch

git lgBranch1 --all

Ich schlage tig https://github.com/jonas/tig vor , ein viel besseres Befehlszeilen-Tool für Git.

Sie können Homebrew verwenden, um tig unter macOS zu installieren:

$ brew install tig
$ tig

Ich habe diesen git logAlias ~/.gitconfig, um den Diagrammverlauf anzuzeigen:

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

Wenn dies vorhanden ist, git lwird Folgendes ausgegeben:

In Git 2.12 + können Sie sogar die Linienfarben des Diagramms mithilfe der log.graphColorsKonfigurationsoption anpassen .

Das Format der Protokolle ähnelt dem Format, wobei --onelineder Autorenname (jeweils .mailmap) und das relative Autorendatum hinzugefügt werden . Beachten Sie, dass die %C(auto)Syntax, die Git anweist, die Standardfarben für Commit-Hash usw. zu verwenden, in Git> = 1.8.3 unterstützt wird .

Hast du es versucht gitkoder gitk --all? Es gibt jedoch keine Funktion zum Drucken / Speichern als Bild.

GitGraph

Generiert eine PNG- oder SVG-Darstellung des Commit-Verlaufs Ihres Git-Repositorys.

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

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

Dies ist meine Terminalvariante, ähnlich wie viele Antworten hier. Ich mag es, die übergebenen Flags anzupassen less, um das Umbrechen von Wörtern zu verhindern.

Ich habe dies auf einen Alias ​​für den schnellen Zugriff gesetzt, da der Befehl etwas umständlich ist.

Versuchen Sie es mit Ditaa . Es kann jedes ASCII-Diagramm in ein Bild umwandeln. Obwohl es nicht für Git-Zweige entwickelt wurde, war ich von den Ergebnissen beeindruckt.

Quelle (txt-Datei):

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

Befehl:

java -jar ditaa0_9.jar ascii-graph.txt

Ergebnis:

Es unterstützt auch Hintergrundfarben, gestrichelte Linien, verschiedene Formen und mehr. Siehe die Beispiele .

Wenn sich Ihr Repository auf Gitlab befindet, können Sie die Diagrammdarstellung verwenden, da diese in Ihrem Browser als SVG gerendert wird.

• Wechseln Sie zur Diagrammansicht Ihres Repositorys, z. B. https://gitlab.com/gitlab-org/gitter/webapp/network/develop

• Scrollen Sie das Diagramm nach unten (es lädt faul Commits!)

• Verwenden Sie den Inspektor Ihres Browsers, um das SVG-Element in eine neue Datei zu kopieren

• Öffnen Sie es in einem Renderer Ihrer Wahl, z. B. Inkscape

Ich kenne kein direktes Tool, aber vielleicht können Sie ein Skript hacken, um die Daten in das Punktformat zu exportieren und mit graphviz zu rendern.

Es gibt ein funky Git-Commit-Diagramm als eine der Demos der Raphael -Webgrafikbibliothek.

Die Demo ist statisch, aber es sollte einfach genug sein, den Code zu nehmen und ihre statischen Daten gegen einen Live-Datensatz auszutauschen - ich denke, es sind nur Git-Commit-Daten im JSON-Format.

Die Demo ist hier: http://dmitrybaranovskiy.github.io/raphael/github/impact.html

Eine schöne und sauber aussehende tablettenartige Git-Grafikausgabe für Muscheln

mit Hashes wie üblich neben dem Graphbaum

oder in einer zusätzlichen Spalte

Bearbeiten : Sie möchten sofort beginnen, ohne Erklärungen zu lesen? Verwenden Sie Git-Alias-, Skript- oder Funktionscode-Snippets aus Abschnitt EDIT 5 unten.

In allen Antworten auf diese Frage zeigte bisher keine eine saubere, tablettenartig aussehende Ausgabe für Muscheln. Am nächsten kam diese Antwort aus den Evangelien, von denen ich ausgegangen bin.

Der Kernpunkt meines Ansatzes besteht darin, nur die Baumzeichen zu zählen, die dem Benutzer angezeigt werden. Füllen Sie sie dann auf eine persönliche Länge mit Leerzeichen.

Außer Git benötigen Sie diese Tools

• grep
• Einfügen
• printf
• sed
• seq
• tr
• Toilette

Meistens an Bord mit jeder Linux-Distribution.

Das Code-Snippet ist

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

Zur Berechnung der benötigten Leerzeichen verwenden wir

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

Um alle Zeichen (bis zu 500 pro Zeile) zu erhalten, wählen Sie nur die Baumzeichen aus: * | / \ _ und Leerzeichen mit

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

Zählen Sie sie schließlich und subtrahieren Sie das Ergebnis von unserem gewählten Längenwert, der im Beispiel 9 beträgt.

Um die berechnete Anzahl von Leerzeichen zu erzeugen, verwenden wir

  seq -s' ' $whitespaces

und kürzen Sie die Positionsnummern mit

  tr -d '[:digit:]'

als sie am Ende unserer Grafiklinie hinzufügen. Das ist es!

Git hat die nette Option, die Länge der Ausgabespezifizierer bereits mit der Syntax zu formatieren'%><(amount_of_characters,truncate_option)' , die Leerzeichen von links '>' oder rechts '<' hinzufügt und Zeichen von Anfang 'ltrunc', Mitte 'mtrunc' oder Ende abschneiden kann 'abschneiden'.

Es ist wichtig, dass die obigen printf-cmds die gleichen Längenwerte für die entsprechende Git-Spalte verwenden.

Viel Spaß beim Gestalten Ihrer eigenen sauberen, tablettenartig aussehenden Ausgabe nach Ihren Bedürfnissen.

Extra:

Um den richtigen Längenwert zu erhalten, können Sie das folgende Snippet verwenden

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

und verwenden Sie $ max_chars als den richtigen Längenwert oben.

BEARBEITEN 1 : Ich habe gerade bemerkt, dass das Unterstreichungszeichen auch im Git-Baum verwendet wird, und bearbeite die obigen Code-Schnipsel entsprechend. Wenn andere Zeichen fehlen, hinterlassen Sie bitte einen Kommentar.

BEARBEITEN 2 : Wenn Sie die Klammern um Verzweigungs- und Tag-Einträge entfernen möchten, verwenden Sie einfach "% D" anstelle von "% d" im Befehl git, wie in BEARBEITEN 3.

EDIT 3 : Vielleicht ist die Farboption "Auto" diejenige, die Sie für Verzweigungs- und Tag-Einträge am meisten bevorzugen?

Ändern Sie diesen Teil des Befehls git (Farbe 214 ).

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

zu auto

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

EDIT 4 : Oder Sie mögen Ihren eigenen Farbmix für diesen Teil, eine ausgefallene Ausgabe mit blinkendem Kopf?

Um den Kopf, die Verzweigungsnamen und die Tags zuerst formatieren zu können, benötigen wir die Farboption "auto" in unserem git-Befehl wie in EDIT 3.

Dann können wir die bekannten Farbwerte durch unsere eigenen ersetzen, indem wir diese 3 Zeilen hinzufügen

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

kurz vor der Linie

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

in unserem Code-Snippet. Die Ersatzwerte ergeben die obigen Farben.

Zum Beispiel ist der Wiederbeschaffungswert für Kopf

3;5;1;38;5;196

wo 3; steht für kursiv, 5; zum Blinken und 1; 38; 5; 196 für die Farbe. Weitere Infos finden Sie hier. Hinweis: Dieses Verhalten hängt von Ihrem bevorzugten Terminal ab und kann daher möglicherweise nicht verwendet werden.

ABER Sie können einen beliebigen Farbwert auswählen.

ÜBERSICHT über die Git-Farbwerte und ANSI-Äquivalente

Eine Liste mit der Option git color / style finden Sie hier .

Wenn Sie die Ausgabe auf Ihrer Konsole für genaue Farben benötigen (das obige Bild wird durch Stapelüberlauf verkleinert), können Sie die Ausgabe mit erzeugen

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

in Ihrem Git-Projektpfad, der das erste Commit aus Ihrer Git-Protokollausgabe verwendet.

EDIT 5 : Wie Mitglied "Andras Deak" erwähnt hat, gibt es einige Möglichkeiten, diesen Code zu verwenden:

1) als Alias :

Alias ​​akzeptiert keine Parameter, aber eine Funktion kann daher einfach in Ihrer .bashrc definieren

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

   }

und rufen Sie die Funktion git_tably (abgeleitet von tablelike) direkt unter Ihrem Git-Projektpfad oder von jedem beliebigen Ort aus mit Ihrem Git-Projektpfad als erstem Parameter auf.

2) als Shell-Skript :

Ich benutze es mit der Option, ein Git-Projektverzeichnis als ersten Parameter zu übergeben oder wenn es leer ist, das Arbeitsverzeichnis wie gewohnt zu nehmen. In seiner Gesamtheit haben wir

# 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) als Git-Alias :

Am bequemsten ist es vielleicht, einen Git-Alias ​​in Ihre .gitconfig einzufügen

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

Dann rufen Sie einfach git tablyunter einem beliebigen Projektpfad auf.

Git ist so mächtig, dass Sie Kopf, Tags, ... direkt wie oben gezeigt und von hier aus ändern können .

Eine weitere ausgefallene Option ist die Auswahl der Baumfarben, mit denen Sie am meisten bevorzugen

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

Das gibt dir verrückt aussehende, aber immer tablettenartige Git-Log-Ausgaben

Zu viel Blinken! Nur um zu demonstrieren, was möglich ist. Zu wenige spezifizierte Farben führen zu Farbwiederholungen.

Eine vollständige .gitconfig-Referenz ist nur einen Klick entfernt.

WIEDER: Viel Spaß beim Gestalten Ihrer eigenen, sauberen, tablettenartigen Ausgabe, die Ihren Anforderungen entspricht.

Einige Aliase in ~ / .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'

Für OSX-Benutzer habe ich das Beispiel @gospes genommen und es leicht für gsed ( gnu-sedinstalliert über Homebrew) geändert und die Farben angepasst (um mit einem schwarzen Hintergrund zu arbeiten, nicht sicher, wie das ursprüngliche Beispiel möglicherweise so rendern könnte, wie es im Beispiel, da es schwarzen Text auf einem Terminal mit schwarzem Hintergrund angibt).

[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

Der Schlüssel für OSX besteht darin, zuerst gnu sed zu installieren (mit der Option -r). Am einfachsten mit Homebrew, das das vom System installierte sed nicht überschreibt, sondern stattdessen gnu sed als "gsed" installiert. Hoffe das hilft @ SlippD.Thompson, der oben kommentiert hat, dass OSX nicht funktioniert.