Git Command Reference

.GitCommandReference.sh

Directory:    A folder used for storing multiple files.
Repository:   A directory where Git has been initialized to start version controlling your files.

The .git directory: It is usually hidden. It has all sorts of directories and files inside it. 
              We rarely ever need to do anything inside here 

Staging Area: A place where we can group files together before we COMMIT them to Git.
Commit:       A COMMIT is a snapshot of our repository. 
              This way if we ever need to look back at the changes we have made 
              (or if someone else does), we will see a nice timeline of all changes.


git init    #Create an empty Git repository or reinitialize an existing one

git status  #Show the working tree status

git add     # Add file contents to the index

git commit  #Record changes to the repository

git log     #Show commit logs

git remote  #Manage set of tracked repositories

git push    #Update remote refs along with associated objects

git pull    #Fetch from and integrate with another repository or a local branch

git stash   #Stash the changes in a dirty working directory away

.GitDataTrasportCommands.md

GitAdd.sh

GIT ADD ========================================================================

  # Add file contents to the index

git add   [-n] [-v] [--force | -f] [--interactive | -i] [--patch | -p]
          [--edit | -e] [--[no-]all | --[no-]ignore-removal | [--update | -u]]
          [--intent-to-add | -N] [--refresh] [--ignore-errors] [--ignore-missing]
          [--] [<pathspec>…]
          
  # updates the index using the current content found in the working tree, to 
  # prepare the content staged for the next commit. 
  # It typically adds the current content of existing paths as a whole, 
  # This command can be performed multiple times before a commit. 
  # The git add command will not add ignored files by default. 

git add -f / git add --force 

  # Allow adding otherwise ignored files.
  
  # Example:
$ git add Documentation/\*.txt
  # Adds content from all *.txt files under Documentation directory and its subdirectories
  
  # Wildcard *
$ git add '*.txt'
  
git add -A
  # You can also type git add -A . where the dot stands for the current directory, 
  # so everything in and beneath it is added. The -A ensures even file deletions are included.
  
git reset:
You can use git reset <filename> to remove a file or files from the staging area.

GitCommit.sh

GIT COMMIT =====================================================================

  #Record changes to the repository
  
git commit [-a | --interactive | --patch] [-s] [-v] [-u<mode>] [--amend]
           [--dry-run] [(-c | -C | --fixup | --squash) <commit>]
           [-F <file> | -m <msg>] [--reset-author] [--allow-empty]
           [--allow-empty-message] [--no-verify] [-e] [--author=<author>]
           [--date=<date>] [--cleanup=<mode>] [--[no-]status]
           [-i | -o] [-S[<key-id>]] [--] [<file>…]
           
  # Stores the current contents of the index in a new commit along with a log 
  # message from the user describing the changes.
  # The content to be added can be specified in several ways:
  #   by using git add to incrementally "add" changes to the index before using 
  #     the commit command (Note: even modified files must be "added");
  #   by using git rm to remove files from the working tree and the index, again 
  #     before using the commit command;
  #   by listing files as arguments to the commit command, in which case the 
  #     commit will ignore changes staged in the index, and instead record the 
  #     current content of the listed files (which must already be known to Git);
  #   by using the -a switch with the commit command to automatically "add" 
  #     changes from all known files (i.e. all files that are already listed in 
  #     the index) and to automatically "rm" files in the index that have been 
  #     removed from the working tree, and then perform the actual commit;
  #   by using the --interactive or --patch switches with the commit command to 
  #   decide one by one which files or hunks should be part of the commit, 
  #   before finalizing the operation. 
  
  # If you make a commit and then find a mistake immediately after that, you can 
  # recover from it with git reset.   
  
-m <msg>
--message=<msg>
  # Use the given <msg> as the commit message. If multiple -m options are given, 
  # their values are concatenated as separate paragraphs.
  
$ git commit -m "Add cute octocat story"

GitInit.sh

GIT INIT =======================================================================

  #Create an empty Git repository or reinitialize an existing one
  
