GitHub Cheat Sheet

[holman]

As mentioned, these are cribbed from my Git & GitHub Secrets talk: http://zachholman.com/talk/git-github-secrets/

If you're interested in the arcane side of Git and GitHub, you might also be interested in the follow-up talk I've given a few times the last half-year or so, which details a bunch of other new things: http://zachholman.com/talk/more-git-and-github-secrets/

I'm more of a fan of the second talk, myself. My favorite thing I discovered while making the second talk was the "second-order-diff Git trick", which Tom Moertel came up with here: http://blog.moertel.com/posts/2013-02-18-git-second-order-di...

[CyberShadow]

> Adding `#L52` to the end of a code file URL will highlight that line number.

You can click the line number (in the column to the left of the code) to add the fragment to the URL, and Shift+click to select a range. Easier than editing the URL directly.

[roryokane]

The cheat sheet has been updated to include that: https://github.com/tiimgreen/github-cheat-sheet/commit/a6d33...

[daGrevis]

One shouldn't alias 'git add . && git commit' to 'git ac'. You should always check what you are about to commit with 'git status' and 'git diff'.

[conradev]

Another great tool to understand what you are committing is to add each chunk individually using `git add -p`.

[epidemian]

If you have already checked that all unstaged changes should get included in the commit with `git st`, then i think doing `git ac` makes sense.

I would, however, use `add -u` instead of `add .`, but that's mostly because i'm messy and its not unusual for me to have some local files which i don't want to commit -- e.g., one-off scripts, temporary SQL dumps, etc. YMMV.

[jballanc]

One that's missing that I've found rather useful: add ".pibb" to the end of any Gist URL to get the "HTML Only" version suitable for embedding in any other site. Time was, before a lot of blogging engines had GitHub integration, this was the best way to get code on your blog.

[rafal_chmiel]

That's cool. Added (https://github.com/tiimgreen/github-cheat-sheet/commit/b4142...).

[canadev]

Interesting, I like the "git status -sb" (short, show branch tracking info) command. The query one seems a lot like "git grep" to me, I am not sure I understand the difference.

The specified "git ac" alias (git add . && git commit) is bad news, in my book. I've seen people accidentally commit extra files using "git add ." .

I much prefer "git add -p" for tracked files; the git tab completion for the shell seems to be pretty good about picking up untracked files using "git add <TAB>" as well. (https://github.com/git/git/tree/master/contrib/completion)

[masklinn]

> The query one seems a lot like "git grep" to me, I am not sure I understand the difference.

1. shows only the most recent matching commit

2. git grep is essentially `grep` customised to the working copy (by default), you probably mean git log --grep

3. `:/foo` is actually a general revisions specifier, see third from bottom in section SPECIFYING REVISIONS of gitrevisions(7), so you should be able to use it anywhere you need to specify a revision (not that I can see much use for it outside of log and show at the moment)

[lubomir]

Could someone give me a usecase for when an empty commit might be useful?

[davej]

Annotating the start of a new bulk of work or a new feature. Documenting when you make changes to the project that aren't code related, e.g. "Now using GitHub for issue tracking, closes #1". Communicating with people using your repo, e.g. "Merry Christmas y'all, I'm away for three weeks, if you have any questions please contact Jim".

I'm not saying doing any of these things is good practice but they are use-cases for when an empty commit might make sense.

[daGrevis]

To tell CI (for example, Jenkins) to rebuild.

[epidemian]

To make a commit to a Gist look the same as changes done through the web interface.

Edit: sorry, i was thinking about --allow-empty-message, not --allow empty.

[nahname]

Opening a PR to discuss a new feature before it is built.

[raju]

I usually initialize my git repos with an empty commit. Several reasons why this is a good idea (detailed in this blog post - http://kevin.deldycke.com/2010/05/initialize-git-repositorie...)

I have a git alias for the same -

  start = !git init && git commit --allow-empty -m \"chore: empty initial commit\"

Note: That's not my blog.

[Myrmornis]

Gists are an easy way to work with small bits of code without creating a fully fledged repo

What is the disadvantage of working with a "fully fledged repo"? Gists unecessarily fragment git workflows. For example, how do I convert my work (a git repo like all projects) into a gist? gists should have been designed as an alternative way of viewing repos, not as a slightly different species of repo.

[sampo]

> "To see all of the shortcuts for given page type shift+?"

Actually just ? suffices.

Source: the list of shortcuts shown by typing ? on a GitHub page.

[delluminatus]

I guess it would be more accurate to call it "shift+/"

[roryokane]

In the U.S. keyboard layout, you have to press Shift-/ to type ‘?’. Listing Shift is a good reminder for those people, who are the majority of readers.

[lelandbatey]

Something also to know is there are multiple ways to embed images in wiki pages. There's the standard Markdown syntax, but there's also a syntax that allows things like specifying the height or width of the image. Example:

    [[ image location | height = 300px ]]

[rafal_chmiel]

Thanks a lot. Added (https://github.com/tiimgreen/github-cheat-sheet#embedding-im...).

[jdkanani]

`git instaweb` is also one of great secrets of Git that GitHub uses very effectively.

[roryokane]

About `git instaweb` (http://git-scm.com/docs/git-instaweb):

git-instaweb instantly configures and launches a webserver running gitweb (which is built into Git).

gitweb (http://git-scm.com/docs/gitweb) is a “Git web interface (web frontend to Git repositories)”. It lets you browse commits, branches, etc.

[davej]

I alias `gti` -> `git`. I'm always mistyping it, not sure why.

[perlgeek]

I tend to type `gi tpull` instead of `git pull`, so I put this small thing into my .bashrc:

    function gi {
        first=$1;
        shift;
        first=${first/#t/};
        git "$first" "$@";
    }

(My bash-fu is very limited, but it seems to work).

[krebby]

Or use zsh, which will do something like this globally.

[thisisblurry]

gti might come in handy: http://r-wos.org/hacks/gti

[mrfusion]

I'd like to get more comfortable handling pull requests. Any tips on that?

Any time my project gets one I panic :-(

[roryokane]

Read the code diff to see if it’s a good change you want to make to your project. If you can’t tell from just the diff, you can add their fork as a Git remote and check out their branch so you can run/test/preview your project with their proposed changes.

If you like their work, just click “Merge pull request”. Your repo on GitHub will be updated. Then you can pull from your GitHub repo to your local repo to make sure you’re working on the version of the code including their changes. If you want, also post a comment in the pull request thanking the contributor.

If you don’t like their work, post a comment saying why you don’t want to pull. If they just have small style problems, or the feature has a bug in it or is missing docs, describe what’s wrong or what still needs to be added or decided. You and other contributors might end up discussing what else needs to be added, using comments. The creator of the pull request can update the code in their branch at any time to accommodate feedback. At the point that their code is good enough, just click “Merge pull request”.

If the pull request is something that can’t be salvaged – it’s out of scope for the project or you think it is an anti-feature – explain that in a comment, and close the pull request at the same time. Pull requests can always be closed or reopened later, and can be commented on whatever state they’re in, so the closed state is mainly for communicating whether you expect that you will eventually merge that pull request or a later update of it.

[ozh]

What I like to do is to fetch the proposed changes on my local repo, but without committing them (`--no-commit`):

- fetching locally: easy to test on your dev box

- without committing: easy to see what files are changed in your directory, and to diff files on your dev box

[nroose]

I'm digging hub! Thanks for the link to the cheat sheet.

[iancarroll]

Git.io looks really cool. Didn't know that existed!