Git usage standard process

In team development, it is very important to follow a reasonable and clear Git usage process.

Otherwise, everyone submits a bunch of disorganized commits and the project quickly becomes difficult to coordinate and maintain.

Below is ThoughtBot's standard Git usage process. I learned a lot from it and recommend you to use Git in the same way.

Step 1: Create a new branch

First of all, every time you develop a new feature, you should create a separate branch (for this, you can refer to "Git Branch Management Strategy").

 # Get the main *** code
 $ git checkout master
 $ git pull 
 
 # Create a new development branch myfeature
 $ git checkout -b myfeature

Step 2: Submit the branch commit

After the branch is modified, you can submit the commit.

 $ git add --all
 $ git status
 $ git commit --verbose

The all parameter of the git add command means saving all changes (including new, modified, and deleted). Since Git 2.0, all is the default parameter of git add, so you can also use git add . instead.

The git status command is used to view changed files.

The verbose parameter of the git commit command will list the results of the diff.

Step 3: Write your commit message

When submitting a commit, you must give a complete and concise commit message. The following is a template.

 Present-tense summary under 50 characters 
 
 * More information about commit (under 72 characters).
 * More information about commit (under 72 characters). 
 
 http: //project.management-system.com/ticket/123  

The first line is a summary of no more than 50 words, followed by a blank line, listing the reason for the change, major changes, and issues that need attention. Finally, provide the corresponding URL (such as a bug ticket).

Step 4: Synchronize with the mainline

During the development of the branch, it is necessary to keep it synchronized with the trunk frequently.

 $ git fetch origin
 $ git rebase origin/master

Step 5: Merge commit

After the branch development is completed, there may be a lot of commits, but when merging it into the trunk, you often hope that there is only one (or at most two or three) commits, which is not only clear but also easy to manage.

So, how can we merge multiple commits? This requires the git rebase command.

 $ git rebase -i origin/master

The i parameter of the git rebase command stands for interactive. At this time, git will open an interactive interface to proceed to the next step.

The following example uses Tute Costa to explain how to merge commits.

 pick 07c5abd Introduce OpenPGP and teach basic usage
 pick de9b1eb Fix PostChecker::Post#urls
 pick 3e7ee36 Hey kids, stop all the highlighting
 pick fa20af3 git interactive rebase, squash, amend 
 
 # Rebase 8db7e8b..fa20af3 onto 8db7e8b
 #
 # Commands:
 # p, pick = use commit
 # r, reword = use commit, but edit the commit message
 # e, edit = use commit, but stop for amending
 # s, squash = use commit, but meld into previous commit
 # f, fixup = like "squash" , but discard this commit's log message
 # x, exec = run command (the rest of the line) using shell
 #
 # These lines can be re-ordered; they are executed from top to bottom.
 #
 # If you remove a line here THAT COMMIT WILL BE LOST.
 #
 # However, if you remove everything, the rebase will be aborted.
 #
 # Note that empty commits are commented out

The interactive interface above first lists the 4 latest commits of the current branch (the lower the newer). There is an operation command in front of each commit, the default is pick, which means that the commit line is selected and the rebase operation is to be performed.

Below the 4 commits are a bunch of comments listing the commands that can be used.

• pick: Normal selection
• reword: Select and modify the submission information;
• edit: If selected, the rebase will pause and allow you to modify the commit (see here)
• squash: If selected, the current commit will be merged with the previous commit
• fixup: Same as squash, but will not save the commit information of the current commit
• exec: execute other shell commands

Among the above 6 commands, squash and fixup can be used to merge commits. First, change the verb in front of the commits to be merged to squash (or s).

 pick 07c5abd Introduce OpenPGP and teach basic usage
 s de9b1eb Fix PostChecker::Post#urls
 s 3e7ee36 Hey kids, stop all the highlighting
 pick fa20af3 git interactive rebase, squash, amend

After this change, there will only be two commits left in the current branch. The commits on the second and third lines will be merged into the commit on the first line. The commit information will contain the commit information of these three commits at the same time.

 # This is a combination of 3 commits.
 # The first commit's message is:
 Introduce OpenPGP and teach basic usage 
 
 # This is the 2nd commit message:
 Fix PostChecker::Post#urls 
 
 # This is the 3rd commit message:
 Hey kids, stop all the highlighting

If the squash command in the third line is changed to the fixup command.

 pick 07c5abd Introduce OpenPGP and teach basic usage
 s de9b1eb Fix PostChecker::Post#urls
 f 3e7ee36 Hey kids, stop all the highlighting
 pick fa20af3 git interactive rebase, squash, amend

The running results are the same, and two commits will be generated. The commits on the second and third lines are merged into the commit on the first line. However, in the new commit information, the commit information on the third line will be commented out.

 # This is a combination of 3 commits.
 # The first commit's message is:
 Introduce OpenPGP and teach basic usage 
 
 # This is the 2nd commit message:
 Fix PostChecker::Post#urls 
 
 # This is the 3rd commit message:
 #Hey kids, stop all the highlighting

The squash and fixup commands can also be used as command line parameters to automatically merge commits.

 $ git commit --fixup
 $ git rebase -i --autosquash

Please refer to this article for its usage, which will not be explained here.

Step 6: Push to remote repository

After merging the commit, you can push the current branch to the remote repository.

 $ git push --force origin myfeature

The git push command needs to be added with the force parameter, because after rebasing, the branch history has changed and may not be compatible with the remote branch, so it may be necessary to force push (see here).

Step 7: Issue a Pull Request

After submitting to the remote repository, you can issue a Pull Request to the master branch, and then ask others to review the code and confirm that it can be merged into the master branch.