git init  [-q | --quiet] [--bare] [--template=<template_directory>]
          [--separate-git-dir <git dir>]
          [--shared[=<permissions>]] [directory]


  # This command creates an empty Git repository - basically a .git directory 
  # with subdirectories for objects, refs/heads, refs/tags, and template files. 
  # An initial HEAD file that references the HEAD of the master branch is also created.
  
  # If the $GIT_DIR environment variable is set then it specifies a path to use 
  # instead of ./.git for the base of the repository.

  # If the object storage directory is specified via the $GIT_OBJECT_DIRECTORY 
  # environment variable then the sha1 directories are created underneath - 
  # otherwise the default $GIT_DIR/objects directory is used.

GitLog.sh

GIT LOG ========================================================================

  #Show commit logs
 
git log [<options>] [<revision range>] [[--] <path>…]

  # The command takes options applicable to the git rev-list command to control 
  # what is shown and how, and options applicable to the git diff-* commands to 
  # control how the changes each commit introduces are shown.
  
--summary
  # Output a condensed summary of extended header information such as creations, 
  # renames and mode changes.
  

GitPull.sh

GIT PULL =======================================================================

  #Fetch from and integrate with another repository or a local branch
  
git pull [options] [<repository> [<refspec>…]]

  # Incorporates changes from a remote repository into the current branch. 
  # In its default mode, git pull is shorthand for git fetch followed by git merge FETCH_HEAD.
  # More precisely, git pull runs git fetch with the given parameters and calls 
  # git merge to merge the retrieved branch heads into the current branch. 
  # With --rebase, it runs git rebase instead of git merge.

  # <repository> should be the name of a remote repository as passed to git-fetch(1). 
  # <refspec> can name an arbitrary remote ref (for example, the name of a tag) 
  # or even a collection of refs with corresponding remote-tracking branches 
  # (e.g., refs/heads/*:refs/remotes/origin/*), but usually it is the name of a 
  # branch in the remote repository.

  # Default values for <repository> and <branch> are read from the "remote" and 
  # "merge" configuration for the current branch as set by git-branch(1) --track.

GitPush.sh

GIT PUSH =======================================================================

  #Update remote refs along with associated objects
  
git push  [--all | --mirror | --tags] [--follow-tags] [-n | --dry-run] [--receive-pack=<git-receive-pack>]
          [--repo=<repository>] [-f | --force] [--prune] [-v | --verbose] [-u | --set-upstream]
          [--force-with-lease[=<refname>[:<expect>]]]
          [--no-verify] [<repository> [<refspec>…]]
          

  # Updates remote refs using local refs, while sending objects necessary to complete the given refs.
  # You can make interesting things happen to a repository every time you push into it, 
  # by setting up hooks there. See documentation for git-receive-pack(1).
  
  # For example, you can upload directly to a webserver whenever you push to your 
  # master remote instead of having to upload your site with an ftp client. 
  # Check out Customizing Git - Git Hooks for more information.

  # When the command line does not specify where to push with the <repository> argument, 
  # branch.*.remote configuration for the current branch is consulted to determine where to push. 
  # If the configuration is missing, it defaults to origin.

  # When the command line does not specify what to push with <refspec>... 
  # arguments or --all, --mirror, --tags options, the command finds the default 
  # <refspec> by consulting remote.*.push configuration, and if it is not found, 
  # honors push.default configuration to decide what to push 
  # (See gitlink:git-config[1] for the meaning of push.default).
  
-u <dir> <dir>
  #The -u tells Git to remember the parameters, so that next time we can simply 
  #run git push and Git will know what to do. Go ahead and push it. 

GitRemote.sh

GIT REMOTE =====================================================================

  #Manage set of tracked repositories

git remote [-v | --verbose]
  #With no arguments, shows a list of existing remotes. 
  
git remote add  [-t <branch>] [-m <master>] [-f] [--[no-]tags] 
                [--mirror=<fetch|push>] <name> <url>
  # Adds a remote named <name> for the repository at <url>. 
  # The command git fetch <name> can then be used to create and update 
  # remote-tracking branches <name>/<branch>.
  
