Note: Feel free to correct, expand, do anything which could make this better and clearer. ^_^

Help

How to get help with git commands

To get a list of most used commands:

git help

To open the Git manual:

man git

To see a summary of options for a specific command:

git COMMAND -h

To open the manual page for a specific command:

git help COMMAND

or

git COMMAND --help

or

man git-COMMAND

To exit code views: hit the 'q' key.

How to use auto-completion

Hit the Tab key as you type to get suggestions. This works with commands and options.

N.B. New Dreamhacks have this set up automatically: see the Pro Git book on how to set it up otherwise.

The Basics

To create a branch:

git branch BRANCH_NAME

To switch to a branch:

git checkout BRANCH_NAME

To create and switch to a branch at once:

git checkout -b BRANCH_NAME

To create and switch to a branch stemming from another branch:

git checkout -b BRANCH_NAME OTHER_BRANCH

To see unstaged code changes:

git diff

To move changes to the staging area:

git add

To commit changes:

git commit

To add and commit changes at once:

git commit -a

To push changes:

git push origin BRANCH_NAME

Staging Area Management

How to see staged changes

To see staged code changes:

git diff --cached

or

git diff --staged

To see staged file changes:

git status -s

How to stash your changes

Note: first make sure you're on the right branch using checkout.

To put them away:

git stash

To bring them back:

git stash pop

To see what's stashed on a branch:

git stash show

How to undo staged changes

To unstage a file:

git reset HEAD FILE_PATH

Important: the file is still modified. It's just no longer part of your current staging area.

To undo:

git checkout -- FILE_PATH

How to move and delete files

To move files:

git mv OLD_PATH NEW_PATH

To delete files:

git rm FILE_PATH

Commit Management

How to see committed changes

To see latest commits on local branches:

git branch -v

To see committed code changes (latest commit only):

git show

To see past commits:

git log

To see past commits one at a time:

git log -1

and so on.

To see commits for a certain file:

git whatchanged FILE

To see what you've done locally in the last 30 days:

git reflog

How to amend your last commit

Important: you can do this as long as nothing has been pushed.

To update a commit with some new changes:

git commit --amend

To do so and reuse your last commit message:

git commit --amend -C HEAD

How to undo committed changes

Important: you can do this as long as nothing has been pushed. Also make sure there's a commit to go back to before you do this or you'll end up in detached HEAD state, which is as bad as it sounds.

To reset everything to the previous commit:

git reset --hard

or:

git reset --hard HEAD~1

You can increment the number to go back to even earlier commits.

How to push commits to the release branch

First create a copy of the release branch:

git checkout -b release-X.X dreamwidth/release-X.X

X-X is the number given to the release on the GitHub repo branch. Make sure it matches.

Follow the usual steps: create a branch, switch to it, edit, add, commit, push.

