Git Blame

Git Blame Overview

The blame command is an extensively used utility tool for configuring various options and troubleshooting. It is a high-end sophisticated and versatile tool for displaying the metadata that is attached to some specific line in a file. The blame commands help in grabbing contexts associated with the commit history in the files and examine it seamlessly. Additionally, it is also used to figure out what and where of the code present in your respective working directory.

Git blame comes integrated with the Git GUI. Certain version control systems offer continuous integration and external support for this command. The major focus is on the references associated with the collaborative discussions present around the commits. It pulls requests by including the IDE support and a wide community of support for developers to dynamically configure it.

The main function of the Git blame command is to annotate each line present in the given file and give a revision method of the last modified line. When the Git blame command is specified more than once, it simply restricts the annotations to the requested line. Hence, it should be carefully used.

What and How?

Take some points into consideration that are really helpful:

When you use this command, the origin of the lines are automatically following the entire file and the following lines are moved from one another that was once copied and pasted from some other files.

Git blames displays the report about the status of lines. Also, the report won't guarantee information about which lines have been deleted or kept. You may peek into diff or pickaxe command to look into that briefly.

Another point to take into consideration is that apart from enhancing the annotations in Git, the blame command supports the method of searching the history of your changed code snippets. It makes it easier for you to keep a track of the code snippet added to your file, moved, or copied in between. The mechanism works by continuously searching the text string in the file and then digging it more using the git diff command.

To demonstrate how Git blames command works, you will need to create a repository with some history or choose if it already exists. When you invoke the git-blame command, it will open a repository containing a README.md (markdown file) which may have few commits from different authors. The next step is to observe. Type the following command.

$ git blame README.md

Executing the above command will give you the output which is static and reflexive at the time of writing it. The output may look something like the timestamp along with the address of the file.

$ git blame README.md 82496ea3

 (kundan_pathak 2021-03-30 13:37:02 -0800 1)

The above output totally depends on the amount of the changes made. If you have made multiple changes while checking logs and then committing them, git blame command will take all of them into consideration and display the timestamp. The timestamp is not the period but it also shows the rows and columns modified while you made use of the blame command in a specific line.

More options

$ git blame -b

The above option is used for displaying blanks for boundary commits using SHA-1(Simple Hashing Algorithm). It can further be used to control and configure them.

$ git blame --root

The above command is used to treat commits associated with roots as boundaries. This can also be done using the blame.showRoot config option.

$ git blame --show-stats

The above command is used to display the statistical data in the output. It includes the following option:

 -L : used from <start> to <end>  // rolls out the range through traverse
 -L : used for <funcname>             // rolls out the function name
 $ git blame -l

The above option is used to show long ranges. They are disabled by default.

$ git blame -t

The above option is used to roll out the timestamp of your blamed files.

$ git blame -S <revs-file>

The above option is used to carry out revision of your files instead of calling them.

$ git blame --reverse <rev> .. <rev>

The above option is a complex command used to a walkover in the reverse method. It will display to you the last revision that existed in the line rather than the last line that appeared. It needs range to roll out the revisions from start to end in reverse order with HEAD.

$ git blame --first-parent

The above option is used to follow only the first parent associated with the merge commit. It is used to give out the information of when the particular branch was determined rather than displaying the overall history.

$ git blame -p

Or

$ git blame --porcelain

The above option is used to show the specific format that was designed and consumed for machine.

$ git blame --line-porcelain

It is yet another option like the previous command. It is used to shot the format for the first line but also for eachline and commits.

$ git blame --incremental

These options rolls out the format designed on the incremental method of machine consumption.

Summary

The Git blame command is used not only to rectify the contents present in your files line by line but is also used to examine the changes made to each line along with their timestamp. The format of the output produced by the blame command can also be formatted using the various options present in the cheat sheet of Git. It offers a superb experience when you want to keep a check of the workflows of your code snippets and re-discover the history of the file's contents. It is similar to the log command which gives the overall log history.