Git: entdecken Sie verpflichtet, die jemals berührt eine Reihe von Linien

Ich denke, das ist, was Sie wollen:

git rev-list HEAD -- foo.rb | ( 
    while read rev; do
        git blame -l -L 1000,+5 $rev -- foo.rb | cut -d ' ' -f 1
    done;
) | awk '{ if (!h[$0]) { print $0; h[$0]=1 } }'

Werde, dass die Ausgabe der Revisionsnummer für jeden commit, der hat bei einer Bearbeitung der Zeilen, die Sie gewählt haben.

Hier sind die Schritte:

1. Den ersten Teil git rev-list HEAD -- foo.rb gibt alle Revisionen, in denen die ausgewählte Datei wird bearbeitet.

2. Jede dieser Revisionen geht dann in den zweiten Teil, die nimmt jeden und bringt es in die git blame -l -L 1000,+5 $rev -- foo.rb | cut -d ' ' -f 1. Dies ist ein zwei-Teil-Befehl.

   1. git blame -l -L 1000,+5 $rev -- foo.rb Ausgänge die Schuld für die gewählten Linien. Durch die Fütterung von es die revision-Nummer, sagen wir es anfangen Begehen und gehen von dort aus, anstatt an der Spitze.
   2. Da die Schuld gibt eine Reihe von info, die wir nicht brauchen, cut -d ' ' -f 1 gibt uns die erste Spalte (die revision) von der Schuld-Ausgang.
3. awk '{ if (!h[$0]) { print $0; h[$0]=1 } }' nimmt nicht-benachbarte doppelte Linien unter Beibehaltung der Reihenfolge, wie Sie erschienen. Sehen http://jeetworks.org/node/94 für weitere Informationen zu diesem Befehl.

Könnte man hinzufügen, einen letzten Schritt zu schöneren Ausgabe. Rohr alles in xargs -L 1 git log --oneline -1 und erhalten die entsprechende commit-Nachricht, um die Liste der Revisionen. Ich hatte ein sonderbares Problem mit diesem letzten Schritt, wo ich hatte, zu halten, drücken weiter alle paar Revisionen ausgegeben. Ich bin mir nicht sicher, warum das war, das ist, warum ich nicht in meiner Lösung.

Ich mochte dieses puzzle, es hat seine Feinheiten. Quelle dieser Datei sagen init foo.rb 1000,1005 und Folgen Sie den Anweisungen. Wenn du fertig bist, die Datei @changes wird die korrekte Liste von commits, die in der topologischen Ordnung und @blames haben die eigentliche Schuld Ausgabe von jedem.

Dies ist dramatisch komplexer als die akzeptierte Lösung oben. Es erzeugt eine Ausgabe, die manchmal nützlicher sein, und schwer zu reproduzieren, und es hat Spaß gemacht zu Programmieren.

Das problem mit der track-line-Nummernkreise automatisch beim treten rückwärts durch die Geschichte ist, wenn eine änderung Brocken überquert line-nummeriert-Bereich Grenzen, man kann nicht automatisch ermitteln, wo in diesem Stück die neue range-Begrenzung muss sein, und Sie werden entweder zu haben, um eine große Reichweite für große Ergänzungen, und so sammeln sich (manchmal viele) irrelevante änderungen, oder legen Sie Sie in den manuellen Modus, um sicherzustellen, dass es richtig (was natürlich bekommt Sie gleich wieder hier), oder akzeptieren, extreme lossage mal an.

Wenn Sie möchten, dass Ihre Ausgabe, um genau zu sein, verwenden Sie die obige Antwort mit vertrauenswürdigen regex reicht, wie `/^type-Funktion(/,/^}/', oder diese, die ist nicht schlecht, ein paar Sekunden pro Schritt zurück in der Zeit.

Im Austausch für die zusätzliche Komplexität, es tut produziert der Trefferliste in topologischer Reihenfolge und es ist zumindest (ziemlich erfolgreich) versuchen, zu lindern die Schmerzen bei jedem Schritt. Es läuft niemals einer redundanten Schuld, zum Beispiel, und aktualisieren-reicht macht das einstellen von Zeilen-Nummern einfacher. Und natürlich gibt es auch auf die Zuverlässigkeit haben, um individuell Augapfel der Kerle... 😛

Diese laufen auf full auto, sagen { init foo.rb /^class foo/,/^end/; auto; } 2>&-

 ### functions here create random @-prefix files in the current directory ###
#
# git blame history for a range, finding every change to that range
# throughout the available history.  It's somewhat, ahh, "intended for
# customization", is that enough of a warning?  It works as advertised
# but drops @-prefix temporary files in your current directory and
# defines new commands
#
# Source this file in a subshell, it defines functions for your use.
# If you have @-prefix files you care about, change all @ in this file
# to something you don't have and source it again.
#
#    init path/to/file [<start>,<end>]  # range optional
#    update-ranges           # check range boundaries for the next step
#    cycle [<start>,<end>]   # range unchanged if not supplied
#    prettyblame             # pretty colors, 
#       blue="child commit doesn't have this line"
#       green="parent commit doesn't have this line"
#           brown=both
#    shhh # silence the pre-cycle blurb
#
# For regex ranges, you can _usually_ source this file and say `init
# path/to/file /startpattern/,/endpattern/` and then cycle until it says 0
# commits remain in the checklist
#
# for line-number ranges, or regex ranges you think might be unworthy, you
# need to check and possibly update the range before each cycle.  File
# @next is the next blame start-point revision text; and command
# update-ranges will bring up vim with the current range V-selected.  If
# that looks good, `@M` is set up to quit even while selecting, so `@M` and
# cycle.  If it doesn't look good, 'o' and the arrow keys will make getting
# good line numbers easy, or you can find better regex's.  Either way, `@M`
# out and say `cycle <start>,<end>` to update the ranges.

