/git-hub

Do GitHub operations from the `git` command

Primary LanguageShellMIT LicenseMIT

=pod

=for comment
DO NOT EDIT. This Pod was generated by Swim v0.1.38.
See http://github.com/ingydotnet/swim-pm#readme

=encoding utf8

=head1 Name

git-hub - The Git command for GitHub

=for html
<a href="https://travis-ci.org/ingydotnet/git-hub"><img src="https://travis-ci.org/ingydotnet/git-hub.png" alt="git-hub"></a>

=head1 Synopsis

Here are just a few of the things you can do on GitHub with a simple command:

    git hub                             # Show the `git hub` cheat sheet
    git hub help                        # Show this awesome documentation
    git hub setup                       # Config dialog. Do this first!

    git hub user <user>                 # Get info about a user
    git hub repos <owner>               # List recent repositories
    git hub repo-new <repo>             # Create a new repository
    git hub fork <owner>/<repo>         # Fork a repository
    git hub clone <owner>/<repo>        # Clone a GitHub repository
                                        # Set/Change your repo description
    git hub repo-edit <repo> description 'Just another GitHub repo'
    git hub repo-delete <owner>/<repo>  # Delete a repository
    git hub followers <user>            # List a user's followers
    git hub star ingydotnet/git-hub     # Star this repository
    git hub watch ingydotnet/git-hub    # Watch this repository
    git hub follow ingydotnet           # Follow this author
    git hub trust ingydotnet            # Add collaborators to repo
                                        # Stalk all your followers
    git hub followers -ra | git hub user -

=head1 Description

The B<hub> subcommand for git, allows you to perform many of the operations
made available by GitHub's v3 REST API, from the C<git> commandline command.

You can fork, create, delete and modify repositories. You can get information
about users, repositories and issues. You can B<star>, B<watch> and B<follow>
things, and find out who else is doing the same. The API is quite extensive.
With this command you can do many of your day to day GitHub actions without
needing a web browser.

You can also chain commands together using the output of one as the input of
another. For example you could use this technique to clone all the repos of a
GitHub user or organization, with one command. See PIPE AND EACH below.

=head1 Installation

There are currently 3 ways to install C<git-hub>. For all of them you need to
get the source code from GitHub:

    git clone https://github.com/ingydotnet/git-hub /path/to/git-hub

The first installation method is preferred: C<source> the C<init> file. Just
add a line like this one to your shell startup script:

    source /path/to/git-hub/init

That will modify your C<PATH> and C<MANPATH>, and also enable command
completion.

The second method is to do these things by hand. This might afford you more
control of your shell environment. Simply add the C<lib> and C<man>
directories to your C<PATH> and C<MANPATH>:

    export PATH="/path/to/git-hub/lib:$PATH"
    export MANPATH="/path/to/git-hub/man:$MANPATH"

See below for info on how to turn on Command Completion.

The third method is a standard system install, which puts C<git-hub> next to
your other git commands, do this instead:

    make install        # Possibly with 'sudo'

This method does not account for upgrading and command completion yet.

See "Upgrading" and "Command Completion" below.

=head1 Command Options

Commandline options start with a dash and can appear in any order in the
command. Long form commands that require an argument can use '=' or not:

    --count=5
    --count 5

=over

=item C<< -c <number> >>, C<< count=<number> >>

This option is for commands that return a list of things. Specify the number
of items you want the command to return. Each list command has a reasonable
default value.

=item C<-a>, C<--all>

Show all elements for list commands. Also applies to a few other commands as
documented.

=item C<-r>, C<--raw>

For commands the produce lists, just list the raw data. For commands that
produce reports, show the raw storage keys, rather than the human friendly
ones. You will need the raw keys to edit/change values.

=item C<-j>, C<--json>

For some commands, you can get the raw data in JSON.

=item C<->

This option, just a single '-', is small but very powerful. It means to read
the next line from stdin, and put the content into the command at that point.
See PIPE and EACH below.

=item C<=>

Like the '-' command above, but reads each B<word> from stdin.

