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

NAME
----
git-http-push - Push missing objects using HTTP/DAV


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
