On Git

Fundamentals

• Git Documentation

• Git Reference
  • Git configuration variables
  • Revisions
  • gitignore Pattern Format
• Pro Git
  • Git References
  • Git Branching
  • Remote Branches
• GitHub Bootcamp
  • As of Nov. 1st 2012, one important thing is missing. That is sharing the project in Eclipse, after cloning the fork in the server. Maybe it could be a defect of Eclipse, not a miss of the article.
• Git Cheatsheet
  • Workspace
  • Local Repository
  • Upstream Repository
• Git Tutorials by Bitbucket
• Git Workflows by Bitbucket
• EGit User Guide
  • Git References(Refs)
  • Remotes

Glossary

• Git Glossary

Term	Description	Examples	Remarks
commit (noun)	A single point in the Git history		revision, version
commit object	An object which contains the information about a particular revision, such as parents, committer, author, date and the tree object which corresponds to the top directory of the stored revision.
commit-ish	A commit object or an object that can be recursively dereferenced to a commit object		commit object, tag object
tree	Either a working tree, or a tree object together with the dependent blob and tree objects (i.e. a stored representation of a working tree)
tree object	An object containing a list of file names and modes along with refs to the associated blob and/or tree objects
tree-ish	A commit-ish, a tree object or a tag object
pathspec	Pattern used to limit paths in Git commands	documentation/*.jpg
ref	A name that begins with refs/ (e.g. refs/heads/master) that points to an object name or another ref (the latter is called a symbolic ref)
refspec	Used by fetch and push to describe the mapping between remote ref and local ref		push refspec
HEAD	The current branch. In more detail: Your working tree is normally derived from the state of the tree referred to by HEAD.		detached HEAD, HEAD ≠ head
detached HEAD	Git also allows you to check out an arbitrary commit that isn’t necessarily the tip of any particular branch. The HEAD in such a state is called "detached".
upstream branch	The default branch that is merged into the branch in question (or the branch in question is rebased onto)		branch.name.remote branch.name.merge upstream branch of br is origin/br′ = br is tracking origin/br′

• What are commit-ish and tree-ish in Git

Revision

• Specifying Revisions

Type	Format	Description	Examples
sha1	40-byte hexadecimal string	The full SHA-1 object name, or a leading substring that is unique within the repository	dae86e1950b1277e545cee180551750029cfe735, dae86e
refname		A symbolic ref name	master, heads/master, refs/heads/master, tags/master
<rev>^[<n>]		the <n>th parent	HEAD^, v1.5.1^0, HEAD^^^, HEAD^^3^2
<rev>~[<n>]		the commit object that is the <n>th generation ancestor of the named commit object	HEAD~, HEAD~4 master~3
<rev>:<path>		the blob or tree at the given path in the tree-ish object named by the part before the colon.	HEAD:README, master:./README

• An illustration, by Jon Loeliger

  G   H   I   J
   \ /     \ /
    D   E   F
     \  |  / \
      \ | /   |
       \|/    |
        B     C
         \   /
          \ /
           A


  A =      = A^0
  B = A^   = A^1     = A~1
  C =      = A^2
  D = A^^  = A^1^1   = A~2
  E = B^2  = A^^2
  F = B^3  = A^^3
  G = A^^^ = A^1^1^1 = A~3
  H = D^2  = B^^2    = A^^^2  = A~2^2
  I = F^   = B^3^    = A^^3^
  J = F^2  = B^3^2   = A^^3^2

Commands

Category	Command	Description	Remark
Setup	git config [--get]	Get and set repository(local) options	git config --get core.autocrlf git config core.autocrlf false
	git config --global [--get]	Get and set global options	git config --global --get committer.name git config --global init.defaultBranch main
	git config --list --show-origin	List all variables set in config file, along with their values.
	git help --all	Prints all the available commands on the standard output
	git help -m command	Display manual page for the command in the man format
Creating	git clone	Clone a repository into a new directory
	git init	Create an empty Git repository or reinitialize an existing one
Snapshotting	git add
	git status	Show the working tree status
	git diff [--] path	Show changes you made relative to the index (staging area for the next commit)	working tree (excluding untracked files) vs index
	git diff commit [--] path	Show the changes you have in your working tree relative to the named commit	working tree (excluding untracked files) vs commit
	git diff --staged commit [--] path	the changes you staged for the next commit relative to the named commit (default to HEAD).	index vs commit
	git diff blob1 blob2	Show differences between the raw contents of two blob objects	git diff HEAD:docs/GUIDELINES.md HEAD~1:docs/GUIDELINES.md
	git diff commit1 commit2 [--] path	Show changes between two arbitrary commits	git diff HEAD HEAD^ docs/GUIDELINES.md
	git diff --name-only commit1 commit2	Show only names of changed files between two arbitrary commits	git diff --name-only v1.2.1 HEAD
	git diff --name-status commit1 commit2	Show only names and status of changed files between two arbitrary commits
	git diff --summary commit1 commit2	Output a condensed summary of extended header information such as creations, renames and mode changes.
	git diff --stat commit1 commit2
	git commit
	git reset	Reset current HEAD to the specified state
	git reset --hard	Resets the index and working tree. Any changes to tracked files in the working tree since commit are discarded.
	git reset --hard commit	Resets the current branch head to commit	Undo commits permanently
	git reset commit [--] path	Reset the index entries for all that match the path to their state at commit	git reset HEAD CONTRIBUTING.md
	git restore	Restore working tree files or the content in the index
	git resotre [--worktree] path	Restore working tree files that match the path from the index
	git reset --staged path	Restore the contents of the index that match the path from HEAD
	git rm	Remove files from the working tree and from the index
	git rm -rf --cached	Only remove from the index	Working tree files, whether modified or not, will be left alone
Branching	git branch	List, create, or delete branches
	git branch --list	List branches.	-l
	git branch --all -vvvv	List both remote-tracking branches and local branches.	-avvvv
	git branch --move oldbranch newbranch	Move/rename a branch and the corresponding reflog.	-m
	git branch --delete [--force] branch	Delete a branch.	-d, -D
	git checkout branch	To prepare for working on branch, switch to it by updating the index and the files in the working tree, and by pointing HEAD at the branch
	git checkout commit [ -- ] pathspec	Overwrite both the index and the working tree that match the pathspec with the contents at the commit.	just one file from another branch
	git checkout -b new-branch [ start-point ] --track remote/branch	Create and check out a new branch tracking the specified remote branch from HEAD or the specified start-point if any	git checkout -b simpler HEAD~3
	git checkout --track remote/branch	Create and check out a new branch which is tracking and named from the specified remote branch	git checkout -t remote/branch
	git push --set-upstream repository src-branch:dst-branch	Push src-branch into dst-branch in repository creating a new branch if dst-branch dose not exist yet and then set the src-branch to track the dst-branch
	git branch --set-upstream-to=remote/branch′ branch	Set up the branch (specified by branch) tracking information so the upstream specified by remote/branch′ is considered it's upstream branch.	git branch --set-upstream-to=origin/bar bar git branch -u origin/bar bar
	git branch --set-upstream-to=upstream	Set up current branch tracking information so the upstream specified by upstream is considered it's upstream branch.	git branch --set-upstream-to=origin/foo git branch -u origin/foo
	git checkout branch [--] pathspec	Overwrite the contents of the files that match the pathspec in both the index and the working tree with the contents at the specified branch
	git checkout --patch branch [--] pathspec	Overwrite the contents of the files that match the pathspec with the interactive interface to show the "diff" output and choose which hunks to use in the result.	--patch, -p
	git merge [--ff | --no-ff | --ff-only] commit	Join two or more development histories together
	git merge --abort	Abort the current conflict resolution process, and try to reconstruct the pre-merge state.
	git log [branch] -n	Show commit logs	git log master -3
	git log [-n] --graph [--all]	Draw a text-based graphical representation of the commit history on the left hand side of the output.	git log -3 --graph
	git tag	Create, list, delete or verify a tag object signed with GPG
	git tag --list -n2	List tags	git tag -l
	git tag --list --sort=-taggerdate --format='%(refname:short), %(*objectname), %(contents:subject)'	List tags with commit hash and annotation ordered, last tag first	format field names
	git tag --annotate tagname -m "..."	Make(create) an unsigned, annotated tag object	git tag -a
	git tag --delete tagname	Delete an existing tag with the given name.	git tag -d
Sharing	git fetch	Fetch branches and/or tags (collectively, "refs") from one or more other repositories, along with the objects necessary to complete their histories.	git remote add staging; git fetch staging
	git fetch [remote remote-branch]
	git pull [remote remote-branch]	Incorporates changes from a remote repository into the current branch	current branch only
	git push [remote [src-branch[:dst-branch]...]]	Push specified branches to the specified remote repository.	branch.*.remote, origin
	git push remote tag-name	Push a tag to the specified remote repository	git push origin v1.3.0-alpha
	git push --all [remote]	Push all branches (i.e. refs under refs/heads/) into default remote, origin, or specified remote
	git push --tags [remote]	All refs under refs/tags are pushed
	git push --follow-tags	Push all the refs that would be pushed without this option, and also push annotated tags in refs/tags that are missing from the remote but are pointing at commit-ish that are reachable from the refs being pushed.
	git push --delete tagname	Delete a remote tag with the given name.	git push -d
	git push --set-upstream	For every branch that is up to date or successfully pushed, add upstream (tracking) reference, used by argument-less git-pull and other commands.
	git remote -v	List tracked repositories
	git remote add name url	Add a remote	git remote add upstream https://....git
	git remote set-url name url	Changes URLs for the remote
	git remote rename old new	Rename a remote
	git remote remove	Remove a remote	git remote rm
	git remote -v show name	Gives some information about a remote	git remote -v show origin
	git ls-remote	List references in a remote repository	git ls-remote origin
Inspection	git show tag	Shows the tag message and the referenced objects.	git show v1.0
	git show rev:path	Shows the contents of the file specified by path at rev	git show HEAD~10:./README.md
Stashing	git stash list	List the stash entries that you currently have.	stash@{0}, stash@{1}
	git stash show stash	Show the changes recorded in the stash entry as a diff between the stashed contents and the commit back when the stash entry was first created
	git stash push pathspec	Save your local modifications to a new stash entry and roll them back to HEAD (in the working tree and in the index)
	git stash pop stash	Remove a single stashed state from the stash list and apply it on top of the current working tree state
	git stash stash	Remove a single stash entry from the list of stash entries.
	git clear	Remove all the stash entries.
Patching	git rebase	Reapply commits on top of another base tip
	git revert	Revert some existing commits	Requires your working tree to be clean (no modifications from the HEAD commit)
Administration	git clean	Remove untracked files from the working tree
	git archive	Create an archive of files from a named tree	git archive -o latest.zip HEAD
Plumbing	git ls-files	Show information about files in the index and the working tree	git ls-files | wc -l
	git show-ref	List references in a local repository
Guides	gitignore		($HOME/.config/git/ignore, $GIT_DIR/info/exclude, .gitignore)
Misc	git svn	Bidirectional operation between a Subversion repository and Git

Ref

A name that begins with refs/ (e.g. refs/heads/master) that points to an object name or another ref.

• Git References(Refs)
• Git Internals - Git References

Type	Format	Example	Remarks
Local branches	refs/heads/...	refs/heads/2.x, refs/heads/3.x
Remote tracking branches	refs/remotes/...	refs/remotes/origin/master, refs/remotes/upstream/master
Tags	refs/tags/...	refs/tags/v0.9, refs/tags/v1.5.RELEASE, refs/tags/v2.0.GA

$ git show-ref

           +--- HEAD
           |
           +--- FETCH_HEAD
           |
           +--- ORIG_HEAD
           |
  .git/ ---+--- refs/ ---+--- heads/ ---+--- main
                         |              |
                         |              +--- next
                         |
                         +--- tags/ ----+--- v0.9
                         |              |
                         |              +--- v1.0
                         |              |
                         |              +--- v1.1
                         |
                         +--- remotes/ ---+--- origin/ --- main
                         |                |
                         |                +--- origin/ --- HEAD
                         |                |
                         |                +--- upstream/ --- main
                         |
                         +--- stash/

Reserved Refs

Reserved	Full	Description	Remarks
master	refs/heads/master	local master branch
origin/master	refs/remotes/origin/master
v1.0.1	refs/tags/v1.0.1
HEAD		currently checkout commit points out the last commit in the current checkout branch.	cat .git/HEAD
FETCH_HEAD		the result of the last fetch operation	cat .git/FETCH_HEAD
ORIG_HEAD		the commit that was checked out before a merge or rebase operation was started	cat .git/ORIG_HEAD

HEAD

• The HEAD

$ cat .git/HEAD
ref: refs/heads/master
$ git checkout test
...
$ cat .git/HEAD
ref: refs/heads/test

• Git Head
  • The HEAD points out the last commit in the current checkout branch. It is like a pointer to any reference.
  • $ git show HEAD

Refspec

Used by fetch and push to describe the mapping between remote ref and local ref.

• git-push refspec
• git-fetch refspec
• git-pull refspec

• Push Refspecs
• Fetch Refspecs

Configuration

• Git configuration variables

Variable	Data Type	Description	Default	Remarks
init.defaultBranch	string	Allows overriding the default branch name
push.followTags	boolean	If set to true enable --follow-tags option by default.	false	--no-follow-tags

• Common global configuration

$ git config --global init.defaultbranch main
$ git config --global core.autocrlf false

$ git config --global user.name ...
$ git config --global user.email ...
$ git config --global author.name ...
$ git config --global author.email ...
$ git config --global committer.name ...
$ git config --global committer.email ...

Model

• Git Cheatsheet
• Git Workflow

File State-chart

• Recording Changes to the Repository

  Untracked           Modified            Staged        Committed
      |                  |                 |               |
      +- add ------------|---------------->|               |
      |                  |                 |               |
      |                  +- add ---------->|               |
      |                  |                 |               |
      |                  |                 +- commit ----->|
      |                  |                 |               |
      |                  |                 |               |
      |                  |<----------------|-------- edit -+
      |                  |                 |               |
      |<-----------------+-----------------+------ remove -|
      |                  |                 |               |


                       * Tracked = Modified | Staged | Committed

                            
  +-----------+            +---------+            +------------+
  | Untracked | ---add---> | Staged  | <---add--- | Modified   |
  |(workspace)|            | (index) |            |(workspace)|
  +-----------+            +---------+            +------------+
                                |                      ^
                                |                      |
                             commit                  edit
                                |                      |
                                |     +-----------+    |
                                +---> | Committed | ---+
                                      +-----------+

Areas

Area	Role	Description	Remarks
Workspace	Working directory	Consists of files that you are currently working on.	Local checkout
Index	Staging area, Cache	Where commits are prepared.
Stash		A place to hide modifications while you work on something else
Local Repository
Upstream Repository

Branching

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

                         << master, HEAD >>
                                  |  
    +----+        +----+        +----+
    | c1 | <----- | c2 | <----- | c3 | 
    +----+        +----+        +----+

$ git branch iss31  # branch to work on issue 31 - new feature

                         << master, HEAD >>
                                  |  
    +----+        +----+        +----+
    | c1 | <----- | c2 | <----- | c3 | 
    +----+        +----+        +----+
                                  |
                             << iss31 >>

$ git checkout iss31

                             << master >>
                                  |  
    +----+        +----+        +----+
    | c1 | <----- | c2 | <----- | c3 | 
    +----+        +----+        +----+
                                  |
                          << iss31, HEAD >>

$ # edits or adds some files
$ git commit -a -m ...

                             << master >>
                                  |  
    +----+        +----+        +----+        +----+
    | c1 | <----- | c2 | <----- | c3 | <----- | c4 |
    +----+        +----+        +----+        +----+
                                                |
                                        << iss31, HEAD >>

$ # a simple bug is found, create anothter branch for hotfix on 'master' 
$ git checkout master
$ git checkout -b hotfix  # same with 'git branch hotfix; git checkout hotfix'
 
                         << master, HEAD >>
                                  |  
    +----+        +----+        +----+        +----+
    | c1 | <----- | c2 | <----- | c3 | <----- | c4 |
    +----+        +----+        +----+        +----+
                                                |
                                           << iss31 >>

                          << hotfix, HEAD >> 
                             << master >>
                                  |  
    +----+        +----+        +----+        +----+
    | c1 | <----- | c2 | <----- | c3 | <----- | c4 |
    +----+        +----+        +----+        +----+
                                                |
                                           << iss31 >>

$ # edits some files to fix the bug
$ git commit -a -m ...

                                           << hotfix, HEAD >>
                                                   |
                                                 +----+
                              << master >>   +-- | c5 |
                                   |         |   +----+
    +----+        +----+        +----+ <-----+
    | c1 | <----- | c2 | <----- | c3 | 
    +----+        +----+        +----+ <-----+ 
                                             |   +----+ 
                                             +-- | c4 |
                                                 +----+
                                                   |
                                              << iss31 >>

$ # after successful testing on hotfix, merge 'hotfix' to 'master'. remove 'hotfix' after merge
$ git checkout master
$ git merge hotfix   # 'master' fast-forwarded
$ git branch --delete hotfix   # --delete == -d

                                              << hotfix >>
                                          << master, HEAD >>
                                                   |
                                                 +----+
                                             +-- | c5 |
                                             |   +----+
    +----+        +----+        +----+ <-----+
    | c1 | <----- | c2 | <----- | c3 | 
    +----+        +----+        +----+ <-----+ 
                                             |   +----+ 
                                             +-- | c4 |
                                                 +----+
                                                   |
                                              << iss31 >>

                                          << master, HEAD >>
                                                   |
                                                 +----+
                                             +-- | c5 |
                                             |   +----+
    +----+        +----+        +----+ <-----+
    | c1 | <----- | c2 | <----- | c3 | 
    +----+        +----+        +----+ <-----+ 
                                             |   +----+ 
                                             +-- | c4 |
                                                 +----+
                                                   |
                                              << iss31 >>

$ # after hotfix, works on 'iss31' branch with other commits
$ git checkout iss31

                                              << master >>
                                                   |
                                                 +----+
                                             +-- | c5 |
                                             |   +----+
    +----+        +----+        +----+ <-----+
    | c1 | <----- | c2 | <----- | c3 | 
    +----+        +----+        +----+ <-----+ 
                                             |   +----+      +----+      +----+  
                                             +-- | c4 | <--- | c6 | <--- | c7 | 
                                                 +----+      +----+      +----+
                                                                           |
                                                                   << iss31, HEAD >>

$ # when 'iss31' implemented successfully
$ git checkout mater
$ git merge iss31   # if no conflict, simple three-way merge with another new commit

                                                                                  << master, HEAD >>
                                                                                           |
                                                 +----+ <------------------------------- +----+
                                             +-- | c5 |                                  | c8 |
                                             |   +----+                           +----- +----+
    +----+        +----+        +----+ <-----+                                    |        |
    | c1 | <----- | c2 | <----- | c3 |                                            |   << iss31 >>
    +----+        +----+        +----+ <-----+                                    | 
                                             |   +----+      +----+      +----+   |
                                             +-- | c4 | <--- | c6 | <--- | c7 | --+
                                                 +----+      +----+      +----+

• Detached HEAD

Commands

merge	A---B---C topic / D---E---F---G master	(master)$ git merge --no-ff topic	A---B---C topic / \ D---E---F---G---H master
reset --hard	A---B---C topic / D---E---F---G---H master	(master)$ git reset --hard HEAD~2	A---B---C topic / D---E---F master
revert
restore
rebase	A---B---C topic / D---E---F---G master	$ git rebase master topic	A'--B'--C' topic / D---E---F---G master
	A---B---C topic / D---E---A'---F master	$ git rebase master topic	B'---C' topic / D---E---A'---F master

Readings

Topic	Reading	Remark
Stashing	Git stash (Bitbucket)

• What's a “fast-forward” in Git?
• Is there any way to clone a git repository's sub-directory only?
• How to change file premissions in Git on Windows (Nov. 2011)
• Git - Get Current Working Copy Version (Jan 23 '12)
  • git log -1
• How to get latest git commit hash command (Mar 28 '13)
• Dealing with line endings
• What does tree-ish mean in Git?(Oct 28 '10)
• Ignoring files
• gitignore: Ignore all files in folder hierarchy except one specific filetype (Oct 18 '11)
• How do negated patterns work in .gitignore? (May 12 '10)
  • /excluded/*, !/excluded/included
• Git v2.0.0, what changed, and why should you care (2014/05/29)
• Adding an existing project to GitHub using the command line

Revision

• What is a Git Revision Expression? (Aug 1 '09)
• Revision Selection
• gitrevisions
• Git References : refs/heads/, refs/remotes/, refs/tags/ ...
• <refname>
• What is the parent of a git commit? How can there be more than one parent to a git commit? (Jul 7 '16)

Basic Snapshotting

add, status, diff, commit, restore, reset

status

• Recording Changes to the Repository
• Difference between untracked, unstaged and staged changes

diff

• How to diff the same file between two different commits on the same branch? (Jul 26 '10)
• Git diff between given two tags (Jul 9 '10)
• git: diff between file in local repo and origin (Jan 13 '14)
  • $ git fetch; git diff --summary master origin/master
• How to list only the names of files that changed between two commits (Oct 12, 2009)
  • git diff --name-only HEAD~10 HEAD~5

reset

• Reset, restore and revert

command	Description	Remark
restore	about restoring files in the working tree from either the index or another commit.	does not update your branch
reset	updating your branch, moving the tip in order to add or remove commits from the branch.	can also be used to restore the index, overlapping with git restore.
revert	about making a new commit that reverts the changes made by other commits.

git revert is used to record some new commits to reverse the effect of some earlier commits (often only a faulty one). If you want to throw away all uncommitted changes in your working directory, you should see git-reset, particularly the --hard option. If you want to extract specific files as they were in another commit, you should see git-restore, specifically the --source option. Take care with these alternatives as both will discard uncommitted changes in your working directory.

• Undo commits permanently
• Delete commit on gitlab (Oct 25, 2016)
  • git reset --hard CommitId, git push -f origin master

rm

• Git treats folder as file and ignores all subfolders and -files (Nov 15 '16)

Branching

branch, checkout, switch, merge, log, tag

• A successful Git branching model (January 05, 2010)

branch

• A branch in Git is simply a lightweight movable pointer to one of these commits.
• Every time you commit, the master branch pointer moves forward automatically.
• HEAD is a pointer to the local branch you’re currently on.

Term	Description	Remark
Remote-tracking Branch
Upstream Branch

• What is the difference between origin and upstream on GitHub? (Feb 13 '12)
• Definition of “downstream” and “upstream”(Apr 29 '10)
• Removing a remote
• How do you create a remote Git branch? (Oct 5 '09)
  • git push <remote-name> <local-branch-name>:<remote-branch-name>
• Make an existing Git branch track a remote branch?(Feb 6, 2009)
  • git branch -u upstream/foo foo or git branch --set-upstream-to=upstream/foo foo
• How To Rename a Local and Remote Git Branch (Feb 18, 2020)
  • git branch -m name, git push origin --delete name
• How to list all the files in a commit? (Jan 8 '09)
  • git show --name-only -1, git log --name-only -1

checkout

• How to checkout remote git tag (Mar 14 '16)
  • git checkout v1.0.0, git checkout tags/v1.0.0
• How to get back to most recent version in Git? (Aug 24 '10)
  • git checkout master

• How to get just one file from another branch? (asked Mar 2 2010)
  • git checkout experiment -- app.js
• Git tip: How to "merge" specific files from another branch (February 25, 2009)
  • git checkout source_branch paths
• How do I merge changes to a single file, rather than merging commits? ( May 28, 2012)

• How to Check out a Remote Git Branch [Step-by-Step] (30 March 2021)
  • A Git repository itself may have multiple remotes, but a branch can only reference a single remote.
  • The fetch command will connect to the remote repository and retrieve a list of all available branches.
  • git checkout RemoteBranch
• git checkout a Remote Branch
  • In order to see this newly published branch, you will have to perform a simple "git fetch" for the remote.
  • $ git checkout --track origin/newsletter

merge

• Git Merge

• How do I cancel a git merge?
  • git reset --hard HEAD or git merge --abort

tag

• How to list all tags along with the full message in git? (Mar 18 '11)
  • git tag -l -n9
• How to tell which commit a tag points to in Git? (Dec 7, 2009)
  • $ git show-ref --tags
  • $ git show tagname
• How to push a tag to a remote repository using Git? (Mar 4 '11)
  • git push origin --tags
• How do you push a tag to a remote repository using Git? (Mar 4 '11)
  • git push origin <tag_name>
• How To Delete Local and Remote Tags on Git
  • $ git push --delete origin tag-name

Sharing

fetch, pull, push, remote

• Find out which remote branch a local branch is tracking (Oct 5 '08)
  • git branch -vv, git status
• Pushing to a remote
  • By default, and without additional parameters, git push sends all matching branches that have the same names as remote branches.

• Why do I have to "git push --set-upstream origin <branch>"? (Jun 12, 2016)
  • git push -u origin solaris

• How to Rename the master branch to main in Git
• How does origin/HEAD get set? (Jan 12, 2012)
  • origin's HEAD will only change if you or someone else actually changes it in the remote repository

Workflow

• Comparing Workflows
• Git Feature Branch Workflow
• Gitflow Workflow
• Forking Workflow

• A successful Git branching model (January 05, 2010)

Hooks

• Git Hooks

Tools

• Interfaces, frontends, and tools

Misc

• Changing a commit message : git commit --amend
• Add line break to 'git commit -m' from the command line (Feb 21 '11)
• Using Git Show to View Contents of Files (DECEMBER 14, 2019)
  • git show <version>:<file>

Subtree

• About Git subtree merges
  • to manage multiple projects within a single repository
• Mastering Git subtrees

Typical Usage

Configuration

List all configuration

$ git config --list --show-scope --show-origin

Snapshotting

Add, commit and push

$ git status .                    // identifies added, modified or untracked items under current local directory
$ git add .                       // updates index
$ git status .                    // confirms the changes to be committed
$ git commit -m "message ..."     // commits changes into local repository
$ git status .                    // confirms all changes are committed
$ git push                        // pushes changes in local repository onto the remote repository
$ git log --name-only -1         // lists files in the last commit

When the HEAD of 'origin/master' has changed since the last sync, '$ git push' would fail with messages including fast-forwards. Then,

$ git pull --rebase
...
may need manual merge.
...
$ git push

Creating local repository using existing artifacts

... and pushing it to the remote bare repository

$ git init
$ git add .
$ git status .
$ git commit -m "..."
$ git remote add origin https://github.com/.../....git
$ git push --set-upstream origin master
$ git remote -v

Look around local repository

$ git status .              // show the working tree status
$ git branch --all -vvvv    // list both remote-tracking branches and local branches.
$ git tag -ln               // list tags
$ git remote -v             // list tracking repositories
$ git show-ref              // list references in a local repository 
$ git log origin/master -3  // lists 3 recent commits for remote branch 'origin/master'
$ git ls-files               // show information about files in the index and the working tree
$ git config -l              // list all variables set in config file, along with their values.

Tracking changes

$ git log master -3                          // lists 3 recent commits for master branch
$ git log v2.0.2 -3                          // lists 3 last commits before the tag of 'v2.0.2'
$ git log origin/master -1                   // lists last commit of remote branch 'origin/master'
$ git log upstream/master -1                 // lists last commit of remote branch 'upstream/master'
$ git log --name-only -1                    // lists files in the last commit.

Branching

Working with branches or tags

$ git tag -ln                                // lists tags
$ git tag -a v2.0.2 -m "before new branch"   // creates a new annotated tag(v2.0.2)
$ git tag origin v2.0.2                      // push a tag to a remote 
$ git push origin --tags                     // pushes all local tags to remote 'origin'

$ git branch                                 // lists branches
$ git branch -a                              // lists both local and remote-tracking branches
$ git branch -avv                            // lists all branches showing hash and upstream branch if any

$ git branch 1.1                             // creates a new branch(1.1) from the master (branch)
$ git branch 2.0.2-ext v2.0.2                // creates a new branch(2.0.2-ext) from a tag(v2.0.2)
$ git push origin advanced:advanced          // creates remote branch 'origin/advanced' from local branch 'advanced'
$ git push --set-upstream origin advanced    // sets upstream(tracking) reference for current branch to 

$ git checkout release-1.1                   // updates working tree to release-1.1
$ git checkout -b gh-pages origin/gh-pages   // copies remote branch to local repository

Creating and pushing tag

$ git tag -a v1.0 -m "Ready to offer externally"
...
$ git push origin v1.0
...

Sharing

Managing remote repositories

$ git remote -v          // lists tracking repositories
$ git remote add upstream https://github.com/jpmorganchase/quorum.git     // add a new remote repository to track
$ git branch -r          // lists branches in tracking repositories

Renaming branch at shared repository first

The default branch has been renamed!
master is now named main
If you have a local clone, you can update it by running the following commands.

git branch -m master main
git fetch origin
git branch -u origin/main main
git remote set-head origin -a

Undoing

Use-case	Solution	Example	Remarks
Removing untracked files and directories	git clean -dx
Removing uncommitted changes on all the tracked files	git reset --hard
Undo commits permanently	git reset --hard commit	git reset --hard HEAD
Removing uncommitted changes on a single or selected tracked files	git checkout commit [ -- ] pathspec		Overwrite both the index and the working tree that match the pathspec with the contents at the commit.
Reverting committed changes	git revert commit	git revert HEAD	revert : go back to a previous state. Instead of removing the commit from the project history, it figures out how to invert the changes introduced by the commit and appends a new commit with the resulting inverse content.

• Undoing Commits & Changes
  • Git Revert
  • Git Reset
  • Git Clean
  • Git RM

Removing untracked files and directories in the working tree

$ git clean -n            // -n: dry run
...
$ git clean -i            // -i: interactive
...
$ git clean -ndx          // -n: dry run, -d: directory also, -x: skip gitignore
...
$ git clean -ffdx         // -ff: force including files manged by different Git repository
...

For more, refer

• how to remove untracked files in Git? (Nov 20 '11)
• How to remove local (untracked) files from the current Git working tree? (Sep 14 '08)

Undoing tracked files

• To remove uncommitted changes on tracked files in the working tree, use 'git reset --hard'.

$ git reset --hard          // resets the index and working tree. Any changes to tracked files in the working tree since <commit> are discarded.

• To unstage a staged file, use 'git reset HEAD <<file>>'.

$ git reset HEAD CONTRIBUTING.md

• To unmodify a modified file, use 'git checkout -- <<file>>'.

$ git checkout -- CONTRIBUTING.md

Removing committed changes

@TODO

Companions

GitHub

• GitHub Help
• Searching code

• Fork A Repo
• Syncing a fork
• Configuring a remote for a fork
• Configuring Git Large File Storage : Git LFS
• Adding an existing project to GitHub using the command line

• GitHub Cheat Sheet
• GitHub Markup Support
  • The library that every markup file in a repository goes on before it is rendered on GitHub.com:

Markup	Extension	Library
Markdown	.markdown, .md	https://github.com/gjtorikian/commonmarker
MediaWiki	.mediawiki, .wiki	https://github.com/nricciar/wikicloth
Textile	.textile	https://github.com/jgarber/redcloth
AsciiDoc	.asciidoc, .adoc	http://asciidoctor.org/
reStructuredText	.rst

GitHub Pages

• GitHub Pages
• GitHub Pages Basics gh-pages
  • Creating Project Pages manually
  • User, Organization, and Project Pages
  • Setting up your GitHub Pages site locally with Jekyll
• GitHub Flavored Markdown

• Master and gh-pages in Github: keep your code and website in the same repo (Jun 14, 2015)

• Get Started With GitHub Pages (Plus Bonus Jekyll)(18 December 2013)
• A blog site with Jekyll, Github Pages Eclipse Che and Codenvy
• Using Jekyll as a static site generator with GitHub Pages
• Collapsible Code Blocks in GitHub Pages (May 2, 2019)
  • <details><summary>...</summary>``` ... ```</details>
• How I can move JavaDoc from master branch to gh-pages branch on GitHub using EGit and Eclipse? (Aug 13 '12)

• GitHub Pages supported themes
• GitHub Pages themes
  • primer, cayman, hacker, minimal, midnight

EGit

• http://www.eclipse.org/egit/
• Desc : an Eclipse Team provider for the Git version control system.
• License
• Readings
  • EGit User Guide
    • Resolving a merge conflict
  • Git For Eclipse Users
  • EGit Getting Started
  • EGit/GitHub/User Guide : explains how to use EGit Mylyn GitHub connector.
  • EGit Compare shows all lines as changed (Dec 30 '13)
    • EGit doesn't support .gitattributes file.

Gitorious

• Desc : Git hosting and collaboration software that you can install yourself
• License : GNU Affero General Public License

GitLab

• https://github.com/gitlabhq/gitlabhq
• Desc : self hosted Git management software
• License : MIT license

• Protected branches : prevent force push or delete
• GitLab Flavored Markdown (GLFM)
  • diagrams/flowcharts, front matter, math/LaTex/KaTex, ToC

Gogs

• https://gogs.io/
• Desc. : a painless self-hosted Git service
• License : MIT License
• Sources : https://github.com/gogs/gogs

Tips and Tricks

Typical .gitignore

A typical .gitignore file contains

# references
#   https://git-scm.com/docs/gitignore
#   https://github.com/github/gitignore

# source version control related
CVS/
.svn/
.hg

# IDEs or tools related
# /.vscode/
/.idea/
.gradle/

# directories for intermediate or final compiled artifacts
/bin/
/target/
/build/
/output/
/out/
/Debug/
/Release/
/x86/
/x64/
/obj/
/package/

# dependencies
/node_modules/*
/pkg/

# generated artifacts
/reports/
/_site/
.apt_generated/
.atp_generated_tests/
/artifacts/
/types/

# runtime outputs
/run/
/log/
/logs/
/test-output/
*.log
npm-debug.log

# backups, caches, or temporary artifacts
.~*
._*
*.bak
.cache*
.*.swp
*.md.html
# package-lock.json
Gemfile.lock
.sass-cache
__pycache__/
.pytest_cache/
packer_cache/
/.scannerwork

# misc
config.gypi
.npmrc
.jekyll-metadata
.DS_Store
.lock-wscript
.wafpickle-N
/*.tgz

# build outputs of Remix-IDE for smart contracts - https://remix-ide.readthedocs.io/en/latest/contract_metadata.html
contracts/**/artifacts/

