git-push(1)
===========

NAME
----
git-push - Update remote refs along with associated objects.


SYNOPSIS
--------
'git-push' [--all] [--tags] [--force] <repository> <refspec>...

DESCRIPTION
-----------

Updates remote refs using local refs, while sending objects
necessary to complete the given refs.

You can make interesting things happen to a repository
every time you push into it, by setting up 'hooks' there.  See
documentation for gitlink:git-receive-pack[1].


OPTIONS
-------
<repository>::
	The "remote" repository that is destination of a push
	operation.  See the section <<URLS,GIT URLS>> below.

<refspec>::
	The canonical format of a <refspec> parameter is
	`+?<src>:<dst>`; that is, an optional plus `+`, followed
	by the source ref, followed by a colon `:`, followed by
	the destination ref.
+
The <src> side can be an
arbitrary "SHA1 expression" that can be used as an
argument to `git-cat-file -t`.  E.g. `master~4` (push
four parents before the current master head).
+
The local ref that matches <src> is used
to fast forward the remote ref that matches <dst>.  If
the optional plus `+` is used, the remote ref is updated
even if it does not result in a fast forward update.
+
Note: If no explicit refspec is found, (that is neither
on the command line nor in any Push line of the
corresponding remotes file---see below), then all the
refs that exist both on the local side and on the remote
side are updated.
+
Some short-cut notations are also supported.
+
* `tag <tag>` means the same as `refs/tags/<tag>:refs/tags/<tag>`.
* A parameter <ref> without a colon is equivalent to
  <ref>`:`<ref>, hence updates <ref> in the destination from <ref>
  in the source.

\--all::
	Instead of naming each ref to push, specifies that all
	refs be pushed.

\--tags::
	All refs under `$GIT_DIR/refs/tags` are pushed, in
	addition to refspecs explicitly listed on the command
	line.

-f, \--force::
	Usually, the command refuses to update a remote ref that is
	not a descendent of the local ref used to overwrite it.
	This flag disables the check.  This can cause the
	remote repository to lose commits; use it with care.

include::urls.txt[]

Author
------
Written by Junio C Hamano <junkio@cox.net>

Documentation
--------------
Documentation by Junio C Hamano and the git-list <git@vger.kernel.org>.

GIT
---
Part of the gitlink:git[7] suite

