Quiero poder hacer lo siguiente:

1. Cree una sucursal local basada en alguna otra sucursal (remota o local) (a través de git brancho git checkout -b)

2. Empuje la rama local al repositorio remoto (publicar), pero hágalo rastreable git pully git pushfuncionará de inmediato.

¿Cómo puedo hacer eso?

Lo sé --set-upstreamen Git 1.7, pero esa es una acción posterior a la creación. Quiero encontrar una manera de hacer un cambio similar al empujar la rama al repositorio remoto.

En Git 1.7.0 y posterior, puedes pagar una nueva rama:

git checkout -b <branch>

Edite archivos, agregue y confirme. Luego presione con la-u--set-upstream opción (abreviatura de ) :

git push -u origin <branch>

Git configurará la información de seguimiento durante el envío.

Si no está compartiendo su repositorio con otros, esto es útil para enviar todas sus sucursales al control remoto y realizar un --set-upstreamseguimiento correcto para usted:

git push --all -u

(No es exactamente lo que pedía el OP, pero esta frase es bastante popular)

Si está compartiendo su repositorio con otros, esta no es una buena forma, ya que obstruirá el repositorio con todas sus ramas experimentales poco fiables.

Antes de la introducción de git push -u, no había git pushopción para obtener lo que desea. Tuvo que agregar nuevas declaraciones de configuración.

Si crea una nueva rama usando:

$ git checkout -b branchB
$ git push origin branchB:branchB

Puede usar el git configcomando para evitar editar directamente el .git/configarchivo.

$ git config branch.branchB.remote origin
$ git config branch.branchB.merge refs/heads/branchB

O puede editar manualmente el .git/configarchivo que tenía información de seguimiento para esta rama.

[branch "branchB"]
    remote = origin
    merge = refs/heads/branchB

En pocas palabras, para crear una nueva sucursal local , haga:

git branch <branch-name>

Para enviarlo al repositorio remoto , haga lo siguiente:

git push -u origin <branch-name>

Una ligera variación de las soluciones ya dadas aquí:

1. Cree una rama local basada en alguna otra rama (remota o local):

   git checkout -b branchname
   

2. Empuje la rama local al repositorio remoto (publicar), pero hágalo rastreable git pully git pushfuncionará de inmediato

   git push -u origin HEAD
   

   Usar HEADes una "forma práctica de empujar la rama actual al mismo nombre en el control remoto". Fuente: https://git-scm.com/docs/git-push En términos de Git, HEAD (en mayúsculas) es una referencia a la parte superior de la rama actual (árbol).

   La -uopción es solo la abreviatura de --set-upstream. Esto agregará una referencia de seguimiento ascendente para la rama actual. puede verificar esto buscando en su archivo .git / config:

   

Yo simplemente hago

git push -u origin localBranch:remoteBranchToBeCreated

sobre un proyecto ya clonado.

Git crea una nueva rama nombrada remoteBranchToBeCreatedbajo mis commits que hice localBranch.

Editar : esto cambia de su rama local actual (posiblemente llamado localBranch) aguas arriba a origin/remoteBranchToBeCreated. Para arreglar eso, simplemente escriba:

git branch --set-upstream-to=origin/localBranch

Entonces su sucursal local actual ahora rastrea origin/localBranch.

Supongo que ya has clonado un proyecto como:

git clone http://github.com/myproject.git

1. Luego, en su copia local, cree una nueva sucursal y compruébelo:

   git checkout -b <newbranch>
   

2. Suponiendo que creó un "git bare --init" en su servidor y creó el myapp.git, debe:

   git remote add origin ssh://example.com/var/git/myapp.git
   git push origin master
   

3. Después de eso, los usuarios deberían poder

   git clone http://example.com/var/git/myapp.git
   

NOTA: Supongo que tiene su servidor en funcionamiento. Si no es así, no funcionará. Un buen tutorial está aquí .

ADICIONAL

Agregar una rama remota:

git push origin master:new_feature_name

Comprueba si todo está bien (busca el origen y enumera las ramas remotas):

git fetch origin
git branch -r

Cree una sucursal local y rastree la sucursal remota:

git checkout -tb new_feature_name origin/new_feature_name

Actualiza todo:

git pull

editar Desfasado, solo usegit push -u origin $BRANCHNAME

Úselo git publish-branchde las diversas herramientas Git de William ( repositorio y clon gitorios ).

OK, no Ruby, entonces, ¡ignorando las salvaguardas! - tome las últimas tres líneas del guión y cree un guión bash git-publish-branch:

