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

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


SYNOPSIS
--------
'git-push' [--all] [--tags] [-f | --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.
+
`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.
+
Pushing an empty <src> allows you to delete the <dst> ref from
the remote repository.

\--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 descendant 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>, later rewritten in C
by Linus Torvalds <torvalds@osdl.org>

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

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