=item C<-h>

Show the brief command usage.

=item C<--help>

Show the full documentation.

=item C<-q>, C<--quiet>

Show minimal output.

=item C<-v>, C<--verbose>

Show detailed output. Notably, show the raw command that is used for the
GitHub API calls.

=item C<< --token=<api-token> >>

Set or override the api-token required by the command. This value can also
come from the C<GIT_HUB_API_TOKEN> environment variable. Usually this value
comes from your C<~/.git-hub/config> file.

=item C<-d> C<--dryrun>

Don't actually make the API call. This option turns on verbose mode.

=item C<-T>

Show the API token in the verbose output. Hidden by default. This option turns
on verbose mode.

=item C<-A>, C<--use-auth>

Use authentication whether or not it is needed for a certain command. This is
useful if you have exceeded your hourly GitHub API rate limit, which is 60
calls unauthenticated, and 5000 calls authenticated.

=item C<-C> C<--no-cache>

There are currently known bugs in GitHub's cache headers. If the content seems
stale, use this option.

=back

=head2 Debug Options

There are a number of debug options that will give you lots of extra
information (albeit in a less pretty format).

=over

=item C<-O>

Show the API reponse output. Always in JSON format. JSON is pretty-printed.

=item C<-H>

Show the API response headers.

=item C<-J>

Show the API response JSON, in decoded form.

=item C<-R>

Repeat the last command, using the previous API server response. Useful for
development and debugging. (Beware, only caches the most recent API call, so
not really good for commands that make multiple calls).

=item C<-x>

Turn on Bash C<-x> debugging. This will show every bash command executed in
the program. This is extremely useful to track down nasty bugs.

=back

=head1 Arguments

The C<git hub> command gets its input values from these sources (in
this order):

=over

=item * Commandline B<arguments> (see specific command, below).

=item * Environment variables of the form C<GIT_HUB_VARIABLE_NAME>.

=item * The C<./.git/config> file. (The repo you are issuing commands from)

=item * The C<~/.githubconfig> file.

=back

Most of the commands described below have arguments. This section defines each
of the argument types. Note that argument values that are strings containing
whitespace need to be quoted.

Argument variable names are always indicated by angle brackets, like: C<<
<variable> >>. Arguments listed in square brackets are optional and arguments
followed by C<...> indicate that more than one is allowed.

=over

=item C<< <user> >>

A GitHub user name. Sometimes an organization name can be used instead. If
this argument is optional, it defaults to the GitHub owner of the repo you are
currently in. If you are not in a GitHub repo, it defaults to your login.
B<Override>: C<GIT_HUB_USER_NAME> environment variable.

=item C<< <owner> >>

A GitHub user or organization that owns the repository being specified. This
value defaults much like the C<< <user> >> argument (above). B<Override>:
C<GIT_HUB_OWNER_NAME> environment variable.

=item C<< <org> >>

A GitHub organization name. B<Override>: C<GIT_HUB_ORG_NAME>
environment variable.

=item C<< <repo> >>

A GitHub repository name. If this argument is optional, it defaults to the
GitHub repo name of the repo you are currently in. B<Override>:
C<GIT_HUB_REPO_NAME> environment variable.

=item C<< <owner>/<repo> >>

Many commands need both an owner and repo separated by a slash. If the owner
is you (your GitHub login) you can omit it (but you still need the leading
slash). Like C</myrepo>, instead of C<me/myrepo>. If this argument is
optional, it defaults the the owner and repo of the GitHub repo you are in.

=item C<< <key-value-pair> >>

Two strings separated by whitespace. Values with embedded whitespace should be
quoted. The documentation of each command that needs these pairs, will list
the valid keys.

=item C<< <api-token-id> >>

The integer number B<id> of a token (not the 40 hex-character value).

=item C<< <scope-name> >>

One of the GitHub scopes that you can apply to a token. The C<git hub scopes>
command will tell you all of these, and what they mean.

=back

=head1 Commands

These are the commands you can use to perform most of your daily GitHub
interactions from the command line. They are installed by default.

=over