init () { 
    file=$1;
    range="$2"
    rm -f @changes
    git rev-list --topo-order HEAD -- "$file" \
    | tee @checklist \
    | cat -n | sort -k2 > @sequence
    git blame "-ln${range:+L$range}" -- "$file" > @latest || echo >@checklist
    check-cycle
    cp @latest @blames
}

update-latest-checklist() {
    # update $latest with the latest sha that actually touched our range,
    # and delete that and everything later than that from the checklist.
    latest=$(
        sed s,^^,, @latest \
        | sort -uk1,1 \
        | join -1 2 -o1.1,1.2 @sequence - \
        | sort -unk1,1 \
        | sed 1q \
        | cut -d" " -f2
    )
    sed -i 1,/^$latest/d @checklist
}
shhh () { shhh=1; }

check-cycle () {
    update-latest-checklist
    sed -n q1 @checklist || git log $latest~..$latest --format=%H\ %s | tee -a @changes
    next=`sed 1q @checklist`
    git cat-file -p `git rev-parse $next:"$file"` > @next
    test -z "$shh$shhh$shhhh" && {
        echo "A blame from the (next-)most recent alteration (id `git rev-parse --short $latest`) to '$file'"
        echo is in file @latest, save its contents where you like
        echo 
        echo you will need to look in file @next to determine the correct next range,
        echo and say '`cycle its-start-line,its-end-line`' to continue
        echo the "update-ranges" function starts you out with the range selected
    } >&2
    ncommits=`wc -l @checklist | cut -d\  -f1`
    echo  $ncommits commits remain in the checklist >&2
    return $((ncommits==0))
}

update-ranges () {
    start="${range%,*}"
    end="${range#*,}"
    case "$start" in
    */*)    startcmd="1G$start"$'\n' ;;
    *)      startcmd="${start}G" ;;
    esac
    case "$end" in
    */*)    endcmd="$end"$'\n' ;;
    [0-9]*) endcmd="${end}G" ;;
    +[0-9]*) endcmd="${end}j" ;;
    *) endcmd="echohl Search|echo "can\'t" get to '${end}'\"|echohl None" ;;
    esac
    vim -c 'set buftype=nofile|let @m=":|q'$'\n"' -c "norm!${startcmd}V${endcmd}z.o" @next
}

cycle () {
    sed -n q1 @checklist && { echo "No more commits to check"; return 1; }
    range="${1:-$range}"
    git blame "-ln${range:+L$range}" $next -- "$file" >@latest || echo >@checklist
    echo >>@blames
    cat @latest >>@blames
    check-cycle
}

auto () {
    while cycle; do true; done
}

prettyblames () {
cat >@pretty <<-\EOD
BEGIN {
    RS=""
    colors[0]="\033[0;30m"
    colors[1]="\033[0;34m"
    colors[2]="\033[0;32m"
    colors[3]="\033[0;33m"
    getline commits < "@changes"
    split(commits,commit,/\n/)
}
NR!=1 { print "" }
{
    thiscommit=gensub(/.*/,"",1,commit[NR])
    printf "%s\n","\033[0;31m"commit[NR]"\033[0m"
    split($0,line,/\n/)
    for ( n=1; n<=length(line); ++n ) {
        color=0
        split(line[n],key,/[1-9][0-9]*)/)
        if ( NR!=1 && !seen[key[1]] ) color+=1
        seen[key[1]]=1;
        linecommit = gensub(/.*/,"",1,line[n])
        if (linecommit==thiscommit) color+=2
        printf "%s%s\033[0m\n",colors[color],line[n]
    }
}
EOD
awk -f @pretty @blames | less -R
}

Ein paar Gedanken..

Diese klingt ähnlich dieser Beitrag, und es sieht aus wie Sie vielleicht in der Nähe mit so etwas wie dies:

git blame -L '/variable_name *= */',+1

So lange, wie Sie wissen, die definition zu Spiel gegen (für den regex).

Gibt es einen thread die Diskussion hier, über die Verwendung tig und git gui (die anscheinend könnte dies Griff). Ich habe nicht versucht, diese selbst noch, also kann es nicht überprüfen (ich werde geben dieses ein versuchen Sie es später).