Select 'compare and review' then click on 'edit' to select the release branch as your base branch (you'll see all changes merged into the release branch otherwise). Send the request when you're done reviewing.

How to squash several commits into one

If, for some reason, you'd like several commits to be just one, you can squash them. This is not reversible so proceed with caution.

Make sure everything is up-to-date.
Make sure you're on the correct bug branch using git checkout.
Load the interactive rebase interface using
```
git rebase -i develop
```
The interface will show you all the successive commits on this branch, from the oldest at the top to the most recent at the bottom.

From there you have several options:

If you want to be able to edit all commit messages or merge them in some fashion, edit the work 'pick' to the word 'squash' for the ones you want to squash into the previous commit. You'll be then shown all commit messages and you'll be able to edit them, comment the lines you want to hide, etc.
If you want to edit the commit message of your master commit but discard all the other ones, use 'reword' for your master commit then 'fixup' for the other ones.
If you want to keep your master message as-is and discard the rest, use 'pick' and 'fixup' instead.

Note that if you had already pushed some changes to GitHub, you will need to force a push to get it updated:

git push -f origin BRANCHNAME

Also, git ready has a nice guide to squashing commits using the interactive rebaser (git rebase -i).

The interactive rebaser can also do many other nifty and powerful things. You can change commit messages, edit past commits, reorder commits, or discard individual commits entirely.

How to move a commit from one branch to another

Important: don't do this if your new branch isn't empty or if what you have will conflict with the new additions.

Create the new branch if it doesn't exist already.

On the old branch, copy your commit hash using git reflog.

Switch to the new branch then use:

git cherry-pick HASH

How to add/commit only part of a file

There are times when you want to commit only some of the changes you've made to a file. Maybe you've fixed one thing, and are in the midst of fixing a second thing somewhere else in that file when you decide you want to commit the first change.

You don't have to back out the work you've done on the second fix in order to commit the first change by itself. Use the interactive option of git add:

# consider all changed files for addition 
git add -i 
# consider only the files specified 
git add -i FILE [FILE2 FILE3 ...]

You'll be shown the current staging status of the file(s), and how many lines in each of them are staged (added) or unstaged (not added yet).

   twilight:~/temp rick$ git add -i
              staged     unstaged path
     1:    unchanged        +9/-8 bar.pl
     2:    unchanged        +2/-1 foo.pl
     3:    unchanged        +2/-0 index.html
   
   *** Commands ***
     1: [s]tatus     2: [u]pdate     3: [r]evert     4: [a]dd untracked
     5: [p]atch      6: [d]iff       7: [q]uit       8: [h]elp
   What now>

There are a lot of commands, but you really only need very few of them. Too, there's help available in each menu -- you can enter ? at any prompt for help, in addition to any visible help options.

1: shows you the current staging status, just like when git add -i started.
2: stage (add) whole files
3: unstage (un-add) whole files
4: add a currently-untracked file
5: stage individual chunks in a file bit-by-bit
6: show the diff between what's been staged so far & the previous commit

Number 5 (patch) is the biggest winner of all these, and usually why you're running the command at all. Select 5 and you'll be presented with a menu like this one:

              staged     unstaged path
     1:    unchanged        +9/-8 [b]ar.pl
     2:    unchanged        +2/-1 [f]oo.pl
     3:    unchanged        +2/-0 [i]ndex.html
   Patch update>>

Pick the file or files you want to part-stage by entering their number(s), then hitting enter. When you're done picking files, hit enter once more at the empty Patch Update>> prompt. The program will show you every change in the files you've selected, one at a time, and ask you if you want to add it, eg:

   diff --git a/index.html b/index.html
   index 32870ee..416e0bd 100644
   --- a/index.html
   +++ b/index.html
   @@ -8,6 +8,7 @@
    
    
        <link rel="stylesheet" type="text/css" href="./css/base.css" />
   +    <link rel="stylesheet" type="text/css" href="./css/frontpage.css" />
        
        <title>Welcome!</title>
      </head>
   Stage this hunk [y/n/a/d/e/?]?

Hit y to add this change, n to not add it for now. There are many more options, like splitting a change in two or adding every change left in the file -- you can hit ? to see those.

When you're done, you're taken back to the main menu. If you're finished, hit 7 to quit. If you want, you can then review everything you've added by giving the command

git diff --cached

Branch Management

How to see branches

To check which local branch you're on (noted with an asterisk):

git branch

To see local and remote branches (including deleted ones):

git branch -a

To see branches on a graph: go to your profile page on github.com, click dw-free or dw-nonfree then on Network. Hit Shift and the right arrow to go to the most current part of the graph.

To see merged branches:

git branch --merged

To see unmerged branches:

git branch --no-merged

Note: you can also see merged and unmerged branches on GitHub. On your profile, click on the Repositories tab, select yours then click on Branches (and view merged branches).

To see where local branches stem off, which branch is also on GitHub and what is the latest commit on each branch and its abbreviated hash ref:

git log --all --abbrev-commit --decorate --oneline  --simplify-by-decoration

Note that git log has many options letting you do wonderful things which might help you better.

How to rename and delete branches

To rename a local branch:

git branch -m OLD_NAME NEW_NAME

Important: if you had already pushed some changes to GitHub, this will create a new identical branch there. You will need to delete the old one using the method described below.

To delete a local branch or a merged branch:

git branch -d BRANCH_NAME

Important: the merge will only be detected if you've updated your code. Otherwise, you'll get an error saying the branch isn't fully merged.

To delete an unmerged branch:

git branch -D BRANCH_NAME

To delete a branch on GitHub:

git push origin :BRANCH_NAME

Note: you can also do this directly on GitHub once your branch has been merged into develop. Just click on the pull request (from the Activity list on your profile for example), scroll down and it'll ask if you want to delete the branch.

How to update your branch

Important: don't do this if your branch isn't empty or if what you have will conflict with the new additions.

To update your branch so it has all the new code which has been added to develop since you created it:

git checkout BRANCH_NAME
git pull --rebase --ff-only dreamwidth develop

You can also do this with other branches such as the current release branch by checking out the release branch then pulling from release-X.X instead of develop.

If you had already pushed your branch to GitHub, you will need to force push your changes:

git push -f origin BRANCH_NAME

How to change where your bug branch stems off

Important: depending on where you put it what you have may conflict with what's already there. You'll then have to resolve conflicts manually or abort the rebase.

To change the point of origin of a branch:

git rebase --onto NEW_BASE OLD_BASE BRANCH_NAME

For example, if you want to move something from develop to a release branch you'd use:

git rebase --onto release-x.x develop bug/feature

Git Configuration

How to create custom keywords for your most-used commands

Tired of (mis)typing the same things over and over? You can create keywords for them. Open .gitconfig in your root folder. Add this at the bottom and edit as desired:

[alias]
	KEYWORD1= COMMAND1
	KEYWORD2= COMMAND2

Warning! Make sure the keyword you're using isn't already a git command.

You can then use your keyword instead of typing the full command (e.g. git c instead of git checkout -b).

How to configure git

See this article for some of the most useful settings.

How to create a default commit message

Easy peasy! In your root folder, create a file called .gitmessage.txt with whatever default message you wanna use then edit .gitconfig to use it:

git config --global commit.template $HOME/.gitmessage.txt

How to automatically insert the bug number into your commit message

Important! This will only work if 'bug XXX' where XXX is the bug number is in your branch name. This is meant as a way not to have to type it or paste it *again* in your commit messages.

Go to ~/dw/.git/hooks/ and create a filed called prepare-commit-msg. Paste this gist made by the brilliant fu and save. Finally make it executable by running:

chmod u+x ~/dw/.git/hooks/prepare-commit-msg

N.B. This can be used in conjunction with the default commit message mentioned in the previous section.

Git How To

Contents