.. -*- coding: utf-8; -*-

======

 Git.

======

.. contents::

   :local:

Setting up git

==============

Debian::

  $ sudo apt-get install git

Cygwin::

  $ setup.exe -p git

  $ apt-cyg install git

After install set up some options::

  $ git config --global user.name "Oleksandr Gavenko"

  $ git config --global user.mail "gavenkoa@gmail.com"

After that you should have::

  $ cat ~/.gitconfig

  [user]

  name = Oleksandr Gavenko

  mail = gavenkoa@gmail.com

git over proxy.

===============

Only http:// protocol support proxy (not git://)::

  $ export http_proxy="http://username:password@proxy:port/"

  $ git clone http://github.com/$user/$proj.git $proj

You can store proxy settings under repository local config file::

  $ git config http.proxy http://$user:$passwd@$ip:$port

Start project with git

======================

Setup proj space on fs::

  $ mkdir proj

  $ cd proj

  $ git init

  Initialized empty Git repository in /home/user/tmp/proj/.git/

  $ ls -a

  . .. .git

Add file, make changes, commit all::

  $ emacs Makefile

  ... C-x C-c

  $ emacs app.c

  ... C-x C-c

  $ git add Makefile app.c

  $ git status

  # On branch master

  #

  # Initial commit

  #

  # Changes to be committed:

  #   (use "git rm --cached <file>..." to unstage)

  #

  #       new file: Makefile

  #       new file: app.c

  #

or just::

  $ git add .

Commit newlly added file::

  $ git commit

  ... Write message log ...

  Created initial commit 2169263: My first commit massage.

   1 files changed, 4 insertions(+), 0 deletions(-)

   create mode 100644 app.c

Show difference

===============

Show difference between index/stage and working tree::

  $ git diff

Show difference between ``HEAD`` and index (what is going to be commited)::

  $ git diff --cached

  $ git diff --staged

.. note:: ``--cached`` and ``--staged`` are synonyms.

Show difference beetween ``HEAD`` and working tree (what is commited after ``git commit -a``)::

  $ git diff HEAD

  $ git diff HEAD -- $path

Show difference in changeset::

  $ git show $hash

Show difference between revisions::

  $ git diff $rev1..$rev2

  $ git diff ORIG_HEAD..HEAD

For merge first parent is a tip where merge is performed, second is a tip of merged branch.

.. note:: ``git show`` shows "combined diff": only files which were modified from all parents.

          ``git show --first-parent`` can be used to show how branch was chaged after merge.

Show differences to each parent for merge::

  $ git show -m $hash

https://stackoverflow.com/questions/3293607/difference-between-git-head-and-the-current-project-state

  Difference between git HEAD and the current project state?

https://stackoverflow.com/questions/40986518/git-show-of-a-merge-commit

  git show of a merge commit.

Undo tracking added file.

=========================

You do::

  $ git add badfile

  $ git status

  # On branch master

  # Changes to be committed:

  #   (use "git reset HEAD <file>..." to unstage)

  #

  #       new file:   badfile

  #

To stop tracking badfile do::

  $ git rm --cached badfile

  $ git status

  # On branch master

  # Untracked files:

  #   (use "git add <file>..." to include in what will be committed)

  #

  #       file

  nothing added to commit but untracked files present (use "git add" to track)

or::

  $ git reset badfile

Committing changes

==================

Individual file::

  $ $EDITOR Makefile

  $ git add Makefile

  $ git diff --cached

  $ git commit -m "..."

Commit all changed and previously manages files::

  $ git commit -a -m "...."

Managing branches

=================

Print current branch::

  $ git branch

List all known branches::

  $ git branch -a

List all known remote branches::

  $ git branch -r

List all remote branches directly from remote::

  $ git ls-remote

  $ git ls-remote origin

List registered remotes::

  $ git remote -v

  $ git remote

  $ git remote show

List remote branches from ``$REMOTE`` remote::

  $ git ls-remote --heads $REMOTE

  $ git remote show $REMOTE

Special case of above is ``origin`` remote, which is default remote::

  $ git remote show origin

  $ git ls-remote --heads origin

.. note::

   Look to ``[remote "..."]`` in ``~/.git/config`` to find out names of possible

   remotes. Alternatively get list from::

     $ git remote show

Getting branches pointers from default (``origin``) remote (without merging

tracking branch)::

  $ git fetch

Getting branches pointers from ``$REMOTE`` remote::

  $ git fetch $REMOTE

To get updated with default remote changes::

  $ git pull

or specify concrete remote::

  $ git pull $REMOTE

  $ git pull origin

