Git and Git Flow

Git Cheat Sheet

Index

• Set Up
• Configuration Files
• Create
• Local Changes
• Search
• Commit History
• Branches & Tags
• Update & Publish
• Merge & Rebase
• Undo
• Git Flow

Setup

Show current configuration:

$ git config --list

Show repository configuration:

$ git config --local --list

Show global configuration:

$ git config --global --list

Show system configuration:

$ git config --system --list

Set a name that is identifiable for credit when review version history:

$ git config --global user.name “[firstname lastname]”

Set an email address that will be associated with each history marker:

$ git config --global user.email “[valid-email]”

Set automatic command line coloring for Git for easy reviewing:

$ git config --global color.ui auto

Set global editor for commit

$ git config --global core.editor vi

Configuration Files

Repository specific configuration file [–local]:

/.git/config

User-specific configuration file [–global]:

~/.gitconfig

System-wide configuration file [–system]:

/etc/gitconfig

Create

Clone an existing repository:

There are two ways:

Via SSH

$ git clone ssh://user@domain.com/repo.git

Via HTTP

$ git clone http://domain.com/user/repo.git

Create a new local repository in the current directory:

$ git init

Create a new local repository in a specific directory:

$ git init 

Local Changes

Changes in working directory:

$ git status

Changes to tracked files:

$ git diff

See changes/difference of a specific file:

$ git diff 

Add all current changes to the next commit:

$ git add .

Add some changes in to the next commit:

$ git add -p 

Add only the mentioned files to the next commit:

$ git add  

Commit all local changes in tracked files:

$ git commit -a

Commit previously staged changes:

$ git commit

Commit with message:

$ git commit -m 'message here'

Commit skipping the staging area and adding message:

$ git commit -am 'message here'

Commit to some previous date:

$ git commit --date="`date --date='n day ago'`" -am ""

Change last commit:

Don’t amend published commits!

$ git commit -a --amend

Amend with last commit but use the previous commit log message

Don’t amend published commits!

$ git commit --amend --no-edit

Change committer date of last commit:

GIT_COMMITTER_DATE="date" git commit --amend

Change Author date of last commit:

$ git commit --amend --date="date"

Move uncommitted changes from current branch to some other branch:

$ git stash
$ git checkout branch2
$ git stash pop

Restore stashed changes back to current branch:

$ git stash apply

Restore particular stash back to current branch:

• {stash_number} can be obtained from git stash list

$ git stash apply stash@{stash_number}

Remove the last set of stashed changes:

$ git stash drop

Search

A text search on all files in the directory:

$ git grep "Hello"

In any version of a text search:

$ git grep "Hello" v2.5

Show commits that introduced a specific keyword

$ git log -S 'keyword'

Show commits that introduced a specific keyword (using a regular expression)

$ git log -S 'keyword' --pickaxe-regex

Commit History

Show all commits, starting with newest (it’ll show the hash, author information, date of commit and title of the commit):

$ git log

Show all the commits(it’ll show just the commit hash and the commit message):

$ git log --oneline

Show all commits of a specific user:

$ git log --author="username"

Show changes over time for a specific file:

$ git log -p 

Display commits that are present only in remote/branch in right side

$ git log --oneline .. --left-right

Who changed, what and when in :

$ git blame 

Show Reference log:

$ git reflog show

Delete Reference log:

$ git reflog delete

Move / Rename

Rename a file:

Rename Index.txt to Index.html

$ git mv Index.txt Index.html

Branches & Tags

List all local branches:

$ git branch

List local/remote branches

$ git branch -a

List all remote branches:

$ git branch -r

Switch HEAD branch:

$ git checkout 

Checkout single file from different branch

$ git checkout  -- 

Create and switch new branch:

$ git checkout -b 

Switch to the previous branch, without saying the name explicitly:

$ git checkout -

Create a new branch from an exiting branch and switch to new branch:

$ git checkout -b  

Checkout and create a new branch from existing commit

$ git checkout  -b 

Create a new branch based on your current HEAD:

$ git branch 

Create a new tracking branch based on a remote branch:

$ git branch --track  

Delete a local branch:

$ git branch -d 

Rename current branch to new branch name

$ git branch -m 

Force delete a local branch:

You will lose unmerged changes!

$ git branch -D 

Mark HEAD with a tag:

$ git tag 

Mark HEAD with a tag and open the editor to include a message:

$ git tag -a 

Mark HEAD with a tag that includes a message:

$ git tag  -am 'message here'

List all tags:

$ git tag

List all tags with their messages (tag message or commit message if tag has no message):

$ git tag -n

Update & Publish

List all current configured remotes:

$ git remote -v

Show information about a remote:

$ git remote show 

Add new remote repository, named :

$ git remote add  

Rename a remote repository, from to :

$ git remote rename  

Remove a remote:

$ git remote rm 

Note: git remote rm does not delete the remote repository from the server. It simply removes the remote and its references from your local repository.

Download all changes from , but don’t integrate into HEAD:

$ git fetch 

Download changes and directly merge/integrate into HEAD:

$ git remote pull  

Get all changes from HEAD to local repository:

$ git pull origin master

Get all changes from HEAD to local repository without a merge:

$ git pull --rebase  

Publish local changes on a remote:

$ git push remote  

Delete a branch on the remote:

$ git push  : (since Git v1.5.0)

OR

$ git push  --delete  (since Git v1.7.0)

Publish your tags:

$ git push --tags

Configure the merge tool globally to meld (editor)

$ git config --global merge.tool meld

Use your configured merge tool to solve conflicts:

$ git mergetool

Merge & Rebase

Merge branch into your current HEAD:

$ git merge 

List merged branches

$ git branch --merged

Rebase your current HEAD onto :

Don’t rebase published commit!

$ git rebase 

Abort a rebase:

$ git rebase --abort

Continue a rebase after resolving conflicts:

$ git rebase --continue

Use your editor to manually solve conflicts and (after resolving) mark file as resolved:

$ git add 

$ git rm 

Squashing commits:

$ git rebase -i 

Now replace this,

pick 
pick 
pick 

to this,

pick 
squash 
squash 

Undo

Discard all local changes in your working directory:

$ git reset --hard HEAD

Get all the files out of the staging area(i.e. undo the last git add):

$ git reset HEAD

Discard local changes in a specific file:

$ git checkout HEAD 

Revert a commit (by producing a new commit with contrary changes):

$ git revert 

Reset your HEAD pointer to a previous commit and discard all changes since then:

$ git reset --hard 

Reset your HEAD pointer to a remote branch current state.

$ git reset --hard  e.g., upstream/master, origin/my-feature

Reset your HEAD pointer to a previous commit and preserve all changes as unstaged changes:

$ git reset 

Reset your HEAD pointer to a previous commit and preserve uncommitted local changes:

$ git reset --keep 

Remove files that were accidentally committed before they were added to .gitignore

$ git rm -r --cached .
$ git add .
$ git commit -m "remove xyz file"

Git-Flow

Improved Git-flow

Index

• Setup
• Getting Started
• Features
• Make a Release
• Hotfixes
• Commands

Setup

You need a working git installation as prerequisite. Git flow works on OSX, Linux and Windows.

OSX Homebrew:

$ brew install git-flow-avh

OSX Macports:

$ port install git-flow

Linux (Debian-based):

$ sudo apt-get install git-flow

Windows (Cygwin):

You need wget and util-linux to install git-flow.

$ wget -q -O - --no-check-certificate https://raw.githubusercontent.com/petervanderdoes/gitflow/develop/contrib/gitflow-installer.sh install  | bash

Getting Started

Git flow needs to be initialized in order to customize your project setup. Start using git-flow by initializing it inside an existing git repository:

Initialize:

You’ll have to answer a few questions regarding the naming conventions for your branches. It’s recommended to use the default values.

git flow init

OR

To use default

git flow init -d

Features

Develop new features for upcoming releases. Typically exist in developers repos only.

Start a new feature:

This action creates a new feature branch based on ‘develop’ and switches to it.

git flow feature start MYFEATURE

Finish up a feature:

Finish the development of a feature. This action performs the following:

1) Merged MYFEATURE into ‘develop’.

2) Removes the feature branch.

3) Switches back to ‘develop’ branch

git flow feature finish MYFEATURE

Publish a feature:

Are you developing a feature in collaboration? Publish a feature to the remote server so it can be used by other users.

git flow feature publish MYFEATURE

Getting a published feature:

Get a feature published by another user.

git flow feature pull origin MYFEATURE

Tracking a origin feature:

You can track a feature on origin by using

git flow feature track MYFEATURE

Make a Release

Support preparation of a new production release. Allow for minor bug fixes and preparing meta-data for a release

Start a release:

To start a release, use the git flow release command. It creates a release branch created from the ‘develop’ branch. You can optionally supply a [BASE] commit sha-1 hash to start the release from. The commit must be on the ‘develop’ branch.

git flow release start RELEASE [BASE]

It’s wise to publish the release branch after creating it to allow release commits by other developers. Do it similar to feature publishing with the command:

git flow release publish RELEASE

(You can track a remote release with the:

git flow release track RELEASE

command)

Finish up a release:

Finishing a release is one of the big steps in git branching. It performs several actions:

1) Merges the release branch back into ‘master’

2) Tags the release with its name

3) Back-merges the release into ‘develop’

4) Removes the release branch

git flow release finish RELEASE

Don’t forget to push your tags with

git push --tags

Hotfixes

Hotfixes arise from the necessity to act immediately upon an undesired state of a live production version. May be branched off from the corresponding tag on the master branch that marks the production version.

Git flow hotfix start:

Like the other git flow commands, a hotfix is started with

$ git flow hotfix start VERSION [BASENAME]

The version argument hereby marks the new hotfix release name. Optionally you can specify a basename to start from.

Finish a hotfix:

By finishing a hotfix it gets merged back into develop and master. Additionally the master merge is tagged with the hotfix version

git flow hotfix finish VERSION