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

NAME
----
git-http-push - Push objects over HTTP/DAV to another repository


SYNOPSIS
--------
'git-http-push' [--complete] [--force] [--verbose] <url> <ref> [<ref>...]

DESCRIPTION
-----------
Sends missing objects to remote repository, and updates the
remote branch.


OPTIONS
-------
--complete::
	Do not assume that the remote repository is complete in its
	current state, and verify all objects in the entire local
	ref's history exist in the remote repository.

--force::
	Usually, the command refuses to update a remote ref that
	is not an ancestor of the local ref used to overwrite it.
	This flag disables the check.  What this means is that
	the remote repository can lose commits; use it with
	care.

--verbose::
	Report the list of objects being walked locally and the
	list of objects successfully sent to the remote repository.

<ref>...::
	The remote refs to update.


Specifying the Refs
-------------------

A '<ref>' specification can be either a single pattern, or a pair
of such patterns separated by a colon ":" (this means that a ref name
cannot have a colon in it).  A single pattern '<name>' is just a 
shorthand for '<name>:<name>'.

Each pattern pair consists of the source side (before the colon)
and the destination side (after the colon).  The ref to be
pushed is determined by finding a match that matches the source
side, and where it is pushed is determined by using the
destination side.

 - It is an error if <src> does not match exactly one of the
   local refs.

 - If <dst> does not match any remote ref, either

   * it has to start with "refs/"; <dst> is used as the
     destination literally in this case.

   * <src> == <dst> and the ref that matched the <src> must not
     exist in the set of remote refs; the ref matched <src>
     locally is used as the name of the destination.

Without '--force', the <src> ref is stored at the remote only if
<dst> does not exist, or <dst> is a proper subset (i.e. an
ancestor) of <src>.  This check, known as "fast forward check",
is performed in order to avoid accidentally overwriting the
remote ref and lose other peoples' commits from there.

With '--force', the fast forward check is disabled for all refs.

Optionally, a <ref> parameter can be prefixed with a plus '+' sign
to disable the fast-forward check only on that ref.


Author
------
Written by Nick Hengeveld <nickh@reactrix.com>

Documentation
--------------
Documentation by Nick Hengeveld

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