Delete local branch (``-D`` is unsafe i.e. changes aren't pushed to any remote)::

  $ git branch -d $NAME

  $ git branch -D $NAME

Delete remote branch::

  $ git push $REMOTE --delete $BRANCH_NAME

  $ git push $REMOTE -d $BRANCH_NAME

  $ git push origin -d $BRANCH_NAME

To locally remove pointers to deleted remotely branches::

  $ git remote update --prune

  $ git remote update --prune origin

.. note::

   Only curtain branches fetched by default::

     [remote "origin"]

     url = ...

     fetch = +refs/heads/*:refs/remotes/origin/*

   Edit ``fetch`` value to change defaults.

Move branch pointer to arbitrary hash::

  $ git branch -f $NAME $HASH

Create local branch from remote with the same name::

  $ git checkout --track origin/fix

Create local branch from remote with an alternative name::

  $ git checkout -b myfix origin/fix

git analog of 'hg incoming'

===========================

git does not directly support such feature. You can emulate it by::

  $ git fetch

  $ git log master..origin/master   # or just '..origin/master'

By previous commands you grab changes from remote server! You can apply them by

``pull`` or ``merge`` or ``rebase`` command::

  $ git pull

  $ git merge

  TODO

To detect if remote repository have new changes::

  $ git ls-remote

  $ git ls-remote $upstream

View git commits

================

Review specific commit with::

  $ git show $REV

  $ git diff $REV^ $REV

Review merge commit related to specific parent::

  $ git diff $REV^1 $REV

  $ git diff $REV^2 $REV

  $ git diff HEAD^1 HEAD

  $ git diff HEAD^2 HEAD

.. note:: ``^1`` is the first parent, ``^2`` is the second parent, and so on.

``git show`` command for merge commits shows only changes from conflicting hunks. It is equivalent

to (lines that changed as part of the conflict resolution)::

  $ git diff-tree --cc $REV

Review difference between commits::

  $ git $REV1 $REV2

  $ git $REV1..$REV2

  $ git $REV1..$REV2 -- $DIR_OR_FILE

Review history with diffs::

  $ git log -p

  $ git log -p $FROM_REV

Review history of merges only::

  $ git log --min-parents=2 -p --cc

View unpublished git commits / analog of git 'hg outgoing'

==========================================================

``git`` does not directly support such feature. Recently ``hg`` start tracking

changes that pushed to any other repositories (called as ``public`` versus

``draft`` which is not yet published anywhere). You can emulate it by::

  $ git fetch origin

  $ git log origin/master..master

  $ git log origin/master..

  $ git log origin/master..HEAD

  $ git log @{u}..

  $ git diff origin/master..

Verbose syntax::

  $ git log --branches --not --remotes

http://stackoverflow.com/questions/2016901/viewing-unpushed-git-commits

  Viewing unpushed Git commits.

http://stackoverflow.com/questions/3636914/how-can-i-see-what-i-am-about-to-push-with-git

  How can I see what I am about to push with git?

git analog of 'hg glog'

=======================

::

  $ git log --all --graph

  $ git log --all --graph --oneline

  $ git log --all --graph --oneline --decorate

Add alias::

  [alias]

  glog = log --all --graph

Git analog of 'hg rollback'

===========================

To edit commit message of last commit::

  $ git commit --amend -m "$MSG"

To integrate changes into last commit (``-a`` to avoid antecedent ``git add ...``,

``--no-edit`` if you don't like to change commit message, otherwise external

editor is opened)::

  $ git commit -a --amend --no-edit

To edit messages of old commits starting from ``$REV``::

  $ git rebase -i $REV

To undo latest commit::

  $ git reset HEAD~1

Git analog of 'hg root'

=======================

::

  $ git rev-parse --show-toplevel

Making local branch tracking remote

===================================

::

  $ git branch -u upstream/foo

  $ git branch -u upstream/foo foo

  $ git branch --set-upstream-to=upstream/foo

  $ git branch --set-upstream-to=upstream/foo foo

Showing what and how local branches are tracked::

  $ git branch -vv

  $ cat .git/gitconfig

Showing what remote branches tracked::

  $ git remote show $remote

Undo mistaken rebase

====================

If there are no any ``reset``, ``rebase`` or ``merge`` afterwards the easiest

way to recode to pre-rebase state is one of::

  $ git rebase --abort

  $ git reset --hard ORIG_HEAD

Otherwise look to::

  $ git reflog

and reset to necessary head::

  $ git reset --hard "HEAD@{...}"

https://stackoverflow.com/questions/134882/undoing-a-git-rebase

  Undoing git rebase.

Undo reset --hard

=================

``git reset --hard`` is destructive command without backup data.

You may find your previously added data in Git garbage::

  $ git fsck --lost-found

look to files inside ``.git/lost-found`` directory.

Reviewing ``git reflog`` also may help.

* https://stackoverflow.com/questions/5788037/recover-from-git-reset-hard

* https://stackoverflow.com/questions/14251194/how-to-recover-after-i-execute-git-reset-hard-head

Undo mistaken push

==================

::

  $ git reset HEAD^

  $ git push --force

Alternative commands may look like::

  $ git reset --hard $HASH

  $ git push -u origin master --force

You can delete remote branch with syntax of appended colon before branch name::

  $ git reset HEAD^

  $ git push origin :$NAME

  $ git push origin $NAME

Git bisect

==========

``bad`` changes should be later in graph history then ``good`` ones. To use

alternative names::

  $ git start --term-old=... --term-new=...

Start bisecting with::

  $ git bisect start

Mark good and bad revisions::

  $ git co vBAD

  $ make test

  $ git bisect bad

  $ git co vGOOD

  $ make test

  $ git bisect good

If build/test failed to complete use::

  $ git bisect skip

To restore mistakenly marked revisions::

  $ git bisect log >$LOG