'git diff' between a remote and local repository

Question

I am trying to diff my local file with a GitHub repository before I submit a pull request, so I can see what will show up. Is there an accurate way of doing this?

I assume GitHub's compare tool manipulates Git's diff.

Solution 1

Don't do a pull :

• do a fetch (the syntax is the same as git pull, but it doesn't automatically merge)
• do a diff between your dest branch and the other branch
• then do a merge if you want

Solution 2

To compare a local working directory against a remote branch, for example origin/master:

1. git fetch origin master
   This tells git to fetch the branch named 'master' from the remote named 'origin'. git fetch will not affect the files in your working directory; it does not try to merge changes like git pull does.
2. git diff --summary FETCH_HEAD
   When the remote branch is fetched, it can be referenced locally via FETCH_HEAD. The command above tells git to diff the working directory files against 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. If you want a bit more info, use --stat instead of --summary.
3. git diff FETCH_HEAD -- mydir/myfile.js
   If you want to see changes to a specific file, for example myfile.js, skip the --summary option and reference the file you want (or tree).

As noted, origin references the remote repository and master references the branch within that repo. By default, git uses the name origin for a remote, so if you do git clone <url> it will by default call that remote origin. Use git remote -v to see what origin points to.

You may have more than one remote. For example, if you "fork" a project on GitHub, you typically need a remote referencing the original project as well as your own fork. Say you create https://github.com/yourusername/someproject as a fork of https://github.com/theoriginal/someproject. By convention, you would name the remote to the original repo upstream, while your own fork would be origin. If you make changes to your fork on GitHub and want to fetch those changes locally, you would use git fetch origin master. If the upstream has made changes that you need to sync locally before making more changes, you would use git fetch upstream master.

Solution 3

Per the OP's comment that part of his "problem was Windows vs. Unix LFs", this should help:

You can use the following configuration command to tell git-diff to ignore the difference of the EOL code.

git config --global core.whitespace cr-at-eol

Solution 4

You can use: git diff remote/my_topic_branch my_topic_branch

Where my_topic_branch is your topic branch.

View more solutions

Comments

[paxdiablo]

Upvoting since it provides more detail than other answers.

[Michael Harris]

Upvoted for the detail and explanations of context. If someone is asking this question they are probably starting out with git. Context and clear explanations are important when you're trying to wrap your head around a new technology, and it certainly never hurts.

[Randall]

I'd add: 2b. git diff --stat FETCH_HEAD to provide a bit more info if --summary wasn't enough.

[Nuetrino]

If I want to avoid merge conflicts before i push my changes. Is it best to do a fetch and then do a diff of my local working directory with the FETCH_HEAD and then do a push if everything is okay?

[DylanYoung]

core.autocrlf is another useful setting for handing system newline differences

[Pedro García Medina]

What if after doing the comparison I decide I do not want to merge my local branch with the remote one; is there a way to "unfetch" the remote branch?

[HieroB]

Pedro: Fetch writes into the file .git/FETCH_HEAD, and you reference the contents via FETCH_HEAD. If you don't merge them, they will not change your local branch. The contents of .git/FETCH_HEAD are overwritten with the next fetch, so usually you can just leave it. I don't know of a git command to explicitly clear FETCH_HEAD.