remote - ¿Cómo envío una nueva sucursal local a un repositorio de Git remoto y también a su seguimiento?

git remote

Question

Quiero poder hacer lo siguiente:

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

2. Empuje la rama local al repositorio remoto (publicación), pero hágalo rastreable para que git pull y git push funcionen inmediatamente.

¿Cómo puedo hacer eso?

Sé acerca de --set-upstream en Git 1.7, pero eso es una acción posterior a la creación. Quiero encontrar una manera de hacer un cambio similar cuando se empuja la rama al repositorio remoto.

Answer 1

Antes de la introducción de git push -u , no existía la opción de git push para obtener lo que desea. Tenías que agregar nuevas declaraciones de configuración.

Si creas una nueva rama usando:

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

Puede usar el comando git config para evitar editar directamente el archivo .git/config .

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

O puede editar manualmente el archivo .git/config para tener información de seguimiento de esta rama.

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

Answer 2

En Git 1.7.0 y versiones posteriores, puedes pagar una nueva sucursal:

git checkout -b <branch>

Editar archivos, añadir y cometer. Luego presione con la opción -u (abreviatura de --set-upstream ) :

git push -u origin <branch>

Git configurará la información de seguimiento durante el empuje.

Answer 3

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

git branch <branch-name>

Para enviarlo al repositorio remoto , haga:

git push -u origin <branch-name>

Answer 4

Hice un alias para que cada vez que cree una nueva rama, empuje y rastree la rama remota en consecuencia. Puse la siguiente porción en el archivo .bash_profile :

# 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-kool con thuy/do-sth-kool es el nombre de mi nueva rama.

Answer 5

Para cargar su sucursal local de un repositorio público, debe cd al repositorio público y luego usar el siguiente código:

git push -u origin branchname

Answer 6

Para crear una nueva rama por ramificación a partir de la rama existente

git checkout -b <new_branch>

y luego empujar esta nueva rama al repositorio usando

git push -u origin <new_branch>

Esto crea y envía todas las confirmaciones locales a un origin/<new_branch> rama remota recién creado origin/<new_branch>

Answer 7

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:

git push -u origin name_new_branch

(name_new_branch, ejemplo: feature)

Answer 8

Si no está compartiendo su recompra con otros, esto es útil para enviar todas sus sucursales al control remoto, y --set-upstream seguimiento en --set-upstream correctamente para usted:

git push --all -u

(No es exactamente lo que el OP estaba pidiendo, pero esta frase es muy popular)

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

Answer 9

Simplemente hago

git push -u origin localBranch:remoteBranchToBeCreated

sobre un proyecto ya clonado.

Git crea una nueva rama llamada remoteBranchToBeCreated bajo mis confirmaciones que hice en localBranch .

Answer 10

Sobre la base de las respuestas aquí, he resumido este proceso como un simple script de Bash, que, por supuesto, también podría usarse como un alias de Git.

La adición importante para mí es que esto me lleva a realizar 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

Answer 11

Supongo que ya has clonado un proyecto como:

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

1. Luego, en tu copia local, crea una nueva rama y échale un vistazo:

   git checkout -b <newbranch>

2. Suponiendo que hiciste un "git bare --init" en tu servidor y creaste el myapp.git, deberías:

   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 usted tiene su servidor en funcionamiento. Si no lo es, no funcionará. Un buen tutorial está here .

ADICIONAL

Añadir una rama remota:

git push origin master:new_feature_name

Compruebe si todo está bien (busque el origen y enumere las ramas remotas):

git fetch origin
git branch -r

Cree una rama local y siga la rama remota:

git checkout -tb new_feature_name origin/new_feature_name

Actualizar todo:

git pull

Answer 12

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 (publicación), pero hágalo rastreable para que git pull y git push funcionen inmediatamente

   git push -u origin HEAD

   Usar HEAD es una "forma práctica de enviar 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 opción -u es corta para --set-setupstream . Esto agregará una referencia de seguimiento en sentido ascendente para la rama actual. Puedes verificar esto buscando en tu archivo .git / config:

Answer 13

editar Desactualizado, solo use git push -u origin $BRANCHNAME

Utilice git publish-branch de las diversas herramientas Git de William ( gitorious repo and clone ).

Está bien, no Ruby, así que, ¡ignorando las salvaguardas! - tome las últimas tres líneas del script y cree un script 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}

A continuación, ejecute git-publish-branch REMOTENAME BRANCHNAME , donde REMOTENAME suele ser origen (puede modificar la secuencia de comandos para que se origine de forma predeterminada, etc.)