# Is there any efficient way to track history of a piece of code?

7 messages from 2014-05-08 to 2014-05-09. Participants: Jianyu Zhan, Jeff King, David Kastrup, Chris Packham, Junio C Hamano, David Lang.
Thread: https://gitlist.dev/t/36606

## Jianyu Zhan, 2014-05-08 06:54

Subject: Is there any efficient way to track history of a piece of code?
Message-ID: <CAHz2CGW4rRWzGMPxM1XsoYvrwrrddrxAr+AKAi5SdMx+3rBjNg@mail.gmail.com>
URL: https://gitlist.dev/e/CAHz2CGW4rRWzGMPxM1XsoYvrwrrddrxAr%2BAKAi5SdMx%2B3rBjNg%40mail.gmail.com

```
Usually, a trivial change(like coding style fix) may bury a
original change of the code, and thus git blame is of less
help. And to address this situation, I have to do like this:

   git blame -s REF^ <file-in-question> > temp

to dig into the history recursively by hand, to find out
the original change.

Here, REF is commit-id that git blame reports.

git log -L is a good alternative option, but sometimes it seems
too cubersome, as I care only one line of code.

Is there any current solution or suggestion?

Thanks,
Jianyu Zhan

```

## Jeff King, 2014-05-08 07:00

Subject: Re: Is there any efficient way to track history of a piece of code?
Message-ID: <20140508070051.GA4532@sigill.intra.peff.net>
URL: https://gitlist.dev/e/20140508070051.GA4532%40sigill.intra.peff.net
In-Reply-To: <CAHz2CGW4rRWzGMPxM1XsoYvrwrrddrxAr+AKAi5SdMx+3rBjNg@mail.gmail.com>

```
On Thu, May 08, 2014 at 02:54:56PM +0800, Jianyu Zhan wrote:

> Usually, a trivial change(like coding style fix) may bury a
> original change of the code, and thus git blame is of less
> help. And to address this situation, I have to do like this:
> 
>    git blame -s REF^ <file-in-question> > temp
> 
> to dig into the history recursively by hand, to find out
> the original change.
> 
> Here, REF is commit-id that git blame reports.
> 
> git log -L is a good alternative option, but sometimes it seems
> too cubersome, as I care only one line of code.
> 
> Is there any current solution or suggestion?

Try "tig blame"[1]; from the blame view, the "," command will restart
the blame at REF^ automatically.  If you don't mind a more graphical
interface, I think "git gui blame" can also reblame from the parent from
the right-click context menu.

-Peff

[1] http://jonas.nitro.dk/tig/

```

## David Kastrup, 2014-05-08 07:06

Subject: Re: Is there any efficient way to track history of a piece of code?
Message-ID: <87bnv8rbp8.fsf@fencepost.gnu.org>
URL: https://gitlist.dev/e/87bnv8rbp8.fsf%40fencepost.gnu.org
In-Reply-To: <CAHz2CGW4rRWzGMPxM1XsoYvrwrrddrxAr+AKAi5SdMx+3rBjNg@mail.gmail.com>

```
Jianyu Zhan <nasa4836@gmail.com> writes:

> Usually, a trivial change(like coding style fix) may bury a
> original change of the code, and thus git blame is of less
> help. And to address this situation, I have to do like this:
>
>    git blame -s REF^ <file-in-question> > temp
>
> to dig into the history recursively by hand, to find out
> the original change.
>
> Here, REF is commit-id that git blame reports.
>
> git log -L is a good alternative option, but sometimes it seems
> too cubersome, as I care only one line of code.
>
> Is there any current solution or suggestion?

git blame -w

might help with a number of "coding style fixes".

-- 
David Kastrup

```

## Jianyu Zhan, 2014-05-08 07:32

Subject: Re: Is there any efficient way to track history of a piece of code?
Message-ID: <CAHz2CGV6==abb0SrXOyqwumxEVLFnTtqe1Z4j2A7XcvJNuoAHw@mail.gmail.com>
URL: https://gitlist.dev/e/CAHz2CGV6%3D%3Dabb0SrXOyqwumxEVLFnTtqe1Z4j2A7XcvJNuoAHw%40mail.gmail.com
In-Reply-To: <20140508070051.GA4532@sigill.intra.peff.net>

