Graphiques de branche assez git

J'ai vu que certains livres et articles ont de très jolis graphiques de branches et de commits git. Comment puis-je créer des images imprimables de haute qualité de l'historique Git?

Mise à jour: Cette réponse a reçu beaucoup plus d'attention qu'elle ne le mérite. Il a été initialement publié parce que je pense que les graphiques sont beaux et qu'ils pourraient être dessinés dans Illustrator pour une publication - et il n'y avait pas de meilleure solution. Mais il existe maintenant des réponses beaucoup plus applicables à ce Q, comme celles de Fracz , Jubobs ou Harry Lee ! S'il vous plaît, allez les voter !!

Mise à jour 2: j'ai publié une version améliorée de cette réponse à la topologie de la branche Visualisation dans la question git , car elle est beaucoup plus appropriée là-bas. Cette version comprend lg3, qui affiche à la fois les informations sur l'auteur et le committer, vous devriez donc vraiment les vérifier. Laisser cette réponse pour des raisons historiques (& rep, je l'admets), bien que je sois vraiment tenté de la supprimer.

Mon 2 ¢ : J'ai deux alias que je jette normalement dans mon ~/.gitconfigfichier:

[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 lg1ressemble à ceci:

et git lg2ressemble à ceci:

Beaucoup de réponses ici sont excellentes, mais pour ceux qui veulent juste une simple ligne à la réponse ponctuelle sans avoir à configurer d'alias ou quoi que ce soit de plus, voici:

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

Tout le monde ne ferait pas git logtout le temps, mais quand vous en avez besoin, n'oubliez pas:

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

Pour la sortie textuelle, vous pouvez essayer:

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

ou:

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

ou: voici un alias graphviz pour dessiner le graphe DAG.

J'utilise personnellement gitx, gitk --allet gitnub.

Gitgraph.js permet de dessiner de jolies branches git sans référentiel. Il vous suffit d'écrire un code Javascript qui configure vos branches et validations et de le rendre dans le navigateur.

var gitGraph = new GitGraph({
   template: "blackarrow",
   mode: "compact",
   orientation: "horizontal",
   reverseArrow: true
});

var master = gitGraph.branch("master").commit().commit();
var develop = gitGraph.branch("develop").commit();
master.commit();
develop.commit().commit();
develop.merge(master);

ou avec metromodèle:

ou avec des messages de validation, des auteurs et des balises:

Testez-le avec JSFiddle .

Générez-le avec Git Grapher par @bsara.

Construit au-dessus de TikZ et PGF , gitdagsest un petit paquet LaTeX qui vous permet de produire sans effort des graphiques de validation de graphiques vectoriels, et plus encore.

La génération automatique du graphe de validation d'un référentiel existant n'est pas le but de gitdags; les graphiques qu'il produit ne sont destinés qu'à des fins éducatives .

Je l'utilise souvent pour produire des graphiques pour mes réponses aux questions Git, comme alternative aux graphiques de validation ASCII:

• Comment puis-je faire un bugfix sur master et l'intégrer dans mes branches moins stables?
• Comment fonctionne git commit --amend, exactement?
• Pourquoi Git me dit "Pas actuellement sur une branche" après avoir exécuté "git checkout origin / <branch>"?
• Quelle est la différence entre la fusion du maître en branche et la fusion de la branche en maître?
• Git rebase - preserve-merges échoue

Voici un exemple d'un tel graphique démontrant les effets d'un simple rebase:

\documentclass{article}

\usepackage{subcaption}
\usepackage{gitdags}

\begin{document}

\begin{figure}
  \begin{subfigure}[b]{\textwidth}
    \centering
    \begin{tikzpicture}
      % Commit DAG
      \gitDAG[grow right sep = 2em]{
        A -- B -- { 
          C,
          D -- E,
        }
      };
      % Tag reference
      \gittag
        [v0p1]       % node name
        {v0.1}       % node text
        {above=of A} % node placement
        {A}          % target
      % Remote branch
      \gitremotebranch
        [origmaster]    % node name
        {origin/master} % node text
        {above=of C}    % node placement
        {C}             % target
      % Branch
      \gitbranch
        {master}     % node name and text 
        {above=of E} % node placement
        {E}          % target
      % HEAD reference
      \gitHEAD
        {above=of master} % node placement
        {master}          % target
    \end{tikzpicture}
    \subcaption{Before\ldots}
  \end{subfigure}

  \begin{subfigure}[b]{\textwidth}
    \centering
    \begin{tikzpicture}
      \gitDAG[grow right sep = 2em]{
        A -- B -- { 
          C -- D' -- E',
          {[nodes=unreachable] D -- E },
        }
      };
      % Tag reference
      \gittag
        [v0p1]       % node name
        {v0.1}       % node text
        {above=of A} % node placement
        {A}          % target
      % Remote branch
      \gitremotebranch
        [origmaster]    % node name
        {origin/master} % node text
        {above=of C}    % node placement
        {C}             % target
      % Branch
      \gitbranch
        {master}      % node name and text 
        {above=of E'} % node placement
        {E'}          % target
      % HEAD reference
      \gitHEAD
        {above=of master} % node placement
        {master}          % target
    \end{tikzpicture}
    \subcaption{\ldots{} and after \texttt{git rebase origin/master}}
  \end{subfigure}
  \caption{Demonstrating a typical \texttt{rebase}}
\end{figure}

\end{document}

Gitg est un clone de Gitk et GitX pour GNOME (il fonctionne également sur KDE, etc.) qui montre un joli graphique coloré.

Il est activement développé (à partir de 2012). Il vous permet de trier les validations (nœuds de graphique) de façon chronologique ou topologique et de masquer les validations qui ne mènent pas à une branche sélectionnée.

Cela fonctionne bien avec les grands référentiels et les graphiques de dépendances complexes.

Exemples de captures d'écran, montrant les référentiels linux-git et linux-2.6:

Je viens d'écrire un outil qui peut générer un joli graphique de commits git en utilisant HTML / Canvas.

Et fournissez un plugin jQuery qui le rend facile à utiliser.

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

Aperçu:

Sourcetree est vraiment bon. Il imprime un bon historique et un graphique de branche et de taille moyenne: (ce qui suit est fait sur un projet expérimental Git juste pour voir quelques branches). Prend en charge Windows 7+ et Mac OS X 10.6+.

git-forestest un excellent script perl que j'utilise depuis plus d'un an et j'utilise à peine la git logcommande directement.

Voici certaines des choses que j'aime dans ce script:

• Il utilise des caractères unicode pour dessiner les lignes dans le graphique en donnant un aspect plus continu aux lignes du graphique.
• Vous pouvez combiner --reverseavec la sortie graphique, ce qui n'est pas possible avec la git logcommande régulière .
• Il utilise en git loginterne pour récupérer la liste des validations, de sorte que toutes les options auxquelles vous passez git logpeuvent également être transmises à ce script.

J'ai un alias utilisant git-forestcomme suit:

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

Voici à quoi ressemble la sortie sur un terminal:

J'ai écrit un outil Web pour convertir les journaux git en jolis graphiques SVG: Bit-Booster - Outil de dessin de graphique de validation hors ligne

Télécharger la sortie de git log --pretty='%h|%p|%d' directement dans l'outil, puis cliquez sur le lien "download graph.svg".

L'outil est purement côté client, et donc aucune de vos données Git n'est partagée avec mon serveur. Vous pouvez également enregistrer le HTML + JS localement et l'exécuter à l'aide des URL "file: ///". Vérifié sur Chrome 48 et Firefox 43 sur Ubuntu 12.04.

Il génère du HTML qui peut être publié directement dans n'importe quelle page (y compris le moteur de blog blogspot!). Jetez un œil à certains des articles de blog ici:

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

Voici une capture d'écran d'un exemple de fichier HTML généré par l'outil:

http://bit-booster.com/graph.html (l'outil)

Basé sur un script Graphviz que j'ai trouvé dans une réponse à une question connexe , j'ai piraté un script ruby qui crée une vue récapitulative d'un référentiel git. Il efface toute l'histoire linéaire et ne montre que les commits "intéressants", c'est-à-dire ceux avec plusieurs parents, plusieurs enfants, ou pointés par une branche ou une balise. Voici un extrait du graphique qu'il génère pour jquery :

git-big-picture et BranchMaster sont des outils similaires qui essaient de n'afficher que la structure de haut niveau d'un graphique, en affichant uniquement la relation entre les balises, les branches, les fusions, etc.

Cette question a plus d'options.

J'ai ajouté trois commandes personnalisées: git tree, git streeet git vtree. Je vais les parcourir dans cet ordre.

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

Avec git streeet git vtreej'ai utilisé bash pour aider au formatage.

[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: Cela fonctionne avec la version 1.9a de git. La valeur de couleur «auto» fait apparemment ses débuts dans cette version. C'est un ajout intéressant car les noms de branche auront une couleur différente. Cela facilite par exemple la distinction entre les succursales locales et distantes.

Cela dépend de ce à quoi ils ressemblaient. J'utilise gitx qui fait des images comme celle-ci:

Vous pouvez comparer git log --graphvs gitk sur une fusion de poulpe à 24 voies (originellement de http://clojure-log.n01se.net/date/2008-12-24.html ):

Pour une sortie textuelle plus détaillée, veuillez essayer:

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

Vous pouvez écrire un alias dans $ HOME / .gitconfig

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

Voici mon point de vue sur cette question:

Capture d'écran:

Usage:

git hist - Afficher l'historique de la branche actuelle

git hist --all - Afficher le graphique de toutes les branches (y compris les télécommandes)

git hist master devel - Montrer la relation entre deux ou plusieurs branches

git hist --branches - Afficher toutes les succursales locales

Ajouter --topo-orderpour trier les validations topologiquement, au lieu de par date (par défaut dans cet alias)

Avantages:

• Ressemble à un simple --decorate, donc avec des couleurs distinctes pour différents noms de branche
• Ajoute un e-mail de committer
• Ajoute la date relative et absolue de validation
• Sorts s'engage par date

Installer:

git config --global alias.hist "log --graph --date-order --date=short \
--pretty=format:'%C(auto)%h%d %C(reset)%s %C(bold blue)%ce %C(reset)%C(green)%cr (%cd)'"

gitg : un visualiseur de référentiel basé sur gtk, c'est nouveau mais intéressant et utile
http://git.gnome.org/browse/gitg
Je l'utilise actuellement

Bien que parfois j'utilise gitg , revenez toujours en ligne de commande:

[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 

Comme vous pouvez le voir, c'est presque une frappe de sauvegarde d'alias, basée sur:

• --couleur: look clair
• --graph: visualiser les parents
• --date-order: look le plus compréhensible au repo
• - décorer: qui est qui
• --oneline: plusieurs fois tout ce que vous devez savoir sur un commit
• - simplifier par décoration: basique pour un premier aperçu (juste des tags, des fusions pertinentes, des branches)
• --all: sauvegarde des frappes avec tous les alias avec et sans cette option
• --date = relative (% ar): Comprendre l'activité dans le repo (parfois une branche est peu engagée près de master mais il y a des mois de sa part)

Voir dans la version récente de git (1.8.5 et au-dessus), vous pouvez bénéficier de% C (auto) dans la décoration placeholder% d

À partir d'ici, tout ce dont vous avez besoin est une bonne compréhension des gitrevisions pour filtrer tout ce dont vous avez besoin (quelque chose comme master..develop, où --simplify-merges pourrait aider avec les branches à long terme)

La puissance derrière la ligne de commande est la configuration rapide en fonction de vos besoins (comprendre qu'un dépôt n'est pas une configuration de journal de clé unique, donc l'ajout de --numstat, ou --raw, ou --name-status est parfois nécessaire. Ici git log et les alias sont rapides, puissants et (avec le temps) le plus joli graphique que vous pouvez obtenir. Encore plus, avec une sortie affichée par défaut via un pager (dites moins), vous pouvez toujours rechercher rapidement dans les résultats. Pas convaincu? Vous pouvez toujours analyser le résultat avec des projets comme gitgraph

Très légèrement peaufiné la réponse impressionnante de Slipp , vous pouvez utiliser ses alias pour enregistrer une seule branche:

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

En laissant de côté, --allvous pouvez maintenant

git lgBranch1 <branch name>

ou même

git lgBranch1 --all

Je suggère tig https://github.com/jonas/tig , un bien meilleur outil de ligne de commande pour git.

Vous pouvez utiliser homebrew pour installer tig sur macOS:

$ brew install tig
$ tig

J'ai cet git logalias ~/.gitconfigpour afficher l'historique du graphique:

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

Avec cela en place, git lproduira quelque chose comme:

Dans Git 2.12 +, vous pouvez même personnaliser les couleurs de ligne du graphique en utilisant l' log.graphColorsoption de configuration.

Quant au format des logs, il est similaire à --oneline, avec l'ajout du nom de l' auteur (respectant .mailmap) et de la date relative de l'auteur . Notez que la %C(auto)syntaxe, qui indique à Git d'utiliser les couleurs par défaut pour le hachage de validation, etc. est prise en charge dans Git> = 1.8.3 .

Avez-vous essayé gitkou gitk --all? Cependant, il n'a pas de fonction d'impression / sauvegarde img.

GitGraph

Génère une représentation PNG ou SVG de l'historique des validations de votre référentiel Git.

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

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

Ceci est ma variante terminale, similaire à de nombreuses réponses ici. J'aime ajuster les drapeaux passés lesspour éviter le retour à la ligne.

J'ai défini cela sur un alias pour un accès rapide car la commande est un peu lourde.

Essayez ditaa . Il peut transformer n'importe quel diagramme ASCII en une image. Bien qu'il n'ait pas été conçu en pensant aux branches Git, j'ai été impressionné par les résultats.

Source (fichier txt):

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

Commander:

java -jar ditaa0_9.jar ascii-graph.txt

Résultat:

Il prend également en charge les couleurs d'arrière-plan, les lignes en pointillés, différentes formes et plus encore. Voir les exemples .

Si votre référentiel se trouve sur Gitlab, vous pouvez utiliser sa représentation graphique telle qu'elle est rendue en SVG dans votre navigateur.

• Accédez à la vue graphique de votre référentiel, par exemple https://gitlab.com/gitlab-org/gitter/webapp/network/develop

• Faites défiler le graphique vers le bas (il charge paresseusement les commits!)

• Utilisez l'inspecteur de votre navigateur pour copier l'élément SVG dans un nouveau fichier

• Ouvrez-le dans un moteur de rendu de votre choix, par exemple Inkscape

Je ne connais pas d'outil direct, mais vous pouvez peut-être pirater un script pour exporter les données au format dot et les rendre avec graphviz.

Il y a un graphique de validation Git génial comme l'une des démos de la bibliothèque graphique Web Raphael .

La démo est statique, mais il devrait être assez facile de prendre le code et d'échanger leurs données statiques pour un ensemble de données en direct - je pense que ce sont juste des données de validation Git au format JSON.

La démo est ici: http://dmitrybaranovskiy.github.io/raphael/github/impact.html

Une sortie de graphique git agréable et propre pour les coquilles

avec des hachages comme d'habitude à côté de l'arbre graphique

ou dans une colonne supplémentaire

Edit : Vous voulez commencer tout de suite sans lire les explications? Utilisez l'alias git, les extraits de code de script ou de fonction de la section EDIT 5 ci-dessous ou même la manière la plus confortable avec EDIT 6 .

Dans toutes les réponses à cette question, aucune n'a montré jusqu'à présent une sortie propre aux tableaux pour les coquilles. Le plus proche était cette réponse des évangiles d' où je suis parti.

Le point central de mon approche est de ne compter que les caractères d'arbre montrés à l'utilisateur. Remplissez-les ensuite à une longueur personnelle avec des espaces blancs.

Autre que git, vous avez besoin de ces outils

• grep
• pâte
• printf
• sed
• seq
• tr
• toilettes

principalement à bord avec n'importe quelle distribution Linux.

L'extrait de code est

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

Pour calculer les espaces nécessaires que nous utilisons

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

pour obtenir tous les caractères (jusqu'à 1000 par ligne) que de sélectionner uniquement les caractères d'arbre: * | / \ _ et espaces avec

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

enfin, comptez-les et soustrayez le résultat de notre valeur de longueur choisie, qui est 9 dans l'exemple.

Pour produire la quantité calculée d'espaces blancs que nous utilisons

  seq -s' ' $whitespaces

et tronquer les numéros de position avec

  tr -d '[:digit:]'

que de les ajouter à la fin de notre ligne de graphique. C'est ça!

Git a la bonne option pour formater la longueur des spécificateurs de sortie déjà avec la syntaxe '%><(amount_of_characters,truncate_option)', qui ajoute des espaces blancs du côté gauche '>' ou droit '<' et peut tronquer les caractères du début 'ltrunc', du milieu 'mtrunc' ou de la fin «trunc».

Il est important que les cmd printf ci-dessus utilisent les mêmes valeurs de longueur pour la colonne git correspondante.

Amusez-vous à créer votre propre sortie propre à la table selon vos besoins.

Supplémentaire:

Pour obtenir la bonne valeur de longueur, vous pouvez utiliser l'extrait de code suivant

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

et utilisez $ max_chars comme la bonne valeur de longueur ci-dessus.

EDIT 1 : Je viens de remarquer que le caractère de soulignement est également utilisé dans l'arbre git et modifiez les extraits de code ci-dessus en conséquence. S'il manque d'autres caractères, veuillez laisser un commentaire.

EDIT 2 : Si vous voulez vous débarrasser des crochets autour des entrées de branche et de balise, utilisez simplement "% D" au lieu de "% d" dans la commande git, comme dans EDIT 3.

EDIT 3 : Peut-être que l'option de couleur "auto" est celle que vous préférez le plus pour les entrées de branche et d'étiquette?

Modifiez cette partie de la commande git (couleur 214 )

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

à auto

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

EDIT 4 : Ou vous aimez votre propre mélange de couleurs pour cette partie, une sortie fantaisie avec une tête clignotante?

Pour pouvoir d'abord styliser les noms de tête, de branche et de balises, nous avons besoin de l'option de couleur "auto" dans notre commande git comme dans EDIT 3.

Ensuite, nous pouvons remplacer les valeurs de couleurs connues par les nôtres en ajoutant ces 3 lignes

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

juste avant la ligne

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

dans notre extrait de code. Les valeurs de remplacement produisent les couleurs ci-dessus.

Par exemple, la valeur de remplacement pour la tête est

3;5;1;38;5;196

où 3; signifie italique, 5; pour clignoter et 1; 38; 5; 196 pour la couleur. Pour plus d'informations, commencez ici. Remarque: ce comportement dépend de votre terminal préféré et peut donc ne pas être utilisable.

MAIS vous pouvez choisir n'importe quelle valeur de couleur que vous préférez.

VUE D'ENSEMBLE des valeurs de couleur git et équivalents ANSI

Vous trouverez ici une liste avec l' option git color / style .

Si vous avez besoin de la sortie sur votre console pour des couleurs précises (l'image ci-dessus est réduite par stackoverflow), vous pouvez produire la sortie avec

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

dans votre chemin de projet git qui utilise le premier commit de votre sortie de journal git.

EDIT 5 : Comme le membre "Andras Deak" l'a mentionné, il existe plusieurs façons d'utiliser ce code:

1) comme alias :

alias n'accepte pas les paramètres mais une fonction peut , donc juste définir dans votre .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" ###

   }

et appelez la fonction git_tably (dérivée de tablelike) directement sous votre chemin de projet git ou d'où vous voulez avec votre chemin de projet git comme premier paramètre.

2) en tant que script shell :

Je l'utilise avec l'option pour lui passer un répertoire de projet git comme premier paramètre ou s'il est vide, prendre le répertoire de travail comme le comportement normal. Dans son intégralité, nous avons

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

Le moyen le plus confortable est peut-être d'ajouter un alias git dans votre .gitconfig

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

[alias]
    count-log = log --all --graph --pretty=format:' '
    tably-log = log --all --graph --decorate=short --color --pretty=format:'+%C(bold 214)%<(7,trunc)%h%C(reset)+%C(dim white)%>(12,trunc)%cr%C(reset)+%C(auto)%>(15,trunc)%D%C(reset)+%C(white)%s%C(reset)'
    tably     = !bash -c '"                                                                                                    \
                  while IFS=+ read -r graph;do                                                                                 \
                    chars_count=$(sed -nl1000 \"l\" <<< \"$graph\" | grep -Eo \"\\\\\\\\\\\\\\\\|\\||\\/|\\ |\\*|_\" | wc -l); \
                    [[ $chars_count -gt ${max_chars:-0} ]] && max_chars=$chars_count;                                          \
                  done < <(git count-log && echo);                                                                             \
                  while IFS=+ read -r graph hash time branch message;do                                                        \
                    chars=$(sed -nl1000 \"l\" <<< \"$graph\" | grep -Eo \"\\\\\\\\\\\\\\\\|\\||\\/|\\ |\\*|_\" | wc -l);       \
                    whitespaces=$(($max_chars-$chars));                                                                        \
                    whitespaces=$(seq -s\" \" $whitespaces|tr -d \"[:digit:]\");                                               \
                    graph_all=\"$graph_all$graph$whitespaces\n\";                                                              \
                    hash_all=\"$hash_all$(printf \"%7s\" \"$hash\")  \n\";                                                     \
                    time_all=\"$time_all$(printf \"%12s\" \"$time\") \n\";                                                     \
                    branch_all=\"$branch_all$(printf \"%15s\" \"$branch\")\n\";                                                \
                    message_all=\"$message_all$message\n\";                                                                    \
                  done < <(git tably-log && echo);                                                                             \
                  paste -d\" \" <(echo -e \"$time_all\") <(echo -e \"$branch_all\") <(echo -e \"$graph_all\")                  \
                                <(echo -e \"$hash_all\") <(echo -e \"$message_all\");                                          \
                '"

Que simplement appeler git tablysous n'importe quel chemin de projet.

Git est si puissant que vous pouvez changer la tête, les tags, ... directement comme indiqué ci-dessus et pris à partir d'ici .

Une autre option sophistiquée consiste à sélectionner les couleurs d'arbre que vous préférez le plus avec

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

qui vous donne un aspect fou mais toujours des sorties de journaux git

Trop de clignotements! Juste pour montrer ce qui est possible. Trop peu de couleurs spécifiées entraînent des répétitions de couleurs.

Une référence .gitconfig complète est à portée de clic.

EDIT 6 : En raison de vos votes positifs, j'ai amélioré l'extrait de code. Maintenant, vous pouvez le nourrir avec presque n'importe quelle commande git log et vous n'avez plus besoin d'adapter le code. Essayez!

Comment ça fonctionne?

• définir vos commandes git log dans votre .gitconfig comme toujours
• définir un numéro de colonne d'arbre positif (facultatif), où le graphique git est affiché

Alors appelez

git tably YourLogAlias

ou

git tably YourLogAlias TreeColNumber

où TreeColNumber écrase une valeur toujours définie d'en haut.

Limitation:

• pour chaque spécificateur de votre commande log, vous devez utiliser cette syntaxe

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

  en plus du dernier et seulement si votre colonne d'arbre choisie ne doit pas être la dernière

  (pour des explications, voir https://git-scm.com/docs/pretty-formats )

• Vous devez choisir et utiliser un délimiteur de colonne qui peut poser des problèmes s'il n'est pas unique
• le nom de votre numéro de colonne d'arbre défini pour un alias de journal spécifique doit être YourLogAlias-col

Maintenant l'extrait amélioré pour votre .gitconfig

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

[alias]

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

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

Résultats:

ou avec le nouveau TreeColNumber à la volée

ENCORE: Amusez-vous à créer votre propre sortie propre à la table selon vos besoins.

certains alias dans ~ / .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'

Pour les utilisateurs OSX, j'ai pris l'exemple @gospes et l'ai légèrement modifié pour gsed ( gnu-sedinstallé via homebrew) et ajusté les couleurs (pour travailler avec un fond noir , je ne sais pas comment l'exemple original pourrait éventuellement rendre la façon dont il le fait dans le exemple car il spécifie du texte noir sur un terminal avec un fond noir).

[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 clé pour OSX est d'installer d'abord gnu sed (qui a l'option -r). Le plus facilement fait avec homebrew, qui n'écrasera pas le sed installé par le système, mais installera plutôt gnu sed en tant que "gsed". J'espère que cela aide @ SlippD.Thompson qui a commenté ci-dessus que OSX ne fonctionne pas.