Colpa della colpa - commetti precedenti?

È possibile vedere chi ha modificato una riga specifica prima del commit segnalato da git blame, come una cronologia di commit per una determinata riga?

Ad esempio, eseguo quanto segue (sul superbo uncrustifyprogetto):

$ git blame -L10,+1 src/options.cpp
^fe25b6d (Ben Gardner 2009-10-17 13:13:55 -0500 10) #include "prototypes.h"

Come posso sapere chi ha modificato quella riga prima del commit fe25b6d? E chi l'ha modificato prima di quel commit?

git blame -L 10,+1 fe25b6d^ -- src/options.cpp

È possibile specificare una revisione per git blame a cui guardare indietro a partire da (anziché il valore predefinito di HEAD); fe25b6d^è il genitore di fe25b6d.

Puoi usare git log -L per visualizzare l'evoluzione di un intervallo di linee.

Per esempio :

git log -L 15,23:filename.txt

significa "traccia l'evoluzione delle righe da 15 a 23 nel file denominato nomefile.txt".

La risposta di Amber è corretta ma l'ho trovata poco chiara; La sintassi è:

git blame {commit_id} -- {path/to/file}

Nota: --viene utilizzato per separare l'albero-ish sha1 dai relativi percorsi di file. ¹

Per esempio:

git blame master -- index.html

Riconoscimento completo ad Amber per aver saputo tutto! :)

Potresti voler dare un'occhiata:

git gui blame <filename>

Ti dà una bella visualizzazione grafica di cambiamenti come "git blame" ma con link cliccabili per riga, per passare ai commit precedenti. Passa il mouse sopra i collegamenti per visualizzare un popup con i dettagli del commit. Non i miei crediti ... l'ho trovato qui:

http://zsoltfabok.com/blog/2012/02/git-blame-line-history/

git guiè un'interfaccia grafica Tcl / Tc per git. Senza altri parametri avvia un'app grafica piuttosto semplice ma utile per eseguire il commit di file, hunk o anche singole righe e altri comandi simili come modifica, ripristina, push ... Fa parte della suite git stock. Su Windows è incluso nel programma di installazione. Su debian - non conosco altri sistemi * nix - deve essere installato separatamente:

apt-get install git-gui

Dai documenti:

https://git-scm.com/docs/git-gui

DESCRIZIONE

Un'interfaccia utente grafica basata su Tcl / Tk per Git. git gui si concentra sul consentire agli utenti di apportare modifiche al loro repository effettuando nuovi commit, modificando quelli esistenti, creando filiali, eseguendo fusioni locali e recuperando / spingendo in repository remoti.

A differenza di gitk, git gui si concentra sulla generazione del commit e sull'annotazione di singoli file e non mostra la cronologia del progetto. Fornisce tuttavia azioni di menu per avviare una sessione gitk dall'interno di git gui.

git gui è noto per funzionare su tutti i più diffusi sistemi UNIX, Mac OS X e Windows (sia con Cygwin che MSYS). Nella misura del possibile vengono seguite le linee guida specifiche dell'interfaccia utente del SO, rendendo git gui un'interfaccia abbastanza nativa per gli utenti.

COMANDI

colpa

Avvia un visualizzatore di colpe sul file specificato nella versione specificata (o directory di lavoro se non specificato).

del browser

Avviare un browser ad albero che mostra tutti i file nel commit specificato. I file selezionati tramite il browser vengono aperti nel visualizzatore di colpa.

citool

Avvia git gui e disponi di effettuare esattamente un commit prima di uscire e tornare alla shell. L'interfaccia è limitata a impegnare solo azioni, riducendo leggermente il tempo di avvio dell'applicazione e semplificando la barra dei menu.

versione

Visualizza la versione attualmente in esecuzione di git gui.

Basandosi sulla risposta precedente, questo bash one-liner dovrebbe darti quello che stai cercando. Visualizza la cronologia delle colpe git per una particolare riga di un determinato file, attraverso le ultime 5 revisioni:

LINE=10 FILE=src/options.cpp REVS=5; for commit in $(git rev-list -n $REVS HEAD $FILE); do git blame -n -L$LINE,+1 $commit -- $FILE; done

Nell'output di questo comando, è possibile che venga visualizzato il contenuto della riga o il numero di riga visualizzato potrebbe persino cambiare, per un determinato commit.

Questo spesso indica che la linea è stata aggiunta per la prima volta, dopo quel particolare commit. Potrebbe anche indicare che la linea è stata spostata da un'altra parte del file.

C'è anche recursive-blame. Può essere installato con

npm install -g recursive-blame

Una soluzione davvero unica per questo problema sta usando git log:

git log -p -M --follow --stat - path / to / your / file

Come spiegato da Andre qui

Se si utilizza Idea ID JetBrains (e derivati) è possibile selezionare più righe, fare clic con il tasto destro del mouse sul menu di scelta rapida, quindi Git -> Mostra cronologia per la selezione. Vedrai un elenco di commit che interessavano le linee selezionate:

A partire da Git 2.23 puoi usare git blame --ignore-rev

Per l'esempio fornito nella domanda questo sarebbe:

git blame -L10,+1 src/options.cpp --ignore-rev fe25b6d

(tuttavia è una domanda trabocchetto perché fe25b6d è la prima revisione del file!)

Basandosi sulla risposta di Will Shepard, il suo output includerà righe duplicate per commit in cui non vi sono state modifiche, quindi è possibile filtrarle come segue (utilizzando questa risposta )

LINE=1 FILE=a; for commit in $(git rev-list HEAD $FILE); do git blame -n -L$LINE,+1 $commit -- $FILE; done | sed '$!N; /^\(.*\)\n\1$/!P; D'

Nota che ho rimosso l'argomento REVS e questo risale al commit root. Ciò è dovuto all'osservazione di Max Nanasy sopra.

Basandomi sulla risposta di DavidN e voglio seguire il file rinominato:

LINE=8 FILE=Info.plist; for commit in $(git log --format='%h%%' --name-only --follow -- $FILE | xargs echo | perl -pe 's/\%\s/,/g'); do hash=$(echo $commit | cut -f1 -d ','); fileMayRenamed=$(echo $commit | cut -f2 -d ','); git blame -n -L$LINE,+1 $hash -- $fileMayRenamed; done | sed '$!N; /^\(.*\)\n\1$/!P; D'

ref: mostra bene la cronologia dei nomi dei file nel log git

Uso questo piccolo script bash per guardare una storia di colpa.

Primo parametro: file da guardare

Parametri successivi: passato a git blame

#!/bin/bash
f=$1
shift
{ git log --pretty=format:%H -- "$f"; echo; } | {
  while read hash; do
    echo "--- $hash"
    git blame $@ $hash -- "$f" | sed 's/^/  /'
  done
}

Puoi fornire parametri di colpa come -L 70, + 10 ma è meglio usare la ricerca regex di git blame perché i numeri di riga in genere "cambiano" nel tempo.

Costruire sulla stangls 's risposta , ho messo questo script sul mio cammino (anche su Windows) come git-bh:

Ciò mi consente di cercare tutti i commit in cui è stata coinvolta una parola:

git bh path/to/myfile myWord

script:

#!/bin/bash
f=$1
shift
csha=""
{ git log --pretty=format:%H -- "$f"; echo; } | {
  while read hash; do
    res=$(git blame -L"/$1/",+1 $hash -- "$f" 2>/dev/null | sed 's/^/  /')
    sha=${res%% (*}
    if [[ "${res}" != "" && "${csha}" != "${sha}" ]]; then
      echo "--- ${hash}"
      echo "${res}"
      csha="${sha}"
    fi
  done
}