Welcome to the website of Davis Fiore

Misc - What is Git?

Sun, 11/16/2014 - 22:03 |

admin

Git is a distributed version control system.

The code go through four stages:

Workspace (local copy
Index (staging)
Local repository (cmmitted files)
Remote respository

Here's a synopsis of the transitions and related commands:

git add --> from workspace to index
git commit -a --> from worspace to local repository
git commit --> from index to local repository
git push --> from local repository to remote repository
git pull --> from remote repository to workspace
git fetch --> from remote repository to local copy of the remote repository (origin/<branch-name>)
git checkout HEAD --> from local repository to workspace
git checkout --> from index to workspace
git diff HEAD --> between workspace and local repository
git diff --> between index and workspace
git merge --> from the local copy of the remote repository to the local repository

The most common commands follows.

Configure the username:

	git config --global user.name "Davis Fiore"

Configure the email:

	git config --global user.email [email protected]

List all the configuration:
```
	git config --list
```
Initialize directory:
```
	git init
```
Add all the files to the staging area:
```
	git add *
```
Show changes between working area and staging area:
```
	git diff
```
Specify a path if you intend to limit the scope.
Show changes between working area and local repository:
```
	git diff HEAD
```
Show changes between staging area and local repository:
```
	git diff --cached HEAD
or
        git diff --cached
```
The option --staged has the same effect.
Show the difference between two branches:
```
	git diff branch1..branch2
```
Show the difference between two commits:
```
	git diff hash1 hash2
```
Show commits that differ between two branches:
```
	git log branch1..branch2
```
Stage and commit all the files:
```
	git commit -a -m 'My comment'
```
Stage and commit separately:
```
	git add myfile.txt
	git commit -m 'My comment'
```
If you created or changed a file and you didn't add it to the staging area, it will be ignored during the commit.
Delete a file:
```
	rm myfile.txt 
	git rm myfile.txt
```
Show previous commits:
```
	git log
```
Show previous commits in a more graphical manner and with more information:
```
        git log --oneline --decorate --graph --all
```
Show the last commit:
```
	git show
```
Show the a specific commit:
```
	git show commit_hashcode
```
Show a log of any repository change:
```
	git reflog
```
Show who last changed each line of code:
```
	git blame filename
```
Update the last commit with the changes added to the index:
```
	git commit --amend 
```
Use --no-edit if you don't want to modify the comment.
Create a local copy of a repository:
```
	git clone respotiory_url
```
Update the local copy of the remote repository:
```
	git fetch repository_name
```
Update the local repository, performing a merge:
```
	git pull repository_url
```
The local copy of the remote repository is update first, with a fetch. Then a merge is perfomed to update the local repository from the copy of the remote repository. The option --rebase is used to perform a rebase instead of a merge.
Push the changes:
```
	git push
```
The first time you push, use the option -u to link your local repository to the repome one.
Add a tag:
```
	git tag tag_name
```
The tag create is lightweight (just a reference). Use the option -a for an annotated tag (actual object).
Show a tag:
```
	git show tag tag_name
```
List the tags:
```
	git tag -l
```
Filter tags:
```
	git tag -l "2.0*"
```
Show the differences between two tags:
```
	git diff tag1 tag2
```
Delete a tag:
```
	git tag tag_name --delete
```
Push a single tag:
```
	git push origin tag_name
```
Push all the tags:
```
	git push origin --tags
```
Push only annotated tags:
```
	git push origin --follow-tags
```
It's a good practice to push only annotated tags.
Delete a tag on the remote repository:
```
	git push origin :tag_name
```
Create and switch to a branch, using the current branch as source:
```
	git checkout -b branch_name
```

Create and switch to a branch:

	git checkout -b branch_name source_branch_name

Switch to a branch:
```
	git checkout branch_name
```
Update a path from the index (it doesn't switch branch):
```
	git checkout path
```
Undo changes to one file:
```
	git checkout -- file_name
```
Show the current branch:
```
	git branch
```
Create a branch, but don't switch to it:
```
	git branch branch_name
```
Delete a local branch:
```
	git branch -d branch_name
```
Delete a remote branch:
```
	git push origin --delete branch_name
```
Merge a branch with the branch currently checked out:
```
	git merge branch_name
```
When the merge fails because of a conflict, you need to fix the conflicts and then commit. But merge commits automatically when there are no conflicts.

Also, note that branch_name merge with the local copy of the branch, whereas "origin/branch_name" merge with the remote version.
Open a tool for merging:
```
	git mergetool
```
Update current branch with changes from an other branch:
```
	git rebase other_branch
```
Apply changes from a specific commit to the local branch:
```
	git cherry-pick commit_hashcode
```
Revert the commit by adding a new one:
```
	git revert commit_hash
Or
	git revert HEAD
```
Note that HEAD is the last commit in the current branch.
Undo one or more commits and discard local changes
```
	git reset --hard commit_hash
```
Undo one or more commits, but don't discard local changes or staged changes:
```
	git reset --soft commit_hash
```
Undo one or more commits, unstage any staged files, but don't discard local changes:
```
	git reset commit_hash
```
Discard local changes and changes in the index:
```
	git reset --hard HEAD
```
Unstage a file (remove the changes from the index):
```
	git reset HEAD file_name
```
Same behavior if HEAD is omitted. Without filename, it applies to all the files.

In alternative:
```
	git rm --cached file_name
```
This makes a file untracked and it's the opposite of "git add". A file needs to be untracked in order to be ignored (see .gitignore)
Display each difference in the worktree:
```
	git status
```
Save your changes away for later use:
```
	git stash
```
This is used when you need to temporarily switch to a different branch.
Use the option --index option, if you want to consider the stagin area as well.
Re-apply last stash:
```
	git stash apply
```
List the stashes:
```
	git stash list
```
Show a specific stash:
```
	git stash show [email protected]{2}
```
stash including untracked files:
```
	git stash -u
```
Drop last stash:
```
	git stash drop 
```
Apply and drop last stash:
```
	git stash pop 
```
Clear all the stashes:
```
	git stash clear 
```
List the tags:
```
	git tag -l
```
Checkout a tagged version:
```
	git checkout tags/tag_name
```
Push a tag upstream:
```
	git push --tags
```
Push upstream a newly create branch (one-off command):
```
	git push --set-upstream origin my_branch
```

Associate an URL to the name "origin":

	git remote add origin https://[email protected]/myproject/mygit.git

Show the urls associated to the keyword "origin":
```
	git remote -v 
```
Remove untracked files and directories (-d), forcefully (-f):
```
	git clean -df .
```