When reviewing GitHub pull requests, I sometimes want to get the proposed
code onto my own machine, for running it, or just reading it in my own
editor. Here are a few ways to do it, with a digression into git/alias/shell
weirdness tacked on the end.

If the pull request is from a branch in the same repo, you can just check out
the branch by name:

$ git checkout joe/proposed-feature

But you might not remember the name of the branch, or it might be in a different
fork. Better is to be able to request the code by the pull request number.

The first technique I found was to modify the repo's .git/config file so that when
you fetch code from the remote, it automatically pulls the pull request
branches also. On GitHub, pull requests are at refspecs like "refs/pull/1234"
(no, I don't really know what refspecs are, but I look forward to the day
when I do...) Bert Belder wrote
up a description of how to tweak your repo to automatically pull down
all the pull request branches. You add this line to the [remote "origin"]
section of your .git/config:

fetch = +refs/pull/*/head:refs/remotes/origin/pr/*

Now when you "git fetch origin", you'll get all the pull request branches,
and you can simply check out the one you want with "git checkout pr/1234".

But this means having to edit your repo's .git/config file before you can get the
pull request code. If you have many repos, you're always going to be finding
the ones that haven't been tweaked yet.

A technique I liked better is on Corey Frang's gist, provided by Rico Sta. Cruz:
Global .gitconfig aliases
for pull request management. Here, you update your single ~/.gitconfig
file to define a new command that will pull down a pull request branch when
you need it:

This technique has the advantage that once you define the alias, it's
available in any repo, and also, it both fetches the branch and switches
you to it.

BTW: finding and collecting these kinds of shortcuts can be daunting, because
if you don't understand every bit of them, then you're in cargo-cult
territory. "This thing worked for someone else, and if I copy it here, then
it will work for me!"

In a few of the aliases on these pages, I see that the commands end with "&& :".
I asked about this in the #git IRC channel, and was told that it was pointless:
"&&" joins two shell commands, and runs the second one if the first
one succeeded, and ":" is a shell built-in that simply succeeds (it's the same
as "true"). So what does "&& :" add to the command? Seemed like it
was pointless; we were stumped.

Then I also asked why other aliases took the form they did. Our copr alias
has this form:

"!f() { command1; command2; }; f"

The bang character escapes from git syntax to the shell. Then we define a
shell function called f with two commands in it, then we call the
function. Why define the function? Why not just define the alias to be the
two commands?

More discussion and experimentation turned up the answer. The way git
invokes the shell, the arguments to the alias are available as $1, $2, etc,
but they are also appended to the command line. As an example, let's
define three different git aliases, each of which uses two arguments:

The second one works because the ":" command eats up the extra arguments.
The third one works because the eventual command run is "f one two", so the
values are passed to the function. So the "&& :" wasn't pointless
afterall, it was needed to make the arguments work properly.

From previous cargo-cult expeditions, my ~/.gitconfig has other aliases using
a different form:

All of them work, I like the function-defining one best, it seems most
programmery, and least shell-tricky. I'm sure there's something here I'm
misunderstanding, or a subtlety I'm overlooking, but I've learned stuff
today.

I don't know what appending "&& :" achieves, but appending "|| :" to a command is used to ensure the exit value of the composite command is always zero. Maybe that is what was intended? I don't know if that's useful in this context though.