Ładne wykresy gałęzi git

Widziałem, że niektóre książki i artykuły zawierają naprawdę ładnie wyglądające wykresy gałęzi gita i zatwierdzeń. Jak mogę zrobić wysokiej jakości drukowane obrazy historii git?

Aktualizacja: Ta odpowiedź przyciągnęła o wiele więcej uwagi niż na to zasługuje. Został pierwotnie opublikowany, ponieważ uważam, że wykresy wyglądają ładnie i można je było pobrać w programie Illustrator do publikacji - i nie było lepszego rozwiązania. Ale teraz istnieje wiele bardziej odpowiednich odpowiedzi na to pytanie, takich jak Fracz , Jubobs lub Harry Lee ! Proszę, głosujcie!

Aktualizacja 2: Opublikowałem ulepszoną wersję tej odpowiedzi w topologii gałęzi Visualizing w pytaniu git , ponieważ jest tam o wiele bardziej odpowiednia. Ta wersja zawiera informacje lg3o autorze i komisarzu, więc naprawdę powinieneś to sprawdzić. Pozostawienie tej odpowiedzi ze względów historycznych (i rep, przyznaję), choć naprawdę kusi mnie, aby ją po prostu usunąć.

Moje 2 ¢ : Mam dwa aliasy, które zwykle wrzucam do ~/.gitconfigpliku:

[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 lg1wygląda następująco:

i git lg2wygląda tak:

Wiele odpowiedzi tutaj jest świetnych, ale dla tych, którzy chcą tylko prostej odpowiedzi od jednego wiersza do punktu bez konieczności ustawiania aliasów lub czegokolwiek dodatkowego, oto:

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

Nie wszyscy robiliby git logcały czas, ale kiedy tego potrzebujesz, pamiętaj:

„ Pies ” = git log - a ll - d ecorate - o neline - g raph

Aby uzyskać tekst, możesz spróbować:

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

lub:

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

lub: oto alias graphviz do rysowania wykresu DAG.

Ja osobiście używać gitx, gitk --alli gitnub.

Gitgraph.js pozwala rysować ładne gałęzie git bez repozytorium. Po prostu napisz kod JavaScript, który konfiguruje twoje gałęzie, zatwierdza i renderuje go w przeglądarce.

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

lub z metroszablonem:

lub z wiadomościami zatwierdzającymi, autorami i tagami:

Przetestuj za pomocą JSFiddle .

Wygeneruj go za pomocą Git Grapher przez @bsara.

Zbudowany na bazie TikZ i PGF , gitdagsto mały pakiet LaTeX, który pozwala bez wysiłku tworzyć wykresy zatwierdzeń grafiki wektorowej i wiele więcej.

Automatyczne generowanie wykresu zatwierdzeń istniejącego repozytorium nie jest celem gitdags; wykresy, które produkuje, są przeznaczone wyłącznie do celów edukacyjnych .

Często używam go do tworzenia wykresów dla moich odpowiedzi na pytania Git, jako alternatywy dla wykresów zatwierdzania ASCII:

• Jak mogę naprawić błąd w Master i zintegrować go z moją mniej stabilną gałęzią?
• Jak dokładnie działa git commit --amend?
• Dlaczego Git mówi mi „Obecnie nie ma żadnego oddziału” po uruchomieniu „git checkout origin / <branch>”?
• Jaka jest różnica między połączeniem wzorca w oddziale i scaleniem oddziału w wzorzec?
• Git rebase - połączenie zachowujące się nie powiedzie się

Oto przykład takiego wykresu pokazującego efekty prostej bazy:

\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 to klon Gitk i GitX dla GNOME (działa również na KDE itp.), Który pokazuje dość kolorowy wykres.

Jest aktywnie rozwijany (od 2012 r.). Pozwala sortować zatwierdzenia (węzły wykresu) chronologicznie lub topologicznie oraz ukrywać zatwierdzenia, które nie prowadzą do wybranej gałęzi.

Działa dobrze z dużymi repozytoriami i złożonymi wykresami zależności.

Przykładowe zrzuty ekranu przedstawiające repozytoria linux-git i linux-2.6:

SourceTree jest naprawdę dobry. Drukuje dobrze wyglądającą i średniej wielkości historię oraz wykres gałęzi: (w eksperymentalnym projekcie Git wykonuje się następujące czynności, aby zobaczyć niektóre gałęzie). Obsługuje Windows 7+ i Mac OS X 10.6+.

http://www.sourcetreeapp.com/

Właśnie napisałem jedno narzędzie, które może generować ładny wykres zatwierdzeń git za pomocą HTML / Canvas.

I zapewnij wtyczkę jQuery, która ułatwia obsługę.

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

Zapowiedź:

git-forestjest doskonałym skryptem perlowym, którego używam od ponad roku i prawie nie używam tego git logpolecenia bezpośrednio.

Oto niektóre z rzeczy, które uwielbiam w tym skrypcie:

• Wykorzystuje znaki Unicode do rysowania linii na wykresie, zapewniając bardziej ciągły wygląd linii wykresu.
• Można łączyć --reversez danymi wyjściowymi wykresu, co nie jest możliwe w przypadku zwykłego git logpolecenia.
• Wykorzystuje git logwewnętrznie do pobierania listy zatwierdzeń, więc wszystkie opcje, które przekazujesz, git logmogą być również przekazywane do tego skryptu.

Mam alias, używając git-forestnastępujących elementów:

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

Tak wygląda wyjście na terminalu:

Napisałem narzędzie sieciowe do konwersji dzienników git na ładne wykresy SVG: Bit-Booster - narzędzie do rysowania wykresów offline

Prześlij dane wyjściowe git log --pretty='%h|%p|%d'bezpośrednio do narzędzia, a następnie kliknij link „pobierz graph.svg”.

Narzędzie jest po stronie klienta, więc żadne z twoich danych Git nie są udostępniane mojemu serwerowi. Możesz także zapisać HTML + JS lokalnie i uruchomić go przy użyciu adresów URL „file: ///”. Zweryfikowano na Chrome 48 i Firefox 43 na Ubuntu 12.04.

Generuje HTML, który można umieszczać bezpośrednio na dowolnej stronie (w tym na blogowym silniku blogowym!). Spójrz na niektóre z postów na blogu tutaj:

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

Oto zrzut ekranu przykładowego pliku HTML wygenerowanego przez narzędzie:

http://bit-booster.com/graph.html (narzędzie)

Na podstawie skryptu Graphviz, który znalazłem w odpowiedzi na powiązane pytanie , zhakowałem skrypt ruby, który tworzy widok podsumowania repozytorium git. Pomija całą liniową historię i po prostu pokazuje „interesujące” zatwierdzenia, tj. Te z wieloma rodzicami, wieloma dziećmi lub wskazane przez gałąź lub znacznik. Oto fragment wykresu generowanego dla jquery :

git-big-picture i BranchMaster są podobnymi narzędziami, które próbują pokazać tylko strukturę wysokiego poziomu wykresu, wyświetlając jedynie powiązanie tagów, gałęzi, scaleń itp.

To pytanie ma kilka innych opcji.

Dodałem trzy polecenia niestandardowe: git tree, git streei git vtree. Przejrzę je w tej kolejności.

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

Za pomocą git streei git vtreeużywam bash, aby pomóc w formatowaniu.

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

EDYCJA: Działa z wersją git 1.9a. Wartość koloru „auto” najwyraźniej debiutuje w tym wydaniu. To miły dodatek, ponieważ nazwy oddziałów będą miały inny kolor. Ułatwia to na przykład rozróżnienie między oddziałami lokalnymi i zdalnymi.

Zależy jak wyglądali. Używam gitx, który tworzy takie zdjęcia:

Możesz porównać git log --graphvs gitk w 24-kierunkowym połączeniu ośmiornicy (pierwotnie z http://clojure-log.n01se.net/date/2008-12-24.html ):

Aby uzyskać bardziej szczegółowy tekst, spróbuj:

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

Możesz napisać alias w $ HOME / .gitconfig

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

Oto moje zdanie na ten temat:

Zrzut ekranu:

Stosowanie:

git hist - Pokaż historię bieżącego oddziału

git hist --all - Pokaż wykres wszystkich gałęzi (w tym pilotów)

git hist master devel - Pokaż związek między dwoma lub więcej oddziałami

git hist --branches - Pokaż wszystkie lokalne oddziały

Dodaj --topo-orderdo sortowania zatwierdza topologicznie, a nie według daty (domyślnie w tym aliasie)

Korzyści:

• Wygląda jak zwykły --decorate, więc z osobnymi kolorami dla różnych nazw gałęzi
• Dodaje adres e-mail osoby zatwierdzającej
• Dodaje datę względną i bezwzględną zatwierdzenia
• Sortuje zatwierdzenia według daty

Ustawiać:

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 : przeglądarka repozytoriów oparta na gtk, to nowe, ale ciekawe i przydatne
http://git.gnome.org/browse/gitg
Obecnie go używam

Chociaż czasami używam gitg , zawsze wracam do wiersza poleceń:

[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 

Jak widać, jest to prawie alias zapisujący naciśnięcie klawisza, oparty na:

• - kolor: przejrzysty wygląd
• --graph: wizualizuj rodziców
• - zamówienie-daty: najbardziej zrozumiałe spojrzenie na repozytorium
• - Udekoruj: kto jest kim
• --oneline: Wiele razy wszystko, co musisz wiedzieć o zatwierdzeniu
• --simplify-by-decoration: podstawowy na pierwszy rzut oka (tylko tagi, odpowiednie scalenia, gałęzie)
• --all: zapisywanie naciśnięć klawiszy ze wszystkimi aliasami z tą opcją i bez niej
• --data = względna (% ar): zrozumienie działania w repozytorium (czasami oddział ma niewiele zobowiązań w pobliżu mistrza, ale kilka miesięcy temu od niego)

Zobacz w najnowszej wersji git (1.8.5 i wyżej) możesz skorzystać z% C (auto) w dekorowaniu symbolu zastępczego% d

Stąd wszystko, czego potrzebujesz, to dobra znajomość gitrevisions do filtrowania wszystkiego, czego potrzebujesz (coś takiego jak master..develop, gdzie --simplify-scalenia może pomóc w długoterminowych oddziałach)

Mocą wiersza poleceń jest szybka konfiguracja oparta na twoich potrzebach (zrozum, że repo nie jest unikalną konfiguracją dziennika kluczy, więc czasami konieczne jest dodanie opcji --numstat, --raw lub --name-status. Tutaj git log a aliasy są szybkie, wydajne i (z czasem) najładniejszym wykresem, jaki można uzyskać. Co więcej, przy wyjściowym wyświetlaniu domyślnym przez pager (powiedz mniej) zawsze możesz szybko wyszukiwać wyniki wewnątrz. Nie jesteś przekonany? Zawsze możesz przeanalizować wynik z projektami takimi jak gitgraph

Bardzo nieznacznie poprawiając niesamowitą odpowiedź Slippa , możesz użyć jego aliasów, aby zarejestrować tylko jedną gałąź:

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

Pozostawiając --allto możesz teraz zrobić

git lgBranch1 <branch name>

lub nawet

git lgBranch1 --all

Sugeruję tig https://github.com/jonas/tig , znacznie lepsze narzędzie wiersza poleceń dla git.

Możesz użyć Homebrew, aby zainstalować TIG na MacOS:

$ brew install tig
$ tig

Mam ten git logalias, ~/.gitconfigaby wyświetlić historię wykresów:

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

Po wprowadzeniu tego, git lwypisze coś takiego:

W Git 2.12 + można nawet dostosować kolory linii wykresu za pomocą log.graphColorsopcji konfiguracji.

Jeśli chodzi o format dzienników, jest podobny --oneline, z dodaniem nazwiska autora (z poszanowaniem .mailmap) i względnej daty autora . Zauważ, że %C(auto)składnia, która mówi Gitowi, aby używał domyślnych kolorów dla skrótu zatwierdzenia itp., Jest obsługiwana w Git> = 1.8.3 .

Próbowałeś gitkczy gitk --all? Nie ma jednak funkcji print / save img as.

GitGraph

Generuje reprezentację PNG lub SVG historii zatwierdzeń Twojego repozytorium Git.

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

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

To moja końcowa odmiana, podobna do wielu odpowiedzi tutaj. Lubię dostosowywać przekazane flagi, lessaby zapobiec zawijaniu słów.

Ustawiłem na alias dla szybkiego dostępu, ponieważ polecenie jest nieco kłopotliwe.

Spróbuj ditaa . Może przekształcić dowolny diagram ASCII w obraz. Chociaż nie został zaprojektowany z myślą o gałęziach Git, byłem pod wrażeniem wyników.

Źródło (plik txt):

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

Komenda:

java -jar ditaa0_9.jar ascii-graph.txt

Wynik:

Obsługuje również kolory tła, linie przerywane, różne kształty i więcej. Zobacz przykłady .

Jeśli twoje repozytorium znajduje się na Gitlab, możesz użyć jego reprezentacji graficznej, ponieważ jest ona renderowana jako SVG w przeglądarce.

• Przejdź do widoku wykresu repozytorium, np. Https://gitlab.com/gitlab-org/gitter/webapp/network/develop

• Przewiń wykres w dół do dołu (leniwe ładunki się zgadzają!)

• Użyj inspektora przeglądarki, aby skopiować element SVG do nowego pliku

• Otwórz go w wybranym renderze, np. Inkscape

Nie wiem o bezpośrednim narzędziu, ale być może możesz zhakować skrypt, aby wyeksportować dane do formatu kropki i wyrenderować je za pomocą graphviz.

Funky graf Git commit jest jednym z pokazów biblioteki graficznej Raphaela .

Demo jest statyczne, ale pobranie kodu i zamiana ich danych statycznych na zestaw danych na żywo powinno być dość łatwe - myślę, że to tylko zatwierdzenie danych Git w formacie JSON.

Demo jest tutaj: http://dmitrybaranovskiy.github.io/raphael/github/impact.html

Ładnie i czysto tablitowy wynik gitowego wykresu dla muszli

z skrótami jak zwykle oprócz drzewa wykresów

lub w dodatkowej kolumnie

Edycja : Chcesz zacząć od razu bez czytania wyjaśnień? Użyj aliasu git, fragmentu skryptu lub kodu funkcji z sekcji EDYCJA 5 poniżej.

We wszystkich odpowiedziach na to pytanie żadna z dotychczas nie wydała czystych tablelowych wyników dla muszli. Najbliższa była odpowiedź z ewangelii, od której zacząłem.

Najważniejsze w moim podejściu jest zliczanie tylko znaków drzewa pokazanych użytkownikowi. Następnie wypełnij je osobistymi spacjami.

Oprócz git potrzebujesz tych narzędzi

• grep
• pasta
• printf
• sed
• seq
• tr
• toaleta

głównie na pokładzie z dowolną dystrybucją Linuksa.

Fragment kodu to

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

Do obliczenia potrzebnych białych znaków używamy

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

aby uzyskać wszystkie znaki (do 500 w wierszu) niż wybrać tylko znaki drzewa: * | / \ _ i białe znaki z

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

na koniec policz je i odejmij wynik od wybranej przez nas wartości długości, która w tym przykładzie wynosi 9.

Aby wygenerować obliczoną liczbę białych znaków, których używamy

  seq -s' ' $whitespaces

i skróć numery pozycji za pomocą

  tr -d '[:digit:]'

niż dodaj je na końcu naszej linii wykresu. Otóż ​​to!

Git ma dobrą opcję formatowania długości specyfikatorów wyjściowych już za pomocą składni '%><(amount_of_characters,truncate_option)', która dodaje białe spacje po lewej stronie>> lub prawej stronie <i może obcinać znaki od początku „ltrunc”, środkowego „mtrunc” lub końca „trunc”.

Jest ważne , że powyższe zastosowanie printf Cmd samo jest dla wartości długości odpowiadającej git kolumny.

Baw się, projektując własne, czysto wyglądające obrusy, zgodnie z własnymi potrzebami.

Dodatkowy:

Aby uzyskać odpowiednią wartość długości, możesz użyć następującego fragmentu kodu

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

i użyj $ max_chars jako właściwej wartości długości powyżej.

EDYCJA 1 : Właśnie zauważyłem, że znak podkreślenia jest również używany w drzewie git i odpowiednio edytuj powyższe fragmenty kodu. Jeśli brakuje innych znaków, zostaw komentarz.

EDYCJA 2 : Jeśli chcesz pozbyć się nawiasów wokół wpisów gałęzi i znaczników, po prostu użyj „% D” zamiast „% d” w poleceniu git, jak w EDIT 3.

EDYCJA 3 : Może opcja koloru „auto” jest najbardziej preferowana dla wpisów gałęzi i tagów?

Zmień tę część polecenia git (kolor 214 )

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

do auto

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

EDYCJA 4 : A może lubisz własną mieszankę kolorów dla tej części, fantazyjne wyjście z migającą głową?

Aby móc najpierw stylizować nagłówek, nazwy gałęzi i tagi, potrzebujemy opcji koloru „auto” w naszym poleceniu git, tak jak w EDIT 3.

Następnie możemy zastąpić znane wartości kolorów własnymi, dodając te 3 linie

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

tuż przed linią

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

w naszym fragmencie kodu. Wartości zastępcze dają kolory powyżej.

Na przykład wartość zastępcza dla head to

3;5;1;38;5;196

gdzie 3; oznacza kursywę, 5; dla migania i 1; 38; 5; 196 dla koloru. Aby uzyskać więcej informacji, zacznij tutaj. Uwaga: To zachowanie zależy od twojego ulubionego terminalu i dlatego może nie być przydatne.

ALE możesz wybrać dowolną preferowaną wartość koloru.

PRZEGLĄD wartości kolorów git i odpowiedników ANSI

Tutaj znajdziesz listę z opcją koloru / stylu git .

Jeśli potrzebujesz danych wyjściowych na konsoli w celu uzyskania dokładnych kolorów (powyższy obrazek jest pomniejszany o przepływ stosu), możesz uzyskać wynik za pomocą

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

w ścieżce projektu git, która korzysta z pierwszego zatwierdzenia z danych wyjściowych dziennika git.

EDYCJA 5 : Jak wspomniał członek „Andras Deak”, istnieje kilka sposobów wykorzystania tego kodu:

1) jako alias :

alias nie akceptuje parametrów, ale funkcja może , dlatego po prostu zdefiniuj w pliku .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" ###

   }

i wywołaj funkcję git_table (pochodzącą z tablelike) bezpośrednio pod ścieżką projektu git lub z dowolnego miejsca ze ścieżką projektu git jako pierwszym parametrem.

2) jako skrypt powłoki :

Używam go z opcją przekazania katalogu projektu git jako pierwszego parametru do niego lub, jeśli jest pusty, weź katalog roboczy jak normalne zachowanie. W całości mamy

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

Być może najwygodniejszym sposobem jest dodanie aliasu git w .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\");                                          \
                '"

Następnie wystarczy zadzwonić git tablypod dowolną ścieżkę projektu.

Git jest tak potężny, że możesz zmieniać głowę, tagi, ... bezpośrednio jak pokazano powyżej i wzięto stąd .

Inną wymyślną opcją jest wybranie preferowanych kolorów drzew

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

co daje szalenie wyglądające, ale zawsze tablelowe wyniki git log

Za dużo mrugania! Aby zademonstrować, co jest możliwe. Zbyt mało określonych kolorów prowadzi do powtórzeń kolorów.

Pełne odniesienie .gitconfig to tylko jedno kliknięcie.

PONOWNIE: Baw się, projektując własne, wyglądające na tablelki produkty odpowiadające Twoim potrzebom.

niektóre aliasy w ~ / .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'

W przypadku użytkowników OSX wziąłem przykład @gospes i nieznacznie zmodyfikowałem go dla gsed ( gnu-sedzainstalowany przez homebrew) i dostosowałem kolory (do pracy z czarnym tłem, nie jestem pewien, jak oryginalny przykład mógłby renderować to, co robi w przykład, ponieważ określa czarny tekst na terminalu z czarnym tłem).

[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

Kluczem dla OSX jest pierwsza instalacja gnu sed (która ma opcję -r). Najłatwiej jest to zrobić za pomocą homebrew, który nie zastąpi instalowanego przez system sed, ale zamiast tego instaluje gnu sed jako „gsed”. Mam nadzieję, że to pomoże @ SlippD.Thompson, który skomentował powyżej, że OSX nie działa.