Ik heb in sommige boeken en artikelen een aantal erg mooie grafieken van Git branches en commits gezien. Hoe kan ik hoogwaardige afdrukbare afbeeldingen van Git-geschiedenis maken?
Antwoord 1, autoriteit 100%
Update 2: ik heb een verbeterde versie van dit antwoord gepost op de Het visualiseren van branch-topologie in Gitvraag, omdat het daar veel geschikter is. Die versie bevatlg3, die zowel de auteur als de committer-info laat zien, dus je moet het echt eens bekijken. Ik laat dit antwoord achter om historische (en ik geef het toe) redenen, hoewel ik echt in de verleiding kom om het gewoon te verwijderen.
Mijn twee cent: ik heb twee aliassen die ik normaal gesproken in mijn ~/.gitconfig-bestand stop:
[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 lg1ziet er als volgt uit:
en git lg2zien er als volgt uit:
(Opmerking: er zijn nu veel meer toepasselijke antwoorden op deze vraag, zoals fracz’s, Jubobs’of Harry Lee’s!)
Antwoord 2, autoriteit 76%
Veel van de antwoorden hier zijn geweldig, maar voor degenen die gewoon een eenvoudig één-regel-tot-de-punt antwoord willen zonder aliassen of iets extra’s in te stellen, hier is het:
git log --all --decorate --oneline --graph
Niet iedereen zou de hele tijd een git logdoen, maar als je het nodig hebt, onthoud dan:
“Een hond” = git log —all —decorate —oneline —graph
Antwoord 3, autoriteit 20%
Voor tekstuele uitvoer kunt u het volgende proberen:
git log --graph --abbrev-commit --decorate --date=relative --all
Of:
git log --graph --oneline --decorate --all
Of: hier iseen Graphvizalias voor het tekenen van de DAGgrafiek.
Ik gebruik persoonlijk gitx, gitk --allen gitnub.
Antwoord 4, autoriteit 14%
Gitgraph.jsmaakt het mogelijk om mooie Git-takken te tekenen zonder een repository. Schrijf gewoon een JavaScript-code die je branches en commits configureert en render deze in de 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);
Of met metrosjabloon:
Of met commit-berichten, auteurs en tags:
Test het met JSFiddle.
Genereer het met Git Graphervan @bsara.
Antwoord 5, autoriteit 7%
Gebouwd bovenop TikZ & PGF, gitdagsis een klein LaTeX-pakket waarmee je maak moeiteloos vectorafbeeldingen, commit-grafieken en meer.
Automatisch genereren van de commit-grafiek van een bestaande repository is niethet doel van gitdags; de grafieken die het produceert zijn alleen bedoeld voor educatieve doeleinden.
Ik gebruik het vaak om grafieken te maken voor mijn antwoorden op Git-vragen, als alternatief voor ASCII-commit-grafieken:
- Hoe kan ik een bugfix op master doen en deze integreren in mijn minder stabiele branch(s)?
- Hoe werkt git commit –amend precies?
- Waarom zegt Git me “Momenteel niet in een branch” nadat ik “git checkout origin/<branch>” heb uitgevoerd?
- Wat is het verschil tussen het samenvoegen van master in branch en het samenvoegen van branch in master?
- Git-rebase –preserve-merges mislukt
Hier is een voorbeeld van zo’n grafiek die de effecten van een eenvoudige rebase laat zien:
\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}
Antwoord 6, autoriteit 4%
Gitgis een kloon van Gitk en GitX voor GNOME (het werkt ook op KDE enz. .) die een mooie gekleurde grafiek toont.
Het wordt actief ontwikkeld (vanaf 2012). Het laat je de commits (grafiekknooppunten) chronologisch of topologischsorteren en commits verbergen die niet’ leidt niet naar een geselecteerde vestiging.
Het werkt prima met grote opslagplaatsen en complexe afhankelijkheidsgrafieken.
Voorbeelden van schermafbeeldingen die de linux-git en linux-2.6 repositories tonen:
Antwoord 7, autoriteit 3%
Ik heb zojuist een tool geschreven die een mooie Git-commits-grafiek kan genereren met behulp van HTML/Canvas.
En zorg voor een jQuery-plug-in die het gebruik gemakkelijk maakt.
[GitHub] https://github.com/tclh123/commits-graph
Voorbeeld:
Antwoord 8, autoriteit 3%
Sourcetreeis echt een goede. Het drukt een goed uitziende en middelgrote geschiedenis en branch-grafiek af: (het volgende is gedaan op een experimenteel Git-project om alleen enkele branches te zien). Ondersteunt Windows 7+ en Mac OS X 10.6+.
Antwoord 9, autoriteit 3%
git-forestis een uitstekend Perl-script dat ik al meer dan een jaar gebruik en ik gebruik de opdracht git lognauwelijks meer rechtstreeks.
Dit zijn enkele van de dingen die ik leuk vind aan dit script:
- Het gebruikt Unicode-tekens om de lijnen in de grafiek te tekenen, waardoor de grafieklijnen een meer doorlopende uitstraling krijgen.
- Je kunt
--reversecombineren met de grafische uitvoer, wat niet mogelijk is met het regulieregit logcommando. - Het gebruikt
git logintern om de lijst met commits te pakken, dus alle opties die je doorgeeft aangit logkunnen ook aan dit script worden doorgegeven.
li>
Ik heb een alias die git-forestals volgt gebruikt:
[alias]
tree = "forest --pretty=format:\"%C(red)%h %C(magenta)(%ar) %C(blue)%an %C(reset)%s\" --style=15 --reverse"
Zo ziet de uitvoer eruit op een terminal:
Antwoord 10, autoriteit 3%
Ik heb een webtool geschreven om Git-logboeken om te zetten in mooie SVG-grafieken:
Bit-Booster – Grafiektekenprogramma offline vastleggen
Upload uitvoer van git log --pretty='%h|%p|%d'rechtstreeks naar de tool en klik vervolgens op de link “download graph.svg”.
De tool is puur client-side, en dus wordt geen van je Git-gegevens gedeeld met mijn server. U kunt de HTML + JavaScript ook lokaal opslaan en uitvoeren met behulp van “file:///” URL’s. Het is geverifieerd in Chrome 48 en Firefox 43 op Ubuntu 12.04(Precieze Pangolin).
Het genereert HTML die direct op elke pagina kan worden geplaatst (inclusief de blog-engine van blogspot!). Bekijk hier enkele van de blogberichten:
http://bit-booster.blogspot.ca/
Hier is een screenshot van een voorbeeld van een HTML-bestand dat door de tool is gegenereerd:
http://bit-booster.com/graph.html(de tool)
Antwoord 11, autoriteit 2%
Op basis van een Graphviz-script dat ik vond in een antwoord op een gerelateerde vraag, heb ik een Ruby-scriptdat een overzichtsweergave van een Git-repository maakt. Het verwijdert alle lineaire geschiedenis en toont alleen “interessante” commits, d.w.z. die met meerdere ouders, meerdere kinderen, of waarnaar wordt verwezen door een branch of tag. Hier is een fragment van de grafiek die het genereert voor jQuery:
git-big-pictureen BranchMasterzijn vergelijkbare tools die proberen alleen de structuur op hoog niveau van een grafiek weer te geven, door alleen weer te geven hoe tags, branches, merges, enz. zijn gerelateerd.
Deze vraagheeft wat meer opties.
Antwoord 12, autoriteit 2%
Ik heb drie aangepaste commando’s toegevoegd: git stree, git streeen git vtree. Ik zal ze in die volgorde doornemen.
[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)'
Met git streeen git vtreeheb ik Bash gebruikt om te helpen bij het formatteren.
[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);"'
Dit werkt met Git versie 1.9a. De kleurwaarde ‘auto’ maakt blijkbaar zijn debuut in deze release. Het is een leuke toevoeging omdat de filiaalnamen een andere kleur krijgen. Dit maakt het gemakkelijker om onderscheid te maken tussen bijvoorbeeld lokale en externe vestigingen.
Antwoord 13, autoriteit 2%
Het hangt ervan af hoe ze eruit zagen. Ik gebruik gitxdie afbeeldingen als deze maakt:
Je kunt git log --graphvergelijken met gitkop een 24-weg octopus-samenvoeging (oorspronkelijk van http://clojure -log.n01se.net/date/2008-12-24.html):
Antwoord 14, autoriteit 2%
Probeer voor meer gedetailleerde tekstuele uitvoer:
git log --graph --date-order -C -M --pretty=format:"<%h> %ad [%an] %Cgreen%d%Creset %s" --all --date=short
Je kunt een alias toevoegen in bestand $HOME/.gitconfig:
[alias]
graph = log --graph --date-order -C -M --pretty=format:\"<%h> %ad [%an] %Cgreen%d%Creset %s\" --all --date=short
Antwoord 15, autoriteit 2%
Een mooie en overzichtelijke tabelachtige Git-grafiekuitvoer voor shells
Met hashes zoals gewoonlijk naast de grafiekboom
Of in een extra kolom
EDIT: Wil je meteen beginnen zonder alle uitleg te lezen? Ga naar BEWERK 6.
INFO: voor een meer branch-achtige gekleurde versie voor shells, zie ook mijn tweede antwoord (https: //stackoverflow.com/a/63253135/).
In alle antwoorden op deze vraag toonde geen enkele tot nu toe een schone tabel-achtige uitvoer voor shells.
De dichtstbijzijnde was dit antwoord van gospeswaar ik mee begon.
Het kernpunt in mijn benadering is om alleen de boomkarakters te tellen die aan de gebruiker worden getoond. Vul ze vervolgens tot een persoonlijke lengte met spaties.
Anders dan Git heb je deze tools nodig
- grep
- plakken
- printf
- sed
- vervolg
- tr
- wc
Meestal aan boord met elke Linux-distributie.
Het codefragment is
while IFS=+ read -r graph hash time branch message;do
# Count needed amount of white spaces 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 table-like output
paste -d' ' <(echo -e "$time_all") <(echo -e "$branch_all") <(echo -e "$graph_all") <(echo -e "$hash_all") <(echo -e "$message_all")
Om de benodigde spaties te berekenen die we gebruiken
sed -nl1000 'l' <<< "$graph"
om alle karakters te krijgen (tot 1000 per regel) selecteer dan alleen de boomkarakters: * | / \ _ en spaties met
grep -Eo '\\\\|\||\/|\ |\*|_'
Tel ze ten slotte en trek het resultaat af van de door ons gekozen lengtewaarde, die in het voorbeeld 9 is.
Om de berekende hoeveelheid spaties te produceren die we gebruiken
seq -s' ' $whitespaces
en kap de positienummers af met
tr -d '[:digit:]'
Voeg ze vervolgens toe aan het einde van onze grafieklijn. Dat is het!
Git heeft de leuke optie om de lengte van de uitvoerspecificatiesal te formatteren met de syntaxis '%><(amount_of_characters,truncate_option)',
die spaties van links toevoegt ‘>’ of rechts ‘<‘ kant en kan karakters afkappen vanaf het begin ‘ltrunc’, middelste ‘mtrunc’ of einde ‘trunc’.
Het is belangrijkdat de bovenstaande printf-cmd’s dezelfde lengtewaarden gebruiken voor de corresponderende Git-kolom.
Veel plezier met het stylen van je eigen strakke, tafelachtige output naar jouw wensen.
Extra:
Om de juiste lengtewaarde te krijgen, kunt u het volgende fragment gebruiken
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:' ')
en gebruik $max_chars als de juiste lengtewaarde hierboven.
BEWERK 1:
Merk net op dat het onderstreepte teken ook wordt gebruikt in de git-boom en bewerk de codefragmenten hierboven dienovereenkomstig. Als er andere tekens ontbreken, laat dan een reactie achter.
BEWERK 2:
Als je de haakjes rond branch- en tag-items wilt verwijderen, gebruik dan gewoon “%D” in plaats van “%d” in het git-commando, zoals in EDIT 3.
BEWERK 3:
Misschien is de kleuroptie “auto” degene die u het meest verkiest voor vertakkingen en tag-items?
Wijzig dit deel van het git-commando (kleur 214)
%C(214)%>(15,trunc)%D%C(reset)
naar automatisch
%C(auto)%>(15,trunc)%D%C(reset)
EDIT 4: Of hou je van je eigen kleurenmix voor dat deel, een mooie output met knipperende kop?
Om eerst de head, branch-namen en tags te kunnen stylen, hebben we de “auto” kleuroptie nodig in ons git-commando zoals in EDIT 3.
Dan kunnen we de bekende kleurwaarden vervangen door onze eigen kleurwaarden door deze 3 regels toe te voegen
# 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}
net voor de regel
branch_all="$branch_all$(printf '%15s' "$branch")\n"
in ons codefragment. De vervangingswaarden produceren de bovenstaande kleuren.
De vervangingswaarde voor kop is bijvoorbeeld
3;5;1;38;5;196
waar 3; staat voor cursief, 5; voor knipperen en 1;38;5;196 voor de kleur. Begin hier voor meer informatie.Opmerking: dit gedrag is afhankelijk van uw favoriete terminal en is daarom mogelijk niet bruikbaar.
MAARje kunt elke gewenste kleurwaarde kiezen.
OVERZICHT van de git-kleurwaarden en ANSI-equivalenten
Je vindt hier een lijst met git color/style optie.
Als u de uitvoer op uw console nodig heeft voor nauwkeurige kleuren (de afbeelding hierboven is verkleind door Stack Overflow), kunt u de uitvoer produceren met
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 je Git-projectpad dat de eerste commit van je Git-logboekuitvoer gebruikt.
BEWERK 5:
Zoals lid “Andras Deak” al zei, zijn er enkele manieren om deze code te gebruiken:
1) als alias:
alias accepteert geen parameters, maar een functie wel, definieer daarom gewoon in uw .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" ###
}
en roep de functie git_tably (afgeleid van table-like) direct onder je git-projectpad aan of waar je maar wilt met je git-projectpad als eerste parameter.
2) als shell-script:
Ik gebruik het met de optie om een Git-projectdirectory als eerste parameter eraan door te geven of, indien leeg, de werkdirectory te nemen zoals normaal. In zijn geheel hebben we
# 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 preferred table-like git graph output
while IFS=+ read -r graph hash time branch message;do
# Count needed amount of white spaces 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 table-like 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 een git-alias:
Misschien is de meest comfortabele manier om een git-alias toe te voegen aan je .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\"); \
'"
Noem dan gewoon git tablyaan onder een willekeurig projectpad.
Git is zo krachtig dat je head, tags, … direct kunt wijzigen, zoals hierboven getoond en van hier overgenomen.
Een andere mooie optieis om de boomkleuren te selecteren die u het meest verkiest
[log]
graphColors = bold 160, blink 231 bold 239, bold 166, bold black 214, bold green, bold 24, cyan
dat geeft je gek uitziende maar altijd tabel-achtige git log-outputs
Te veel knipperen! Gewoon om te laten zien wat er allemaal mogelijk is. Te weinig gespecificeerde kleuren leiden tot kleurherhalingen.
Een complete .gitconfig-referentie is slechts één klik verwijderd.
BEWERK 6:
Vanwege jullie positieve stemmen heb ik het fragment verbeterd.
Nu kun je het voeden met bijna elk git log-commando en hoef je de code niet meer aan te passen. Probeer het!
Hoe werkt het?
- definieer je Git log-commando’s in je .gitconfig zoals altijd (opgemaakt zoals hieronder)
- definieer een positief boomkolomnummer, waar de git-grafiek wordt getoond (optioneel)
Bel dan gewoon
git tably YourLogAlias
onder een willekeurig git-projectpad of
git tably YourLogAlias TreeColNumber
waarbij TreeColNumber een altijd gedefinieerde waarde van boven overschrijft.
git tably YourLogAlias | less -r
zal de uitvoer naar minder sturen, wat handig is voor grote geschiedenissen.
Uw Git-logalias moet aan deze indelingsregels voldoen:
-
elke kolom moet worden aangegeven met een kolomscheidingsteken dat u moet kiezen en dit kan problemen veroorzaken, zo niet uniek
d.w.z.
^in...format:'^%h^%cr^%s'resulteert in een boomstructuur, een hash, een tijd en een vastleggingskolom -
voor elke tijdelijke aanduiding voor een commit in je log-opdracht die je moet gebruiken
%><(<N>[,ltrunc|mtrunc|trunc]), met een van de trunc-opties(zie voor uitleg over de syntaxis https://git -scm.com/docs/pretty-formats),
maar de laatste plaatsaanduiding voor een nieuwe regel kan ook zonder deze worden gebruikt
d.w.z.
...format:'^%<(7,trunc)%h^%<(12,trunc)%cr^%s' -
als er extra tekens nodig zijn voor decoratie zoals
(committer:,<en>)in...%C(dim white)(committer: %cn% <%ce>)%C(reset)...om een tabelachtige uitvoer te krijgen, moeten ze direct voor en na de tijdelijke aanduiding voor de commit worden geschreven
d.w.z.
...%C(dim white)%<(25,trunc)(committer: %cn%<(25,trunc) <%ce>)%C(reset)... -
het gebruik van kolomkleuren zoals
%C(white)...%C(rest)heeft de optie--colornodig voor een gekleurde uitvoerd.w.z.
...--color...format:'^%C(white)%<(7,trunc)%h%C(rest)... -
als je de optie
--statof iets dergelijks gebruikt, voeg dan een nieuwe regel%ntoe aan het einded.w.z.
...--stat...format:'...%n'... -
je kunt de git-grafiek bij elke kolom plaatsen zolang je geen nieuwe regel of alleen lege regels gebruikt
format:'...%n'voor niet-lege nieuwe regels
...%n%CommitPlaceholder...kunt u de git-grafiek alleen op elke kolom n+1 plaatsen als alle n-de kolommen van elke regel bestaan en gebruiken dezelfde breedte -
de naam van uw gedefinieerde boomkolomnummer voor een specifieke logalias moet
YourLogAlias-colzijn
Vergeleken met de normale uitvoer van git logs is deze traag maar fijn.
Nu het verbeterde fragment om toe te voegen aan je .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 '" \
\
\
declare -A col_length; \
apost=$(echo -e \"\\u0027\"); \
delim=$(git config alias.delim); \
git_log_cmd=$(git config alias.$1); \
git_tre_col=${2:-$(git config alias.$1-col)}; \
[[ -z "$git_tre_col" ]] && git_tre_col=1; \
[[ -z "$git_log_cmd" ]] && { git $1;exit; }; \
\
\
i=0; \
n=0; \
while IFS= read -r line;do \
((n++)); \
while read -d\"$delim\" -r col_info;do \
((i++)); \
[[ -z \"$col_info\" ]] && col_length[\"$n:$i\"]=${col_length[\"${last[$i]:-1}:$i\"]} && ((i--)) && continue; \
[[ $i -gt ${i_max:-0} ]] && i_max=$i; \
col_length[\"$n:$i\"]=$(grep -Eo \"\\([0-9]*,[lm]*trunc\\)\" <<< \"$col_info\" | grep -Eo \"[0-9]*\" | head -n 1); \
[[ -n \"${col_length[\"$n:$i\"]}\" ]] && last[$i]=$n; \
chars_extra=$(grep -Eo \"trunc\\).*\" <<< \"$col_info\"); \
chars_extra=${chars_extra#trunc)}; \
chars_begin=${chars_extra%%\\%*}; \
chars_extra=${chars_extra%$apost*}; \
chars_extra=${chars_extra#*\\%}; \
case \" ad aD ae aE ai aI al aL an aN ar as at b B cd cD ce cE ci cI cl cL cn cN cr \
cs ct d D e f G? gd gD ge gE GF GG GK gn gN GP gs GS GT h H N p P s S t T \" in \
*\" ${chars_extra:0:2} \"*) \
chars_extra=${chars_extra:2}; \
chars_after=${chars_extra%%\\%*}; \
;; \
*\" ${chars_extra:0:1} \"*) \
chars_extra=${chars_extra:1}; \
chars_after=${chars_extra%%\\%*}; \
;; \
*) \
echo \"No Placeholder found. Probably no tablelike output.\"; \
continue; \
;; \
esac; \
if [[ -n \"$chars_begin$chars_after\" ]];then \
len_extra=$(echo \"$chars_begin$chars_after\" | wc -m); \
col_length["$n:$i"]=$((${col_length["$n:$i"]}+$len_extra-1)); \
fi; \
done <<< \"${line#*=format:}$delim\"; \
i=1; \
done <<< \"$(echo -e \"${git_log_cmd//\\%n/\\\\n}\")\"; \
\
\
git_log_fst_part=\"${git_log_cmd%%\"$apost\"*}\"; \
git_log_lst_part=\"${git_log_cmd##*\"$apost\"}\"; \
git_log_tre_part=\"${git_log_cmd%%\"$delim\"*}\"; \
git_log_tre_part=\"${git_log_tre_part##*\"$apost\"}\"; \
git_log_cmd_count=\"$git_log_fst_part$apost $git_log_tre_part$apost$git_log_lst_part\"; \
col_length[\"1:1\"]=$(eval git \"${git_log_cmd_count// --color}\" | wc -L); \
\
\
i=0; \
while IFS=\"$delim\" read -r graph rest;do \
((i++)); \
graph_line[$i]=\"$graph\"; \
done < <(eval git \"${git_log_cmd/ --color}\" && echo); \
\
\
i=0; \
l=0; \
while IFS= read -r line;do \
c=0; \
((i++)); \
((l++)); \
[[ $l -gt $n ]] && l=1; \
while IFS= read -d\"$delim\" -r col_content;do \
((c++)); \
[[ $c -le $git_tre_col ]] && c_corr=-1 || c_corr=0; \
if [[ $c -eq 1 ]];then \
[[ \"${col_content/\\*}\" = \"$col_content\" ]] && [[ $l -eq 1 ]] && l=$n; \
count=$(wc -L <<< \"${graph_line[$i]}\"); \
whitespaces=$(seq -s\" \" $((${col_length[\"1:1\"]}-$count))|tr -d \"[:digit:]\"); \
col_content[$git_tre_col]=\"${col_content}$whitespaces\"; \
else \
col_content[$c+$c_corr]=\"$(printf \"%-${col_length[\"$l:$c\"]}s\" \"${col_content:-\"\"}\")\"; \
fi; \
done <<< \"$line$delim\"; \
for ((k=$c+1;k<=$i_max;k++));do \
[[ $k -le $git_tre_col ]] && c_corr=-1 || c_corr=0; \
col_content[$k+$c_corr]=\"$(printf \"%-${col_length[\"$l:$k\"]:-${col_length[\"${last[$k]:-1}:$k\"]:-0}}s\" \"\")\"; \
done; \
unset col_content[0]; \
echo -e \"${col_content[*]}\"; \
unset col_content[*]; \
done < <(eval git \"$git_log_cmd\" && echo); \
"' "git-tably"
waar in tably
- de eerste alinea laadt de delim(iter), YourLogAlias en YourLogAlias-col in shell-variabelen
- de tweede leest de lengte voor elke kolom
- de derde telt de max. lengte van de boom
- de vierde laadt de boom in een array
- de vijfde organiseert en print de tabelachtige uitvoer
Resultaten:
of met het nieuwe TreeColNumber on-the-fly
OPNIEUW: veel plezier met het stylen van uw eigen, schone tafelachtige uitvoer naar uw behoeften.
Je kunt ook je favoriete geformatteerde Git-logalias delen in de opmerkingen. Van tijd tot tijd zal ik de meest gewaardeerde in de bovenstaande tekst opnemen en ook afbeeldingen toevoegen.
Antwoord 16, autoriteit 2%
Dit is mijn mening over deze kwestie:
Schermafbeelding:
Gebruik:
git hist– Toon de geschiedenis van de huidige tak
git hist --all– Toon de grafiek van alle takken (inclusief afstandsbedieningen)
git hist master devel– Toon de relatie tussen twee of meer branches
git hist --branches– Toon alle lokale vestigingen
Voeg --topo-ordertoe om commits topologisch te sorteren, in plaats van op datum (standaard in deze alias)
Voordelen:
- Ziet eruit als gewoon
--decorate, dus met aparte kleuren voor verschillende taknamen - Voegt committer-e-mailadres toe
- Voegt relatieve en absolute datum toe
- Sorteer toezeggingen op datum
Instellen:
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)'"
Antwoord 17
gitg: een op gtk gebaseerde repository-viewer. Dat is nieuw, maar interessant en nuttig.
Ik gebruik het momenteel.
Antwoord 18
Hoewel ik soms gitg, ik kom altijd terug op de opdrachtregel:
[alias]
# Quick look at all repositories
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 the 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 the 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 repositories without subject body commits (Vim repository, 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
Zoals je kunt zien, is het bijna een toetsaanslag die aliassen bespaart, gebaseerd op:
- –kleur: heldere look
- –graph: visualiseer ouders
- –date-order: meest begrijpelijke kijk op repo
- –decorate: wie is wie
- –oneline: Vaak alles wat je moet weten over een commit
- –simplify-by-decoration: basis voor een eerste blik (alleen tags, relevante samenvoegingen, branches)
- –all: toetsaanslagen opslaan met alle aliassen met en zonder deze optie
- –date=relative (%ar): Begrijp activiteit in repo (soms heeft een branch weinig commits in de buurt van master, maar maanden geleden van hem)
Zie in de recente versie van Git (1.8.5 en hoger) dat je kunt profiteren van %C(auto) in decor placeholder %d.
Vanaf hier is alles wat je nodig hebt een goed begrip van gitrevisions om te filteren wat je nodig hebt (zoiets als master..develop, waar --simplify-mergeszou kunnen helpen met vertakkingen op lange termijn).
De kracht achter de opdrachtregel is de snelle configuratie op basis van uw behoeften (begrijp dat een repository geen unieke sleutellogboekconfiguratie is, dus het toevoegen van –numstat, of –raw of –name-status is soms nodig. Hier zijn git logen aliassen snel, krachtig en (met de tijd) de mooiste grafiek die je kunt bereiken. Sterker nog, met output die standaard wordt weergegeven via een pager (zeg minder) kun je altijd snel in de resultaten zoeken . Niet overtuigd? Je kunt het resultaat altijd ontleden met projecten zoals gitgraph.
Antwoord 19
Ik stel voor tighttps://github.com/jonas/tig, een veel veel betere opdrachtregeltool voor Git.
Je kunt Homebrew gebruiken om tig op macOS te installeren:
$ brew install tig
$ tig
Antwoord 20
Zeer kleine aanpassingen Slipp’s geweldige antwoord, je kunt zijn aliassen gebruiken om er maar één te loggen filiaal:
[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"
Door de --allweg te laten die je nu kunt doen
git lgBranch1 <branch name>
of zelfs
git lgBranch1 --all
Antwoord 21
Ik heb deze git logalias in ~/.gitconfigom de grafiekgeschiedenis te bekijken:
[alias]
l = log --all --graph --pretty=format:'%C(auto)%h%C(auto)%d %s %C(dim white)(%aN, %ar)'
Als dit op zijn plaats is, zal git lzoiets als uitvoeren:
In Git 2.12+ kun je pas zelfs de lijnkleuren van de grafiek aan met behulp van de log.graphColorsconfiguratieoptie.
Het formaat van de logs is vergelijkbaar met --oneline, met de toevoeging van de naam van de auteur(met respect voor .mailmap) en de relatieve auteurdatum. Merk op dat de syntaxis %C(auto), die Git vertelt om de standaardkleuren te gebruiken voor commit-hash, enz., wordt ondersteund in Git >= 1.8.3.
Antwoord 22
git -c core.pager='less -SRF' log --oneline --graph --decorate
Dit is mijn terminalvariant, vergelijkbaar met veel antwoorden hier. Ik pas graag de vlaggen aan die worden doorgegeven aan lessom tekstterugloop te voorkomen.
Ik heb dit ingesteld op een alias voor snelle toegang, omdat de opdracht een beetje omslachtig is.
Antwoord 23
Probeer gitkof gitk --all. Het heeft echter geen functie afdrukken/opslaan img.
Antwoord 24
Het genereert een PNG- of SVG-weergave van de commit-geschiedenis van je Git-repository.
Antwoord 25
Visual Studio Code heeft een geweldige extensie, Git Graph:
Antwoord 26
Een meer takachtige gekleurde versie voor schelpen.
Sommige andere antwoorden laten grafiekbomen zien die mooi gekleurd zijn door externe tools, deels met gekleurde lijninformatie.
Dit is mijn benadering voor shells, wat een combinatie is met mijn eerste antwoord hier voor een tabelachtige uitvoer (https://stackoverflow.com/a /61487052).
Kenmerken:
- U kunt alle boomkleuren definiëren
- Je kunt elke kolom verven in de bijbehorende takkleur
- U kunt de boomkolom op verschillende posities plaatsen
- Je kunt verschillende
git logaliassen gebruiken - U kunt voor elke alias een boomkolomnummer definiëren
- Je kunt het in
less -rpipen voor enorme geschiedenissen
Hoe u het gebruikt:
Definieer je git logalias zoals in verschillende getoonde antwoorden, bijv. van Slipp D., albfan, kaoru, met de onderstaande opmaakinstructies en plak deze samen met het codefragment in uw .gitconfig-bestand.
Roep het vanuit uw projectpad aan, zoals gewoonlijk met
git colored YourLogAliasof met
git colored YourLogAlias TreeColumnNumberom de boomkolom in een oogwenk te plaatsen.
Opmaakinstructies:
Je git logalias moet deze formaatregels volgen:
- gebruik een uniek teken als kolomscheidingsteken voor elke tijdelijke aanduiding voor een vastlegging, d.w.z.
^
...format:'%h%cr%s'–>...format:'^%h^%cr^%s' - kleur een hele kolom in één kleur of laat deze leeg om de betreffende vertakkingskleur aan te nemen
...format:'^%h^%cr^%s'–>...format:'^%h^%cr^%C(white)%s%C(reset)'(hashes en tijd in vertakkingskleur) - je moet de breedte van elke kolom specificeren met
%><(<N>[,ltrunc|mtrunc|trunc])met een van de trunc-opties, maar elke laatste commit tijdelijke aanduiding op een regel kan zonder worden gebruikt
...format:'^%h^%cr^%C(white)%s%C(reset)'–>...format:'^%<(7,trunc)%h^%<(12,trunc)%cr^%C(white)%<(50,trunc)%s%C(reset)' - als je extra decoratietekens nodig hebt, plaats ze dan direct rond de tijdelijke aanduiding voor de commit, d.w.z.
Commit:
...^%C(white)%<(50,trunc)%s%C(reset)...–>...^%C(white)%<(50,trunc)Commit:%s%C(reset)... - als u nieuwe regels
%ngebruikt, plaatst u deze voor een kolomscheidingsteken of aan het einde
...^%C(white)%<(50,trunc)Commit:%s%C(reset)'–>...%n^%C(white)%<(50,trunc)Commit:%s%C(reset)%n' - als u kolomkleuren zoals
%C(white)hierboven gebruikt, moet u de optie--colortoevoegen
...format:'^%<(7,trunc)%h...–>...--color...format:'^%<(7,trunc)%h... - als je de optie
--statof iets dergelijks gebruikt, voeg dan een nieuwe regel%ntoe aan het einde
...--stat...format:'...'–>...--stat...format:'...%n'
Diversen:
-
voor je
git logaliassen met niet-lege nieuwe regels...%n%CommitPlaceholder...,
je kunt de Git-grafiek alleen op elke kolom n+1 plaatsen als alle n-de kolommen van elke regel bestaan en dezelfde breedte gebruiken -
YourLogAlias-colmoet de naam zijn als je een TreeColumnNumber definieert in bestand .gitconfigvoorYourLogAlias -
vergeleken met de normale
git log-uitvoer, is deze traag, maar leuk
Voorbeelden:
git colored lgc1
git colored lgc2
git colored lgc3
git colored lgc4
Codefragment:
Voeg de volgende regels toe aan je .gitconfigbestand
[alias]
# Define your unique column separator
delim = ^
# Define your 'git log' aliases and optional tree column numbers
lgc1 = log --all --graph --color --pretty=format:'^%<(7,trunc)%h^%C(white)%<(15,trunc)- %ar -%C(reset)^%<(35,trunc)%s^%C(white)%an%C(reset)'
lgc2 = log --all --graph --color --pretty=format:'%D^%<(7,trunc)%h^%<(35,trunc)%s^%C(white)%<(20,trunc)%an%C(reset)^%C(white) (%ar)%C(reset)'
lgc2-col = 2
lgc3 = log --all --graph --color --pretty=format:'%<(7,trunc)%h%d^%<(11,trunc)%cs%C(reset)^%s%n^%C(white)%<(11,trunc)%cr%C(reset)^%C(white)%<(25,trunc)From %an%C(reset)^%C(white)%ae%C(reset)%n'
lgc3-col = 2
lgc4 = log --all --graph --color --pretty=format:'%h^%C(white)%<(25,trunc)%an%C(reset)^%C(white)%<(31,trunc)%aD%C(reset)^%s%n^%C(dim white)%<(25,trunc)%ae%C(reset)^%>(31,trunc)%D%C(reset)%n'
lgc4-col = 3
# Define your whitespace seperated tree color list
color-list = "1;38;5;222 1;38;5;69 1;38;5;250 1;38;5;70 1;31 1;38;5;93 1;33 2;38;5;11 1;38;5;48 1;35 1;32 1;38;5;111 1;38;5;160 1;38;5;130 1;36 38;5;21"
Voeg het Bash-fragment ook toe aan uw .gitconfig-bestand
# This is the Bash snippet which does all the magic
colored = !bash -c '" \
\
\
declare -A col_length col_colored; \
apost=$(echo -e \"\\u0027\"); \
delim=$(git config alias.delim); \
git_log_cmd=$(git config alias.$1); \
graph_col=${2:-$(git config alias.$1-col)}; \
color_list=( $(git config alias.color-list) ); \
[[ -z \"$graph_col\" ]] && graph_col=1; \
[[ -z \"$git_log_cmd\" ]] && { git $1;exit; }; \
\
\
i=0; \
n=0; \
while IFS= read -r line; do \
((n++)); \
while read -d\"$delim\" -r col_info;do \
((i++)); \
[[ -z \"$col_info\" ]] && col_length[\"$n:$i\"]=${col_length[\"${last[$i]:-1}:$i\"]} && ((i--)) && continue; \
[[ $i -gt ${i_max:-0} ]] && i_max=$i; \
[[ \"${col_info:1:1}\" = \"C\" ]] && col_colored[\"$n:$i\"]=1; \
col_length[\"$n:$i\"]=$(grep -Eo \"\\([0-9]*,[lm]*trunc\\)\" <<< \"$col_info\" | grep -Eo \"[0-9]*\" | head -n 1); \
[[ -n \"${col_length[\"$n:$i\"]}\" ]] && last[$i]=$n; \
chars_extra=$(grep -Eo \"\\trunc\\).*\" <<< \"$col_info\"); \
chars_extra=${chars_extra#trunc)}; \
chars_begin=${chars_extra%%\\%*}; \
chars_extra=${chars_extra%$apost*}; \
chars_extra=${chars_extra#*\\%}; \
case \" ad aD ae aE ai aI al aL an aN ar as at b B cd cD ce cE ci cI cl cL cn cN cr \
cs ct d D e f G? gd gD ge gE GF GG GK gn gN GP gs GS GT h H N p P s S t T \" in \
*\" ${chars_extra:0:2} \"*) \
chars_extra=${chars_extra:2}; \
chars_after=${chars_extra%%\\%*}; \
;; \
*\" ${chars_extra:0:1} \"*) \
chars_extra=${chars_extra:1}; \
chars_after=${chars_extra%%\\%*}; \
;; \
*) \
echo \"No Placeholder found. Probably no table-like output.\"; \
continue; \
;; \
esac; \
if [[ -n \"$chars_begin$chars_after\" ]];then \
len_extra=$(echo \"$chars_begin$chars_after\" | wc -m); \
col_length[\"$n:$i\"]=$((${col_length[\"$n:$i\"]}+$len_extra-1)); \
fi; \
done <<< \"${line#*=format:}$delim\"; \
i=1; \
done <<< \"$(echo -e \"${git_log_cmd//\\%n/\\\\n}\")\"; \
\
\
git_log_fst_part=\"${git_log_cmd%%\"$apost\"*}\"; \
git_log_lst_part=\"${git_log_cmd##*\"$apost\"}\"; \
git_log_tre_part=\"${git_log_cmd%%\"$delim\"*}\"; \
git_log_tre_part=\"${git_log_tre_part##*\"$apost\"}\"; \
git_log_cmd_count=\"$git_log_fst_part$apost $git_log_tre_part$apost$git_log_lst_part\"; \
col_length[\"1:1\"]=$(eval git \"${git_log_cmd_count// --color}\" | wc -L); \
\
\
i=0; \
while IFS=\"$delim\" read -r graph rest;do \
((i++)); \
graph_line[$i]=\"$graph\"; \
done < <(eval git \"${git_log_cmd/ --color}\" && echo); \
\
\
i=0; \
l=0; \
msg_err=; \
color_list_ind=-1; \
color_list_num=${#color_list[*]}; \
color_repeat_ind=1; \
if [[ $color_list_num -eq 0 ]];then \
echo \"No tree colors specified via color-list under section [alias] in your .gitconfig\"; \
echo \"Therefore collecting available Git colors, which may take a while ...\"; \
while read -d\"[\" -r char;do \
color=$(sed -nl99 \"l\" <<< \"$char\"); \
case \"$color\" in \
*\"m\"*) \
color=${color%%m*}; \
;; \
*) \
continue; \
;; \
esac; \
case \" $color_list \" in \
*\" $color \"*) \
continue; \
;; \
*) \
color_list=\"$color_list$color \"; \
;; \
esac; \
done <<< \"$(git log --all --color --graph --pretty=format:)\"; \
echo -e \"Temporary used color-list = \\\"${color_list% }\\\"\\n\"; \
color_list=( ${color_list% } ); \
color_list_num=${#color_list[*]}; \
fi; \
while IFS= read -r line;do \
((i++)); \
j=-1; \
case_off=; \
graph_colored=; \
graph_line_last=\"${graph_line[$i-1]}\"; \
graph_line=\"${graph_line[$i]}\"; \
graph_line_next=\"${graph_line[$i+1]}\"; \
while IFS= read -r char;do \
((j++)); \
case \"$case_off$char\" in \
[^\\ \\_\\*\\/\\|\\\\]|\"case_off\"*) \
graph_colored=\"${graph_colored}\\033[${point_color}m$char\\033[0m\"; \
case_off=\"case_off\"; \
;; \
\" \") \
graph_colored=\"${graph_colored}$char\"; \
case \"$char_last\" in \
\" \") \
unset color_ind[$j]; \
;; \
esac; \
;; \
\"*\") \
case \"${graph_line_last:$j:1}\" in \
\"*\") \
:; \
;; \
\"|\") \
case \"${graph_line_last:$(($j-1)):1}\" in \
\"\\\\\") \
color_ind[$j]=${color_ind_last[$j-1]:-${color_ind[$j-1]}}; \
;; \
*) \
:; \
;; \
esac; \
;; \
\" \") \
case \"${graph_line_last:$(($j-1)):1}\" in \
\"\\\\\") \
color_ind[$j]=${color_ind_last[$j-1]:-${color_ind[$j-1]}}; \
;; \
\"/\") \
case \"${graph_line_last:$(($j+1)):1}\" in \
\"/\") \
color_ind[$j]=${color_ind[$j+1]}; \
;; \
\" \") \
new_col_ind=${#color[*]}; \
while true;do \
((color_list_ind++)); \
[[ $color_list_ind -ge $color_list_num ]] && color_list_ind=$color_repeat_ind; \
[[ $color_list_ind -ge $color_list_num ]] && break; \
new_color=${color_list[$color_list_ind]}; \
case \"$new_color\" in \
\"\"|[\\ ]*) \
continue; \
;; \
\"${color[${color_ind[$j-1]}]}\") \
[[ $(($color_list_num-$color_repeat_ind)) -gt 1 ]] && continue; \
;;& \
*) \
color[$new_col_ind]=$new_color; \
color_ind[$j]=$new_col_ind; \
last_new_colored_line=$i; \
break; \
;; \
esac 2>/dev/null; \
done; \
;; \
*) \
[[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
;; \
esac; \
;; \
\" \") \
case \"${graph_line_last:$(($j+1)):1}\" in \
\"/\") \
color_ind[$j]=${color_ind[$j+1]}; \
;; \
*) \
new_col_ind=${#color[*]}; \
while true;do \
((color_list_ind++)); \
[[ $color_list_ind -ge $color_list_num ]] && color_list_ind=$color_repeat_ind; \
[[ $color_list_ind -ge $color_list_num ]] && break; \
new_color=${color_list[$color_list_ind]}; \
case \"$new_color\" in \
\"\"|[\\ ]*) \
continue; \
;; \
\"${color[${color_ind[$j-1]}]}\") \
[[ $(($color_list_num-$color_repeat_ind)) -gt 1 ]] && continue; \
;;& \
*) \
color[$new_col_ind]=$new_color; \
color_ind[$j]=$new_col_ind; \
last_new_colored_line=$i; \
break; \
;; \
esac 2>/dev/null; \
done; \
;; \
esac; \
;; \
*) \
[[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
;; \
esac; \
;; \
\"\"|[^\\ \\_\\*\\/\\|\\\\]) \
new_col_ind=${#color[*]}; \
while true;do \
((color_list_ind++)); \
[[ $color_list_ind -ge $color_list_num ]] && color_list_ind=$color_repeat_ind; \
[[ $color_list_ind -ge $color_list_num ]] && break; \
new_color=${color_list[$color_list_ind]}; \
case \"$new_color\" in \
\"\"|[\\ ]*) \
continue; \
;; \
\"${color[${color_ind[$j-1]}]}\") \
[[ $(($color_list_num-$color_repeat_ind)) -gt 1 ]] && continue; \
;;& \
*) \
color[$new_col_ind]=$new_color; \
color_ind[$j]=$new_col_ind; \
last_new_colored_line=$i; \
break; \
;; \
esac 2>/dev/null; \
done; \
;; \
*) \
[[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
;; \
esac; \
graph_colored=\"${graph_colored}\\033[${color[${color_ind[$j]}]}m$char\\033[0m\"; \
point_color=${color[${color_ind[$j]}]}; \
;; \
\"|\") \
case \"${graph_line_last:$j:1}\" in \
\" \") \
case \"${graph_line_last:$(($j-1)):1}\" in \
\"/\") \
color_ind[$j]=${color_ind[$j+1]}; \
;; \
\"\\\\\") \
color_ind[$j]=${color_ind_last[$j-1]:-${color_ind[$j-1]}}; \
;; \
*) \
case \"${graph_line_last:$(($j+1)):1}\" in \
\"/\") \
color_ind[$j]=${color_ind[$j+1]}; \
;; \
*) \
[[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
;; \
esac; \
;; \
esac; \
;; \
\"|\") \
case \"${graph_line_last:$(($j-1)):1}\" in \
\"\\\\\") \
case \"${graph_line:$(($j+1)):1}\" in \
\"\\\\\") \
:; \
;; \
\" \") \
color_ind[$j]=${color_ind_last[$j-1]}; \
;; \
*) \
[[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
;; \
esac; \
;; \
*) \
:; \
;; \
esac; \
;; \
\"*\") \
case \"${graph_line:$(($j-1)):1}\" in \
\"/\") \
if [[ $last_new_colored_line -eq $(($i-1)) ]];then \
new_col_ind=${#color[*]}; \
while true;do \
((color_list_ind++)); \
[[ $color_list_ind -ge $color_list_num ]] && color_list_ind=$color_repeat_ind; \
[[ $color_list_ind -ge $color_list_num ]] && break; \
new_color=${color_list[$color_list_ind]}; \
case \"$new_color\" in \
\"\"|[\\ ]*) \
continue; \
;; \
\"${color[${color_ind[$j-1]}]}\") \
[[ $(($color_list_num-$color_repeat_ind)) -gt 1 ]] && continue; \
;;& \
*) \
color[$new_col_ind]=$new_color; \
color_ind[$j]=$new_col_ind; \
break; \
;; \
esac 2>/dev/null; \
done; \
else \
color_ind[$j]=${color_ind_last[$j]}; \
fi; \
;; \
*) \
:; \
;; \
esac; \
;; \
\"/\") \
color_ind[$j]=${color_ind[$j]}; \
;; \
*) \
[[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
;; \
esac; \
graph_colored=\"${graph_colored}\\033[${color[${color_ind[$j]}]}m$char\\033[0m\"; \
;; \
\"/\") \
case \"${graph_line_last:$(($j)):1}\" in \
\"|\") \
case \"${graph_line_last:$(($j+1)):1}\" in \
\"/\") \
case \"${graph_line_next:$j:1}\" in \
\"|\") \
color_ind[$j]=${color_ind[$j+1]}; \
;; \
\" \") \
color_ind[$j]=${color_ind[$j]}; \
;; \
*) \
[[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
;; \
esac; \
;; \
*) \
color_ind[$j]=${color_ind[$j]}; \
;; \
esac; \
;; \
*) \
case \"${graph_line_last:$(($j+2)):1}\" in \
\"/\"|\"_\") \
color_ind[$j]=${color_ind[$j+2]}; \
;; \
*) \
case \"${graph_line_last:$(($j+1)):1}\" in \
\"/\"|\"_\"|\"|\") \
color_ind[$j]=${color_ind[$j+1]}; \
;; \
\"*\") \
case \"${graph_line:$(($j+1)):1}\" in \
\"|\") \
if [[ $last_new_colored_line -eq $(($i-1)) ]];then \
color_ind[$j]=${color_ind_last[$j+1]}; \
else \
new_col_ind=${#color[*]}; \
while true;do \
((color_list_ind++)); \
[[ $color_list_ind -ge $color_list_num ]] && color_list_ind=$color_repeat_ind; \
[[ $color_list_ind -ge $color_list_num ]] && break; \
new_color=${color_list[$color_list_ind]}; \
case \"$new_color\" in \
\"\"|[\\ ]*) \
continue; \
;; \
\"${color[${color_ind[$j-1]}]}\") \
[[ $(($color_list_num-$color_repeat_ind)) -gt 1 ]] && continue; \
;;& \
*) \
color[$new_col_ind]=$new_color; \
color_ind[$j]=$new_col_ind; \
break; \
;; \
esac 2>/dev/null; \
done; \
fi; \
;; \
*) \
color_ind[$j]=${color_ind_last[$j+1]}; \
;; \
esac; \
;; \
*) \
case \"${graph_line_last:$j:1}\" in \
\"\\\\\") \
:; \
;; \
\" \") \
case \"${graph_line_last:$(($j+1)):1}\" in \
\"*\") \
color_ind[$j]=${color_ind[$j+1]}; \
;; \
*) \
[[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
;; \
esac; \
;; \
*) \
[[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
;; \
esac; \
;; \
esac; \
;; \
esac; \
;; \
esac; \
graph_colored=\"${graph_colored}\\033[${color[${color_ind[$j]}]}m$char\\033[0m\"; \
;; \
\"\\\\\") \
case \"${graph_line_last:$(($j-1)):1}\" in \
\"|\"|\"\\\\\") \
color_ind[$j]=${color_ind_last[$j-1]:-${color_ind[$j-1]}}; \
;; \
\"*\") \
new_col_ind=${#color[*]}; \
while true;do \
((color_list_ind++)); \
[[ $color_list_ind -ge $color_list_num ]] && color_list_ind=$color_repeat_ind; \
[[ $color_list_ind -ge $color_list_num ]] && break; \
new_color=${color_list[$color_list_ind]}; \
case \"$new_color\" in \
\"\"|[\\ ]*) \
continue; \
;; \
\"${color[${color_ind[$j-1]}]}\") \
[[ $(($color_list_num-$color_repeat_ind)) -gt 1 ]] && continue; \
;;& \
*) \
color[$new_col_ind]=$new_color; \
color_ind[$j]=$new_col_ind; \
break; \
;; \
esac 2>/dev/null; \
done; \
;; \
\" \") \
case \"${graph_line_last:$(($j-2)):1}\" in \
\"\\\\\"|\"_\") \
color_ind[$j]=${color_ind_last[$j-2]:-${color_ind[$j-2]}}; \
;; \
*) \
case \"${graph_line_last:$j:1}\" in \
\"|\") \
color_ind[$j]=${color_ind_last[$j]:-${color_ind[$j]}}; \
;; \
*) \
[[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
;; \
esac; \
;; \
esac; \
;; \
*) \
[[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
;; \
esac; \
graph_colored=\"${graph_colored}\\033[${color[${color_ind[$j]}]}m$char$char\\033[0m\"; \
;; \
\"_\") \
case \"${graph_line:$(($j-2)):1}\" in \
\"\\\\\"|\"_\") \
color_ind[$j]=${color_ind[$j-2]}; \
;; \
\" \"|\"/\") \
k=2; \
while [[ \"${graph_line:$(($j+$k)):1}\" = \"_\" ]];do \
k=$(($k+2)); \
done; \
case \"${graph_line:$(($j+$k)):1}\" in \
\"/\") \
case \"${graph_line_last:$(($j+$k+1)):1}\" in \
\"*\") \
color_ind[$j]=${color_ind[$j+$k+1]}; \
;; \
\" \") \
case \"${graph_line_last:$(($j+$k)):1}\" in \
\"\\\\\") \
color_ind[$j]=${color_ind[$j+$k]}; \
;; \
*) \
[[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
;; \
esac; \
;; \
\"|\") \
case \"${graph_line:$(($j+$k+1)):1}\" in \
\"|\") \
color_ind[$j]=${color_ind[$j+$k+2]}; \
;; \
\" \") \
color_ind[$j]=${color_ind[$j+$k+1]}; \
;; \
*) \
[[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
;; \
esac; \
;; \
*) \
[[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
;; \
esac; \
;; \
*) \
[[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
;; \
esac; \
;; \
*) \
[[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
;; \
esac; \
graph_colored=\"${graph_colored}\\033[${color[${color_ind[$j]}]}m$char\\033[0m\"; \
;; \
esac; \
char_last=$char; \
done <<< \"$(grep -Eo \".\" <<< \"${graph_line%%$delim*}\")\"; \
for key in ${!color_ind[*]};do \
color_ind_last[$key]=${color_ind[$key]}; \
done; \
\
\
c=0; \
((l++)); \
[[ $l -gt $n ]] && l=1; \
while IFS= read -d\"$delim\" -r col_content;do \
((c++)); \
[[ $c -le $graph_col ]] && c_corr=-1 || c_corr=0; \
if [[ $c -eq 1 ]];then \
[[ \"${col_content/\\*}\" = \"$col_content\" ]] && [[ $l -eq 1 ]] && l=$n; \
whitespaces=$(seq -s\" \" $((${col_length[\"1:1\"]}-$j))|tr -d \"[:digit:]\"); \
col_content[$graph_col]=\"${graph_colored}$whitespaces\"; \
elif [[ ${col_colored[\"$l:$c\"]:-0} -eq 0 ]];then \
col_content[$c+$c_corr]=\"\\033[${point_color:-0}m$(printf \"%-${col_length[\"$l:$c\"]}s\" \"${col_content:-\"\"}\")\\033[0m\"; \
else \
col_content[$c+$c_corr]=\"$(printf \"%-${col_length[\"$l:$c\"]}s\" \"${col_content:-\"\"}\")\"; \
fi; \
done <<< \"$line$delim\"; \
for ((k=$c+1;k<=$i_max;k++));do \
[[ $k -le $graph_col ]] && c_corr=-1 || c_corr=0; \
col_content[$k+$c_corr]=\"$(printf \"%-${col_length[\"$l:$k\"]:-${col_length[\"${last[$k]:-1}:$k\"]:-0}}s\" \"\")\"; \
done; \
unset col_content[0]; \
echo -e \"${col_content[*]}\"; \
unset col_content[*]; \
done < <(git $1 && echo); \
"' "git-colored"
Uitleg:
- De eerste alinea laadt de delim(iter), kleurenlijst en YourLogAlias in shell-variabelen
- De tweede leest de lengte voor elke kolom
- De derde telt de maximale lengte van de boom
- De vierde laadt de boom in een array
- De vijfde kleurt de boom, gebaseerd op casusanalyse
- De zesde kleurt niet-boomkolommen en drukt de tabelachtige uitvoer af
Het grootste deel is de casusanalyse voor het instellen van de boomkleuren. De andere delen worden uitgelegd in mijn gekoppelde antwoord voor tabelachtige shell-uitgangen.
Laat je favoriete geformatteerde log-alias in de opmerkingen zien, want de mijne zijn slechts voorbeelden.
Antwoord 27
Probeer ditaa. Het kan elk ASCII-diagram omzetten in een afbeelding. Hoewel het niet ontworpen was met Git branches in gedachten, was ik onder de indruk van de resultaten.
Bron (txt-bestand):
+--------+
| hotfix |
+---+----+
|
--*<---*<---*
^
|
\--*<---*
|
+---+----+
| master |
+--------+
Opdracht:
java -jar ditaa0_9.jar ascii-graph.txt
Resultaat:
Het ondersteunt ook achtergrondkleuren, stippellijnen, verschillende vormen en meer. Zie de voorbeelden.
Antwoord 28
Enkele aliassen in bestand ~/.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'
Antwoord 29
Als je repository op GitLab staat, kun je de grafische weergave ervan gebruiken zoals die wordt weergegeven als een SVG in je browser.
-
Ga naar de grafiekweergave van uw repository, bijvoorbeeld https:/ /gitlab.com/gitlab-org/gitter/webapp/network/develop
-
Scroll de grafiek naar beneden (het laadt de commits lui!)
-
Gebruik het infovenster van uw browser om het SVG-element naar een nieuw bestand te kopiëren
-
Open het in een renderer naar keuze, bijv. Inkscape
Antwoord 30
Er is een funky Git-commit-grafiek als een van de demo’s van de Raphaelwebgraphics-bibliotheek.
De demo is statisch, maar het zou gemakkelijk genoeg moeten zijn om de code te nemen en hun statische gegevens om te ruilen voor een live set gegevens — ik denk dat het gewoon Git-commit-gegevens in JSON-indeling zijn.
De demo is hier: http://dmitrybaranovskiy.github.io/raphael/github /impact.html