# don't ignore OpenZeppelin contracts
# !/node_modules/@openzeppelin
# /node_modules/@openzeppelin/*
# !/node_modules/@openzeppelin/contracts-3
# /node_modules/@openzeppelin/contracts-3/build
# /node_modules/@openzeppelin/contracts-3/package.json
# /node_modules/@openzeppelin/contracts-3/**/artifacts
# !/node_modules/@openzeppelin/contracts-4
# /node_modules/@openzeppelin/contracts-4/build
# /node_modules/@openzeppelin/contracts-4/package.json
# /node_modules/@openzeppelin/contracts-4/**/artifacts

For more, refer

• gitignore documentation
• A collection of useful .gitignore templates

Typical .gitattribute

• gitattributes : Defining attributes per path

# https://git-scm.com/docs/gitattributes
* -text

*.aj -text
*.cfg -text
*.component -text
*.ftl -text
*.g -text
*.json -text
*.launch -text
*.mediawiki -text
*.MF -text
*.prefs -text
*.q -text
*.script -text
*.sol linguist-language=Solidity
*.tag -text
*.textile -text
*.tokens -text
.classpath -text
.clay -text
.euml2 -text
.fbprefs -text
.jsdtscope -text
.jshintrc -text
.lint4jprefs -text
.pmd -text
.project -text
.springBeans -text
.umlproject -text

# Declare files that will always have CRLF line endings on checkout.
*.sln text eol=crlf

# Denote all files that are truly binary and should not be modified.
*.a binary
*.o binary
*.so binary
*.lib binary
*.com binary
*.exe binary
*.dll binary
*.bin binary
# compressed files
*.zip binary
*.7z binary
# image files
*.png binary
*.jpeg binary
*.jpg binary
*.gif binary
*.bmp binary
*.tif binary
*.tiff binary
# media files
*.mp3 binary
*.mp4 binary
*.avi binary
*.flv binary
*.ico binary
# document files
*.doc binary
*.docx binary
*.xls binary
*.xlsx binary
*.ppt binary
*.pptx binary
*.pdf binary
# misc
*.class binary
*.jar binary