GIT cheatsheet

IMPORTANT!

• Remember you need to be in your git working directory (e.g., ~/Desktop/FIRST/terkel or ~/Desktop/FIRST/FTC-Team-25, or wherever you put your GIT directories) to do the git commands.
• it’s a good policy to keep your master branch, in your local repository and GitHub too, clean of changes you make, and only to pull things into it from upstream. Do your new work on a branch instead!
• origin is the default name of the remote git repository you cloned from
• When a repo is cloned, it has a default remote called origin that points to your fork on GitHub (for example, https://github.com/odacindy/terkel), not the original repo it was forked from (which was from github.com/cmacfarl/terkel). You will use upstream to fetch from the original repo (in order to keep your local copy in sync with the project you want to contribute to).
• The git fetch command imports commits from a remote repository into your local repo. The resulting commits are stored as remote branches instead of the normal local branches that we’ve been working with. This gives you a chance to review changes before integrating them into your copy of the project.
• Make sure that you tell GIT your user name and email when you first start doing GIT stuff ("git config --global user.name "Winnie Pooh") and ("git config --global user.email janedoe@rocknrollrobots25.com"0. Note that the "--global" indicates that this applies to all your repositories. If you only want it set for a single repository, remove the "--global" option.
• HEAD is the snapshot of your last commit. HEAD can point to any commit, it does not need to be the last commit in any branch. (When HEAD points to a commit that is not the last commit in a branch, that is a "detached HEAD"

List remote repository URLs and their shortcut names

• git remote -v

List all available branches

• git branch -a

Add a new shortcut name for a remote repository URL

• git remote add <shortcut_name> <url>
• Example: git remote add elixawu https://github.com/elixawu/master.git

Create a new local branch that is the same as someone else's remote branch

• git checkout -b <my_new_branch> <remote>/<branch_name>
• For example: git checkout -b mybranchname elixawu/master

If you haven't done it already, call craig's repository the shortcut name 'upstream'

• change directory to your git directories ~/Desktop/FIRST/terkel and ~/Desktop/FIRST/FTC-Team-25
• git remote add upstream https://github.com/cmacfarl/terkel (if you are in your terkel directory on your local machine)
• git remote add upstream https://github.com/cmacfarl/FTC-Team-25 (if you are in your FTC-Team-25 directory on your local machine)

Check difference between your local git directory and your remote repository (your https://github.com/<yourname>/<yourrepo.git> )

First do a fetch to download new commits from a remote repository into your local repository

• change directory to one of your git working directories
• git fetch origin master # which fetches the master branch from origin, which is the repository from which you cloned your local git directory

Then do one of the following types of diff after you've done the fetch :

• git diff origin/mybranch origin/master # how does my remote origin branch, mybranch, differ from my remote origin master branch (ONLY COMMITTED CHANGES!!)
• git diff origin/master-25 master-25 # how does my local branch master-25 differ from the remote origin master-25 branch (ONLY COMMITTED CHANGES!!)
• git diff origin/master-25 # how does my local branch master-25's uncommitted changes differ from the remote origin master-25 branch (UNCOMMITTED CHANGES!!)
• git diff mybranch someOtherRepo/master # how does my branch (only committed changes) differ from someone else's forked repo's master branch of the same repo. This assumes you already made a shortcut name, someOtherRepo, that points to a remote URL using the "remote add" command and fetched it (git fetch someOtherRepo)
• git diff remotename/branchname:remote/path/file1.txt local/path/file1.txt # To view the differences going from the remote file to the local file. Note that "remotename/branchname", "remote/path", and "local/path", should be replaced with your real names and paths.
• 
  
• The following will diff between a file (that you have already git fetched the remote branch) in a remote branch and the working directory
• git difftool DesG17/skystone_meet2:2020/opmodes/RollingStoneTeleop.java -- 2020/opmodes/RollingStoneTeleop.java
• git diff <my branch> origin/master -- <my relative path> says to diff between what was last committed to your branch and origin/master. From the git-diff man page...

   git diff [--options] <commit> [--] [<path>...]

       This form is to view the changes you have in your working tree relative to the

       named <commit>. You can use HEAD to compare it with the latest commit, or a

       branch name to compare with the tip of a different branch.

   git diff [--options] <commit> <commit> [--] [<path>...]

       This is to view the changes between two arbitrary <commit>.

You want to diff between the working copy and origin/master.

git diff origin/master -- <my relative path>

• If I am in my terkel/java/team25core directory, then I can send the following command to view the diff between my remote file and a file in my working directory
• git diff upstream/master:java/team25core/DeadmanMotorTask.java -- DeadmanMotorTaskLizzie.java
• If you want to see the difference as just the names of the files changed then use:

git diff --name-status <remote-branch> <local-branch>

Display the state of the working directory and the staging area. It lets you see which changes have been staged, which haven't, and which files aren't being tracked by Git

• git status

The git add command adds a change in the working directory to the staging area. It tells Git that you want to include updates to a particular file in the next commit.

• git add <yourFilename>

The git commit command commits the staged snapshot to the project history. In other words, after you add, modify, or delete a file, it doesn't really take effect until you do a "git commit"

• git commit -m <msgOfYourChanges>

After you've fetched origin master, you can merge it into your current branch

• git merge branchname # takes new commits from the branch branchname, and adds them to the current branch.
• For example: 'git fetch origin' followed by 'git merge origin/master'

Fetch

• git pull is basically the same as git fetch; git merge origin/master.

Steps to take if you want to make a new change in your local repository

• create a new Git branch, based on master, for new work to go into (git checkout -b yourNewBranchName)
• edit your file(s) and stage your changes: after you've finished creating/editing your file, then you add the new file to your local repository and stage it for commit by typing 'git add your-filename'
• commit your changes (git commit -m "msg describing the changes you made" )
• NOTE: you can combine the above two commands by doing "git commit -m "msg describing your changes" -a // where the "-a" flag indicates that we are staging the file changes for commit
• push your changes to GitHub (git push origin yourNewBranchName)
• In GitHub make a pull request if you want to ask craig or someone else to merge in your changes. From github.com/<yourGithubName>/<yourRepoName>, check if your new branch is there and your new changes are there first. If it looks okay you can make a pull request to cmacfarl's master branch to see if craig wants to merge in your changes

Steps to take if you want to take a branch from someone's github repository

• git remote add theirusername https://github.com/theirusername/reponame.git
• git fetch theirusername
• git checkout -b mynamefortheirbranch theirusername/theirbranch
• now you have a local branch with their stuff, so you can make changes. Remember if you add any files you must do a (git add your-new-filename). If you add or modify any files, you must also do a (git commit -m "msg describing changes" -a ) where the "-a" adds the file modifications in the staging area for commit
• (git status) is a useful command that shows you which changes have been staged, which haven't, and which files aren't being tracked by Git
• Once you've committed all your changes, you can push the changes to your GitHub repository (git push <remote_name> <branch name>). For example: 'git push origin myBranchName'

Different kinds of GIT diffs

• First type "git branch -a" to get a list of available branches
• If you just want to see the files and the number of changes between two commits using "--stat" (git diff --stat --color remotes/upstream/master-25..origin/master-25)
• If you want to diff between two remote branches, upstream and origin (git diff --color remotes/upstream/master-25..origin/master-25)
• If you want to diff between your local and remote, first fetch the branch named 'master' from the remote named 'origin' (git fetch origin master) When the remote branch is fetched, it can be referenced locally via FETCH_HEAD. The command (git diff --summary FETCH_HEAD ) tells git to diff the working directory files (includes uncommitted files) against the FETCHed branch's HEAD and report the results in summary format. Summary format gives an overview of the changes, usually a good way to start
• git diff --color master-25 origin/master-25 // diff between your local (committed .vs. uncommitted) master-25 branch and the origin/master branch (don't forget to 'git fetch origin master' first to make sure you have the latest commits)
• If you're on a given branch, and you want to compare it with an upstream branch you're tracking, use (git diff @ @{upstream} ) @ is HEAD, which is where you are now (committed changes), so you are comparing HEAD with the upstream your branch is tracking. You can use @{push} instead of upstream to get diff between the branch you are set to push to. The HEAD in Git is the pointer to the current branch reference, which is in turn a pointer to the last commit you made or the last commit that was checked out into your working directory. That also means it will be the parent of the next commit you do. It's generally simplest to think of it as HEAD is the snapshot of your last commit.

Difference between local and remote repository

The git fetch command imports commits from a remote repository into your local repo without merging those changes into your own branches.

• get fetch <remotename> where <remotename> is the URL or shortcut name (e.g., git fetch origin) or (git fetch elixawu) assuming you've already made shortcutname elixawu previously using (git remote add elixawu https://github.com/elixawu/master.git) or (git fetch https://github.com/elixawu/master.git) if you haven't made a shortcutname
• List all branches (git branch -a)
• Switch to the local branch you want to do the difference with "git checkout <your_local_branchname>". For example (git checkout breannas_branch)
• Check the difference between your local branch (e.g., breannas_branch) and the remote branch which you just fetched (git diff <remotename>/<branch_name> <your_local_branchname>) if you provide the local branch name. it will diff against your committed local repository. If you omit your local branch name, it diffs against the working directory which includes uncommitted changes.

Difference between remote and local files

• Add shortcut name for remote repository (e.g., git remote add breanna https://github.com/bwchan00/FTC-Team-25.git)
• git fetch <remote_shortname> <remote_branch_name> (e.g., git fetch breanna BreannaTeleop)
• cd ~/Desktop/GITstuff/FTC-Team-25/2017/opmodes
• git difftool breanna/BreannaTeleop:2017/opmodes/VioletTeleop.java -- VioletTeleop.java

How to change the URL for origin

• git remote set-url --push origin https://github.com/<your_github_name>/<yourgitrepo.git>
• OR edit .git/config and change the URLs there

What to do if delete file without "git remove" (now it is in repo, but not local. How to remove it from repo)

• The files are stored in your git repository but they are no longer part of your working directory
• Once git track files which you wish to remove you will have to first remove them from the cache (index). e.g., git rm --cached <list of deleted files>

How to Revert uncommited changes

• Good idea to run 'git clean -nd' to preview the changes before running git clean to ensure you don't have untracked files or directories that you care about that will be removed
• git clean -i for an interactive mode
• # Remove all untracked files and directories. (`-f` is `force`, `-d` is `remove directories`)

git clean -fd

• 'git reset --hard' will undo both staged and unstaged changes, whereas 'git checkout -- .' will undo only unstaged changes in your current working directory
• git checkout -- will simply list the files that will be reverted (no action, just list). This is useful if you want to see what files will be affected before doing git checkout -- .
• To undo all the changes you’ve introduced since the last commit, use the following command:

git reset --hard

This command reverts the repo to the state of the HEAD revision, which is the last committed version. Git discards all the changes you made since that point.

Other times, you may want to only discard the changes to one file in the repo. You can do this with the checkout command:

git checkout -- path/to/the/file.txt

Use the checkout command with two dashes, then the path to the file for which you want to revert to its previous state.

git diff (no parameters)

Print out differences between your working directory and the index (staging area).

git diff --cached:

HEAD: the current commit your repo is on. Most of the time HEAD points to the latest commit in your branch, but that doesn't have to be the case. HEAD really just means "what is my repo currently pointing at".

Print out differences between the index and HEAD (current commit).

git diff HEAD:

Print out differences between your working directory and the HEAD.

git diff --name-only

Show only names of changed files.

git diff --name-status

Show only names and status of changed files.

git diff --color-words

Word by word diff instead of line by line.

Check the difference between the working directory in my current branch against the working directory of another branch in a specific file? For example, if I'm working in branch A on file 1, I want to compare the difference with file 1 on branch B.

• git diff branchA branchB -- file.cs

put the two names of your branches and optionally use the -- filename option to specify one file

• If you don't pass anything, it shows the entire branch diff. git diff branchA branchB
• git diff branchA branchB file.cs - diff on that 1 file
• git diff branchA branchB some/path/in/rep some/other/path - diffs two directories
• If you're on one branch, called mybranch, and want to compare the file build.gradle to the same version on the master branch:

git diff master build.gradle

• Diff between different files on different branches

git diff branch1:full/path/to/foo.txt branch2:full/path/to/foo-another.txt

• git difftool and then drop the branch2: and that will allow you to edit a file in the current working tree (to bring over changes from branch1 git difftool branch1:full/path/to/foo.txt full/path/to/foo-another.txt
• git diff --name-status branch1..branch2 // shows you which files differ between branch1 and branch2
• How to extract a file from another branch into current working directory that was different from the file's original location. Answer:

git show TREEISH:path/to/file >path/to/local/file

• Another method:

1) Ensure you're in branch where you need a copy of the file. for eg: i want sub branch file in master so you need to checkout or should be in master git checkout master

2) Now checkout specific file alone you want from sub branch into master,

git checkout sub_branch file_path/my_file.ext

here sub_branch means where you have that file followed by filename you need to copy.

• Working on master branch with app.js file. Want to bring experiment's app.js from experiment to master branch without merging

git checkout master               # first get back to master

git checkout experiment -- app.js # then copy the version of app.js 

                                  # from branch "experiment"

• another way: git show experiment:path/to/app.js > app.js // need to use the full path from the root directory of the repo
• one more way:

But, for git checkout or git show, you can actually reference any revision you want, as illustrated in the SO question "git checkout revision of a file in git gui":

$ git show $REVISION:$FILENAME

$ git checkout $REVISION -- $FILENAME

would be the same is $FILENAME is a full path of a versioned file.

$REVISION can be as shown in git rev-parse:

experiment@{yesterday}:app.js # app.js as it was yesterday 

experiment^:app.js            # app.js on the first commit parent

experiment@{2}:app.js         # app.js two commits ago