```
On Thu, May 8, 2014 at 3:00 PM, Jeff King <peff@peff.net> wrote:
> Try "tig blame"[1]; from the blame view, the "," command will restart
> the blame at REF^ automatically.  If you don't mind a more graphical
> interface, I think "git gui blame" can also reblame from the parent from
> the right-click context menu.

Thanks! It helps!

Hmm, but you know, we are cli people so we met git ;-)

My by-hand recursive digging history works for me and I've consider automate
this but failed since the pattern match to find the correct line of
code in each recursion
is a big problem.

The root cause of this problem maybe that git is not semantic-aware. It if is,
then we could easily weed out the trivial-change or grammatical-change
in git blame.

Here a structural program comparison tool may be a direction.
http://yinwang0.wordpress.com/2012/01/03/ydiff/

That being said, storing abstract syntax tree, instead of raw object in git.
But that goes too far...

Thanks,
Jianyu Zhan

```

## Chris Packham, 2014-05-08 07:35

Subject: Re: Is there any efficient way to track history of a piece of code?
Message-ID: <536B33D5.7090301@gmail.com>
URL: https://gitlist.dev/e/536B33D5.7090301%40gmail.com
In-Reply-To: <CAHz2CGW4rRWzGMPxM1XsoYvrwrrddrxAr+AKAi5SdMx+3rBjNg@mail.gmail.com>

```
On 08/05/14 18:54, Jianyu Zhan wrote:
> Usually, a trivial change(like coding style fix) may bury a
> original change of the code, and thus git blame is of less
> help. And to address this situation, I have to do like this:
> 
>    git blame -s REF^ <file-in-question> > temp
> 
> to dig into the history recursively by hand, to find out
> the original change.
> 
> Here, REF is commit-id that git blame reports.
> 
> git log -L is a good alternative option, but sometimes it seems
> too cubersome, as I care only one line of code.
> 
> Is there any current solution or suggestion?
> 

I use "git gui blame" for this all the time at $dayjob. If there aren't
too many of these code clean ups then the eclipse git integration is
also handy for this but it will suffer from the same issues as git blame.

```

## Junio C Hamano, 2014-05-08 18:34

Subject: Re: Is there any efficient way to track history of a piece of code?
Message-ID: <xmqq1tw43yrx.fsf@gitster.dls.corp.google.com>
URL: https://gitlist.dev/e/xmqq1tw43yrx.fsf%40gitster.dls.corp.google.com
In-Reply-To: <CAHz2CGV6==abb0SrXOyqwumxEVLFnTtqe1Z4j2A7XcvJNuoAHw@mail.gmail.com>

```
Jianyu Zhan <nasa4836@gmail.com> writes:

> On Thu, May 8, 2014 at 3:00 PM, Jeff King <peff@peff.net> wrote:
>> Try "tig blame"[1]; from the blame view, the "," command will restart
>> the blame at REF^ automatically.  If you don't mind a more graphical
>> interface, I think "git gui blame" can also reblame from the parent from
>> the right-click context menu.
>
> Thanks! It helps!
>
> Hmm, but you know, we are cli people so we met git ;-)
>
> My by-hand recursive digging history works for me and I've consider automate
> this but failed since the pattern match to find the correct line of
> code in each recursion
> is a big problem.

Yes, by definition, there is no corresponding line in a version
behind the version shown in the blame output, so there needs some
heuristics, such as "assume the same line range", "find the
beginning and the end of the function definition that contains that
line", etc.

```

## David Lang, 2014-05-09 06:56

Subject: Re: Is there any efficient way to track history of a piece of code?
Message-ID: <alpine.DEB.2.02.1405082354100.17457@nftneq.ynat.uz>
URL: https://gitlist.dev/e/alpine.DEB.2.02.1405082354100.17457%40nftneq.ynat.uz
In-Reply-To: <CAHz2CGV6==abb0SrXOyqwumxEVLFnTtqe1Z4j2A7XcvJNuoAHw@mail.gmail.com>

```
On Thu, 8 May 2014, Jianyu Zhan wrote:

> That being said, storing abstract syntax tree, instead of raw object in git.
> But that goes too far...

well, there are the clean/smudge filters, you can have it run everything through 
a prettyprinter as it's checked in.

with a little effort, you could do something along the lines of git filterbranch 
that could create a clone of a repo with all commits cleaned up.

David Lang

```