=item C<help>

Show this manpage.

=item C<version>

Print version info for C<git-hub>.

=item C<info>

Show detailed version and environment info about your C<git-hub> installation.
This can be useful for figuring out things about how C<git-hub> is operating
in a given situation. Also good for reporting bugs / issues in C<git-hub>.

=item C<setup>

Before you can use the commands described below, you need to perform some
setup/configuration steps.

This "wizard" style dialog, will walk you through the configuration process
quickly and painlessly, with lots of explanation. You should run this command
right away. You can also re-run it, and it will allow you to change your
config, while defaulting to your existing settings.

If you would rather do the steps by hand, see L<#Configuration-
Commands> below.

=item C<upgrade>

Upgrade the C<git-hub> installation to the latest version. Note: you need to
be running 'git-hub' from the source repo, and be on the master branch for
this to work.

=item C<< user [<user>] >>

Show basic information about a specific user. User defaults to the owner of
the current repo, or your login if you are not inside a repo directory. The
C<--raw> and C<--json> options show the data in different formats than
normal output.

=item C<< user-get <user> <data-key> >>

Get a specific data value for a particular user.

=item C<< user-edit <key-value-pair>... >>

Set specific fields of your user info to new values. You list the parameters
as key/value pairs.

You can edit the following user keys: C<name>, C<email>, C<blog>, C<location>,
C<company>, C<bio>.

=item C<< orgs [<user>] >>

List the organizations that a user is a member of.

=item C<< org <org> >>

Show basic information about a GitHub organization. The C<--raw> and C<--json>
options show the data in different formats than normal output.

=item C<< org-repos <org> >>

Show all the repos for an organization, both public and private.

=item C<< org-members <org> >>

List members of an organization.

=item C<< org-get <org> <data-key> >>

Get a specific data value for a particular organization.

=item C<< org-edit <org> <key-value-pairs>... >>

Set specific meta-data fields of an organization to new values. You list the
parameters as key/value pairs.

You can edit the following organization keys: C<name>, C<email>,
C<billing_email>, C<blog>, C<location>, C<company>.

=item C<< teams <org> >>

List the teams in an organization.

=item C<< team <team_id> >>

Get information about a team.

=item C<< team-members <team_id> >>

List members of a team.

=item C<< team-repos <team_id> >>

List repos of a team.

=item C<< team-repo-add <team_id> <repo> >>

Add repo to a team. Repo name must not include org name.

=item C<< team-new <org> <name> <perm> >>

Add a new team (name) to an organization. The 'perm' arg must be pull,
push or admin.

=item C<< team-delete <team_id> >>

Delete a team.

=item C<< members <org>|<team_id> >>

List the members of an organization or team. If numeric argument, show team
members, else organization members.

=item C<< member-get <team_id> <user> >>

Show whether a user is a member of a specified team.

=item C<< member-add <team_id> <user> >>

Add a user to a team.

=item C<< member-remove <team_id> <user> >>

Remove a user from a team.

=item C<< followers [<user>] >>

List the people who are followers of a user.

=item C<< follows <user> [<target-user>] >>

Check if C<< <user> >> follows C<< <target-user> >>. The default target
user is you.

=item C<< following [<user>] >>

List the people that a user is following.

=item C<< follow <user>... >>

Follow one or more users.

=item C<< unfollow <user>... >>

Stop following one or more users.

=item C<< clone ([<owner>/]<repo> [<directory>])... >>

Clone a GitHub repo. Always uses C<--recursive> so you get submodules too. You
can specifiy a list of repos. If you specify a directory for a repo, it should
be an absolute path name or else begin with '.I<' or '..>' so that it can be
distinguished from another repo name.

=item C<< repos [<user>] >>

List the repos for a user or organization. List is returned in order of
recent activity.

=item C<< repo [<repo>] >>

Show basic information about a specific repository. The C<--raw> and C<--json>
options show the data in different formats than normal output.

=item C<< repo-get <owner>/<repo> <data-key> >>

Get a specific data value for a particular repository.