git remote rename <old> <new>
  # Rename the remote named <old> to <new>. 
  # All remote-tracking branches and configuration settings for the remote are updated.

git remote remove <name>
  # Remove the remote named <name>. 
  # All remote-tracking branches and configuration settings for the remote are removed.

git remote set-head <name> (-a | --auto | -d | --delete | <branch>)
  # Sets or deletes the default branch (i.e. the target of the symbolic-ref refs/remotes/<name>/HEAD) for the named remote.
  
git remote set-branches [--add] <name> <branch>…
  # Changes the list of branches tracked by the named remote. 
  # This can be used to track a subset of the available remote branches after the initial setup for a remote.

git remote set-url
  # Changes URL remote points to. 
  # Sets first URL remote points to matching regex <oldurl> 
  # (first URL if no <oldurl> is given) to <newurl>. 
  # If <oldurl> doesn’t match any URL, error occurs and nothing is changed.
  
git remote set-url [--push] <name> <newurl> [<oldurl>]
  #With --push, push URLs are manipulated instead of fetch URLs.
git remote set-url --add [--push] <name> <newurl>
  #With --add, instead of changing some URL, new URL is added.
git remote set-url --delete [--push] <name> <url>
  #With --delete, instead of changing some URL, all URLs matching regex <url> are deleted. 
  #Trying to delete all non-push URLs is an error.

git remote [-v | --verbose] show [-n] <name>…
  #Gives some information about the remote <name>.

git remote prune [-n | --dry-run] <name>…
  #Deletes all stale remote-tracking branches under <name>. 
  #These stale branches have already been removed from the remote repository 
  #referenced by <name>, but are still locally available in "remotes/<name>".
  
git remote [-v | --verbose] update [-p | --prune] [(<group> | <remote>)…]
  #Fetch updates for a named set of remotes in the repository as defined by remotes.<group>. 

GitStash.sh

GIT STASH ======================================================================

  # Stash the changes in a dirty working directory away
  
git stash list [<options>]
git stash show [<stash>]
git stash drop [-q|--quiet] [<stash>]
git stash ( pop | apply ) [--index] [-q|--quiet] [<stash>]
git stash branch <branchname> [<stash>]
git stash [save [-p|--patch] [-k|--[no-]keep-index] [-q|--quiet]
             [-u|--include-untracked] [-a|--all] [<message>]]
git stash clear
git stash create [<message>]
git stash store [-m|--message <message>] [-q|--quiet] <commit>

  # Use git stash when you want to record the current state of the working directory 
  # and the index, but want to go back to a clean working directory. 
  # The command saves your local modifications away and reverts the working directory 
  # to match the HEAD commit.

  #The modifications stashed away by this command can be listed with git stash list, 
  #inspected with git stash show, and restored (potentially on top of a different 
  #commit) with git stash apply. Calling git stash without any arguments is equivalent 
  #to git stash save. A stash is by default listed as "WIP on branchname …", 
  #but you can give a more descriptive message on the command line when you create one.

  #The latest stash you created is stored in refs/stash; older stashes are found in 
  #the reflog of this reference and can be named using the usual reflog syntax (e.g. 
  #stash@{0} is the most recently created stash, stash@{1} is the one before it, 
  # stash@{2.hours.ago} is also possible).
  

GitStatus.sh

GIT STATUS =====================================================================

  # Show the working tree status

git status [<options>…] [--] [<pathspec>…]

  # Displays paths that: 
  #   have differences between the index file and the current HEAD commit, 
  #   have differences between the working tree and the index file, 
  #   are not tracked by Git but are in the working tree (and are not ignored by gitignore(5)). 
  # The first are what you would commit by running git commit; the second and 
  # third are what you could commit by running git add before running git commit.

# Staged:   Files are ready to be committed.
# Unstaged: Files with changes that have not been prepared to be committed.
# Untracked:Files aren't tracked by Git yet. 
#          This usually indicates a newly created file.
# Deleted:  File has been deleted and is waiting to be removed from Git.

# It's healthy to run git status often. Sometimes things change and you don't notice it.