#!/bin/bash
REMOTE=$1 # Rewrite this to make it optional...
BRANCH=$2
# Uncomment the following line to create BRANCH locally first
#git checkout -b ${BRANCH}
git push ${ORIGIN} ${BRANCH}:refs/heads/${BRANCH} &&
git config branch.${BRANCH}.remote ${REMOTE} &&
git config branch.${BRANCH}.merge refs/heads/${BRANCH}

Luego git-publish-branch REMOTENAME BRANCHNAME, ejecute , donde REMOTENAME suele ser el origen (puede modificar el script para que tenga su origen como predeterminado, etc.)

Para crear una nueva rama ramificándose desde una rama existente

git checkout -b <new_branch>

y luego empuje esta nueva rama al repositorio usando

git push -u origin <new_branch>

Esto crea y empuja todos los commits locales a una rama remota recién creada origin/<new_branch>

Para la versión de GitLab anterior a 1.7, use:

git checkout -b name_branch

(name_branch, ex: master)

Para enviarlo al repositorio remoto, haga lo siguiente:

git push -u origin name_new_branch

(name_new_branch, ejemplo: feature)

Hice un alias para que cada vez que cree una nueva rama, empuje y rastree la rama remota en consecuencia. Puse el siguiente fragmento en el .bash_profilearchivo:

# Create a new branch, push to origin and track that remote branch
publishBranch() {
  git checkout -b $1
  git push -u origin $1
}
alias gcb=publishBranch

Uso : simplemente escriba gcb thuy/do-sth-koolcon thuy/do-sth-koolmi nuevo nombre de sucursal.

Basándome ligeramente en las respuestas aquí, he terminado este proceso como un simple script Bash, que por supuesto podría usarse también como un alias de Git.

La adición importante para mí es que esto me lleva a ejecutar pruebas unitarias antes de confirmar y pasa el nombre de la sucursal actual de forma predeterminada.

$ git_push_new_branch.sh

  Have you run your unit tests yet? If so, pass OK or a branch name, and try again

  usage: git_push_new_branch {OK|BRANCH_NAME}

  e.g.

  git_push_new_branch           -> Displays prompt reminding you to run unit tests
  git_push_new_branch OK        -> Pushes the current branch as a new branch to the origin
  git_push_new_branch MYBRANCH  -> Pushes branch MYBRANCH as a new branch to the origin

git_push_new_branch.sh

function show_help()
{
  IT=$(cat <<EOF

  Have you run your unit tests yet? If so, pass OK or a branch name, and try again

  usage: git_push_new_branch {OK|BRANCH_NAME}

  e.g.

  git_push_new_branch.sh           -> Displays prompt reminding you to run unit tests
  git_push_new_branch.sh OK        -> Pushes the current branch as a new branch to the origin
  git_push_new_branch.sh MYBRANCH  -> Pushes branch MYBRANCH as a new branch to the origin

  )
  echo "$IT"
  exit
}

if [ -z "$1" ]
then
  show_help
fi

CURR_BRANCH=$(git rev-parse --abbrev-ref HEAD)
if [ "$1" == "OK" ]
then
  BRANCH=$CURR_BRANCH
else
  BRANCH=${1:-$CURR_BRANCH}
fi

git push -u origin $BRANCH

Puedes hacerlo en 2 pasos:

1. Use checkoutpara crear la rama local:

git checkout -b yourBranchName

Trabaja con tu sucursal como quieras.

2. Use el pushcomando para crear automáticamente la rama y enviar el código al repositorio remoto:

git push -u origin yourBanchName

Hay varias formas de hacer esto, pero creo que esta forma es realmente simple.

Para mayor flexibilidad, puede usar un comando Git personalizado . Por ejemplo, cree el siguiente script de Python en algún lugar $PATHdebajo del nombre git-publishy hágalo ejecutable:

#!/usr/bin/env python3

import argparse
import subprocess
import sys


def publish(args):
    return subprocess.run(['git', 'push', '--set-upstream', args.remote, args.branch]).returncode


def parse_args():
    parser = argparse.ArgumentParser(description='Push and set upstream for a branch')
    parser.add_argument('-r', '--remote', default='origin',
                        help="The remote name (default is 'origin')")
    parser.add_argument('-b', '--branch', help='The branch name (default is whatever HEAD is pointing to)',
                        default='HEAD')
    return parser.parse_args()


def main():
    args = parse_args()
    return publish(args)


if __name__ == '__main__':
    sys.exit(main())

Luego git publish -hle mostrará información de uso:

usage: git-publish [-h] [-r REMOTE] [-b BRANCH]

Push and set upstream for a branch

optional arguments:
  -h, --help            show this help message and exit
  -r REMOTE, --remote REMOTE
                        The remote name (default is 'origin')
  -b BRANCH, --branch BRANCH
                        The branch name (default is whatever HEAD is pointing to)