=item C<< repo-edit [<owner>/]<repo> <key-value-pair>... >>

Set specific meta-data fields of a repository to new values. You list the
parameters as key/value pairs.

You can edit the following repo keys: C<description>, C<homepage>.

=item C<< repo-new [<org>/]<repo> >>

Create a new GitHub repository.

=item C<< repo-init [<directory>] >>

This command is useful for setting up new repos. Just mkdir a new dir, cd into
it and issue the command. It will 'git init', make the GitHub repo and add it
as the origin remote. It will only do the things that have not yet been done.

=item C<< repo-delete <owner>/<repo> >>

Delete a GitHub repository.

=item C<< forks [<owner>/<repo>] >>

List the forks of a repository.

=item C<< fork <owner>/<repo> [--org=<org>] [--remote=<name>] >>

Fork a repository to your account or to an organization. Optionally, you can
specify the name of a remote to add, pointing to your fork.

=item C<< stars [<owner>/<repo>] >>

Show what users have starred a repository.

=item C<< star [<owner>/<repo>] >>

Add your B<star> to a repository.

=item C<< unstar [<owner>/<repo>] >>

Add your B<star> to a repository.

=item C<< starred [<user>] >>

List repositories that a user has starred.

=item C<< watch [<owner>/<repo>] >>

Start watching a repo.

=item C<< unwatch [<owner>/<repo>] >>

Stop watching a repo.

=item C<< watching [<user>] >>

Show which repos a user is watching.

=item C<< watchers [<owner>/<repo>] >>

Show the users who are watching a repo.

=item C<< collabs [<owner>/<repo>] >>

List current collaborators for a repository.

=item C<< trust [<owner>/<repo>] <user>... >>

Add one or more collaborators to a repository.

=item C<< untrust [<owner>/<repo>] <user>... >>

Remove one or more collaborators from a repository.

=item C<< issues [<owner>/<repo>] [--all] >>

List the open issues for a repo. Use the C<--all> flag to see both open and
closed issues.

=item C<< issue [<owner>/<repo>] <issue-id-number> >>

Show info (including any comments) for a specific issue. If no issue number is
given, this command will call C<issue-new> instead.

=item C<< issue-new [<owner>/<repo>] >>

Create a new issue for a repository.

=item C<< issue-edit [<owner>/<repo>] <issue-id-number> >>

Add a comment. Change values of 'title', 'state', 'assignee' and 'milestone'.
Changing state to 'closed' will close the issue.

=item C<< comment [<owner>/<repo>] <issue-id-number> >>

Add a comment to an issue. You can also use C<issue-edit> to just add a
comment.

=item C<< issue-close [<owner>/<repo>] <issue-id-number> >>

Close an issue. You can also use C<issue-edit> to close an issue.

=item C<< issue-resolve [<owner>/<repo>] <issue-id-number> >>

Add a comment to an issue and then close it.

=item C<< pr-list [<owner>/<repo>] >>

List the pull requests for a repo.

=item C<< pr-new [<issue-id-number>] [<options>] >>

Create a new pull request for a repository based on the current branch. If an
issue ID number is given, this command will attach the pull request to the
issue instead of creating a new one.

If the default remote is a fork, the pull request will target the default
branch of the parent repository. Otherwise the pull request will target the
default branch of the default remote itself. Use C<--remote>, C<--branch>, C<--
parent>, and C<--base> options to change the default source remote, source
branch, target remote and target branch (respectively).

=item C<< pr-diff [<owner>/<repo>] <issue-id-number> >>

Show the diff for a pull request.

=item C<< pr-fetch [<owner>/<repo>] <issue-id-number> >>

Fetches a pull request to a local C<review/$number> branch

=item C<< pr-merge [<owner>/<repo>] <issue-id-number> >>

Merge and close a pull request.

=item C<< pr-queue [<user>] [--count=#] [--all] >>

Show a user's Pull Request queue, for all repos. Shows the open PRs for any
repo that has them. The C<--count> option tells how many repos to check. The
C<--all> option says to show closed as well as open PRs.

Note: this command makes more API calls than most other commands and thus runs
      slower. You might want to tee the output to a file, if you need to get
      back to this data a lot.

=item C<notify-list [--all]>

List your recent I<unread> user notifications. To list your I<read>
notifications as well, use the C<--all> option.

=item C<< keys [<user>] >>

List public SSH keys for a user.

=item C<< keys-add <title> <key> >>

Add a public ssh key for your user.

=item C<cache-clear>

Clear your API response cache.

=item C<< open [<owner>/<repo>] [<file-path>] >>

Open a browser window to a repo or a file in a repo.

=item C<< url [<owner>/<repo>] [<file-path> [<line-number>]] >>

Print the URL of a repo or a file in a repo.

=item C<git-hub-travis>

Enable and/or disable travis-ci testing from the command line.

=back

=head2 Plugin Commands

You get tons of useful commands by default, and they are all listed and
documented in the next section below. But C<git-hub> also supports third party
plugin commands.

This section is about the "plugin" commands that currently come with
C<git-hub>.

=over

=item C<< irc-enable <room> [<server>] >>

This command must be run inside a cloned repo. It enables GitHub activities
for a repo to be reported to an IRC channel.

=item C<irc-enable>

This command must be run inside a cloned repo. It disables the GitHub IRC
webhook for a repo.

=item C<irc-url>

Show the GitHub URL for setting webhooks on the current repo.

=back

=head2 Configuration Commands

These commands are for editing your C<git-hub> config file and managing your
GitHub authentication tokens.

=over

=item C<< config [<config-key> [<config-value>]] >>

With no args, this command will print the contents of C<~/.githubconfig>. With
one argument (a key), print the current value of the config key. With two
arguments (key value), set the value of the config key. 4 keys are currently
supported: C<login>, C<api-token>, C<use-auth>, and C<json-lib>.

=item C<< config-unset <config-key> >>

Unset a config key. Removes the key from the C<~/.githubconfig> file.

=item C<tokens>

List all the API tokens for your GitHub account. Use the C<--raw> option to
print the token IDs and descriptions, but not the actual token values.

=item C<< token-new [<description-string>] >>

Create a new API token for your GitHub login id. Note: Creating a new token
will not automatically add it to your C<~/.githubconfig> file; you need to do
that yourself with the C<< git hub config api-token <token-value> >> command.
Use the C<--raw> option to just print the new token id.

=item C<< token-get <api-token-id> <data-key> >>

Get a specific data value for a particular token.

=item C<< token-delete <api-token-id> >>

Delete one of your API tokens for your GitHub login id. Note: You need to
delete tokens by B<id> (listed by the C<tokens> command), not by token value.

=item C<< scopes <api-token-id> >>

List the scopes assigned to your API token, and also list all the
possible scope values that you can assign. Use the C<--raw> option to
just list the scopes.

=item C<< scope-add <api-token-id> <scope-name>... >>

Add one or more scopes to your API token. You can use the C<--all> option to
add all possible scopes at once.

=item C<< scope-remove <api-token-id> <scope-name>... >>

Remove one or more scopes from your API token. You can use the C<--all> option
to remove all possible scopes at once.

=back

=head1 Upgrading git-hub

If you used the C<PATH> method of installation, just run this to upgrade
C<git-hub>:

    git hub upgrade

Or (same thing):

    cd /path/to/git-hub
    git pull

If you used C<make install> method, then run this again (after C<git pull>):

    make install        # Possibly with 'sudo'

=head1 Command Completion

The C<git hub> command supports C<< <TAB> >>-based command completion. If you
don't use the C<init> script (see Installation, above), you'll need to enable
this manually to use it.

=head2 In Bash

If your Bash setup does not already provide command completion for Git, you'll
need to enable that first:

    source <Git completion script>

On your system, the Git completion script might be found at any of the
following locations (or somewhere else that we don't know about):

=over

=item * C</etc/bash_completion.d/git>

=item * C</usr/share/bash-completion/git>

=item * C</usr/share/bash-completion/completions/git>

=item * C</opt/local/share/bash-completion/completions/git>

=item * C</usr/local/etc/bash_completion.d/git>

=item * C<~/.homebrew/etc/bash_completion.d/git>

=back

In case you can't find any of these, this repository contains a copy of the
Git completion script:

    source /path/to/git-hub/share/git-completion.bash

Once Git completion is enabled (whether you needed to do that manually or
not), you can turn on C<git-hub> completion with a command like this:

    source /path/to/git-hub/share/completion.bash

=head2 In zsh

In the Z shell (zsh), you can manually enable C<git-hub> completion by
adding the following line to your C<~/.zshrc>, B<before> the C<compinit>
function is called:

    fpath=('/path/to/git-hub/share/zsh-completion' $fpath)

=head1 Plugins

The C<git-hub> command supports plugins. All you need to do to install a
plugin, is to clone the plugin repo into the C<plugin/> subdirectory of the
C<git-hub> repository. There are example plugins already installed. If you do
a system-style install, then just C<make install> the plugins too.

=head1 Faster

The C<git-hub> command is written in pure Bash, including a complete JSON
parser written in Bash. Unfortunately, this parser is a bit slow. It is
B<really> slow for large API payloads.

To make the C<git-hub> command perform much faster, just run this command:

    git hub config json-lib json-perl.bash

That will enable a Perl replacement, which requires Perl (of course) and the
JSON.pm Perl module. If the JSON::XS Perl module is also installed, it will be
even faster.

=head1 Pipe and Each

You can pipe the output of one C<git hub> into another and multiply your
power. The command being piped into should use the EACH option which is a
single dash ('-'). It will cause the command to be run once for each line of
input, inserting the line into the command, in place of the '-'. If you use a
'=' it will do the same thing except for each "word" of input.

This command:

    git hub followers --raw

will list lines containing only user ids. You can pipe it into commands
needing a user id, like:

    git hub followers --raw | git hub user - --json

Thus printing the JSON user info for each follower. Same as:

    for _ in `git hub followers --raw`; do
      git hub user $_ --json
    done

For '=' you can do things like:

    echo alice bob chelsea | git hub trust =

to trust a list of users in one go.

=head1 Token Authentication and Scopes

Many endpoints of the GitHub v3 API require a Personal API Access Token. You
can list your current tokens with this command:

    git hub tokens

If you don't have any tokens or want a new one for the C<git-hub> command, run
these commands (the C<git hub setup> command automates this):

    git hub token-new "my git-hub command token"
    git hub scope-add <token-id> user repo
    git hub scopes <token-id>
    git hub config api-token <token-value>

You can also see all your tokens on the web at L<this
page|https://github.com/settings/applications>.

You can specify your API token to C<git hub> on the commandline with C<--
token=...> or in the C<GIT_HUB_API_TOKEN> environment variable, but the
easiest thing to do is just set it in the git-hub config.

Certain token B<scopes> are required for various GitHub API operations. Make
sure your token has the scopes turned on for the things you want to do. See
the C<scopes>, C<scope-add> and C<scope-remove> C<git hub> subcommands.

NOTE: All the C<git hub> commands dealing with tokens and scopes require you
      to enter your GitHub password. If you need to issue a bunch of these
      commands and you don't want to retype your password each time, you can
      put your password in the C<GIT_HUB_PASSWORD> environment variable.

=head1 Rate Limits

GitHub limits unauthenticated API calls to 60 per hour, and authenticated API
calls to 5000 per hour. For this reason you may wish to use authentication
even for calls that don't need it. You can use the C<-A/--use-auth> option to
make sure a command uses authentication. You can also set the config file to
always use authentication, with this command:

    git hub config use-auth true

Another option is to set the GIT_HUB_USE_AUTH environment variable:

    export GIT_HUB_USE_AUTH=true

=head1 ETAG Caching

GitHub provides ETag headers in the API responses, and C<git-hub> uses them to
cache responses, by default. When you use this feature, your rate-limit usage
is not affected for cached responses.

GitHub has had caching bugs in their API in the past. If you suspect the cache
is stale, you may want to try these options:

=over

=item * Use the C<-C> (C<--no-cache>) flag on a request to bypass the cache.

=item * Set C<GIT_HUB_NO_CACHE=true> to bypass the cache.

=item * Run C<git hub config no-cache true> to never use the cache.

=item * Run C<git hub cache-clear> to erase all the cached values.

=back

=head1 Examples

The following sections show lots of interesting ways to use C<git hub>. Let
your imagination be your guide.

=head2 Example 1. Create a new repo and GitHub origin

Do everything from the command line:

    $ mkdir foo
    $ cd foo
    $ echo 'The new foo' > README
    $ git init
    $ git add README
    $ git commit -m 'First commit'
    $ git hub new foo
    $ git hub repo foo      # Get repo info including the remote address
    $ git remote add origin <new-remote-address>
    $ git push origin master
    $ git hub repo-edit \
        description  'The new foo' \
        homepage     http://example.com
    $ git hub repo

Note that on the last two commands you don't need to set the C<< <repo> >>
because it can be gleaned from the remote. Also on the C<edit> command notice
how you can specify multiple key/value pairs.

=head2 Example 2. Commands from within a repo

Assume your current working directory is not a GitHub repo:

    $ # List *your* repos:
    $ git hub repos
    $ # Clone someone else's repo:
    $ git hub clone ingydotnet/git-hub
    $ # cd into it:
    $ cd git-hub
    $ # Get info about ingydotnet:
    $ git hub user
    $ # Show ingydotnet's recent repos:
    $ git hub repos
    $ # Show info about ingydotnet/git-hub:
    $ git hub repo
    $ # Fork the git-hub repo:
    $ git hub fork
    $ # Follow ingydotnet:
    $ git hub follow
    $ # See who ingydotnet is following:
    $ git hub following
    $ # Star the ingydotnet/git-hub repo:
    $ git hub star
    $ # etc...

The C<git hub> command tries to be environmentally aware. If you are in a
GitHub cloned repo directory, and you don't specify C<< <user> >> or C<<
<owner> >> or C<< <repo> >> for a command that needs them, then they will be
pulled from the remote url. Otherwise, if you don't specify a C<< <user> >> it
will use the one (presumably yours) that you set with the C<git hub config
login ...> command.

=head2 Example 3. Building Complex Commands

The C<git hub> command can be used to output raw data, which can be fed into
other commands; even other C<git hub> commands. This lets you do some powerful
automation with very little code. The C<--raw> (C<-r>) flag will make the
output of many commands be usable as data, and the C<-> (EACH) option makes
commands read data from stdin.

Get information about all your followers:

    for user in $(git hub followers <your-login> -r); do
      git hub user $user
    done

Or more simply by using PIPE and EACH:

    git hub followers -r | git hub user -

Follow all your followers:

    git hub followers -r | git hub follow -

Find out if the people you are following, are following you!

    git hub following -r | git hub follows -

View all the open issues on a repository at once:

    git hub issues -r | git hub issue -

Clone all the repos in an organization:

    git hub repos <org> -r | git hub clone -

Star the latest 5 repos from all the people you are following that have more
than 50 repos:

    git hub following <your-login> -r |
      git hub user-get - public_repos |
      perl -nle 'print if $_ > 50' |
      git hub repos - -rc5 |
      git hub star -

=head1 Author

Written by Ingy döt Net <ingy@ingy.net>

=head1 Status

This command is over a year old. It does a ton of stuff well, but still has a
lot to do to be complete.

The plan is to support as much of the API as possible. Patches / Pull
Requests welcome. See the file C<notes/todo> in the C<git-hub> repo for
upcoming changes.

Try C<make test>. There are tests in place but testing is not yet extensive.
Expect more testing soon. Also please include tests-in-kind for any patches
you submit.

Find 'ingy' on #git-commands in irc.freenode.net if you have questions or
ideas.

=head1 Copyright & License

Copyright 2013-2015. Ingy döt Net.

The MIT License (MIT)

=cut