¿Por qué necesito hacer `--set-upstream` todo el tiempo?

Creo una nueva sucursal en Git:

git branch my_branch

Empujalo:

git push origin my_branch

Ahora digamos que alguien hizo algunos cambios en el servidor y quiero retirarlos origin/my_branch. Hago:

git pull

Pero me sale:

You asked me to pull without telling me which branch you
want to merge with, and 'branch.my_branch.merge' in
your configuration file does not tell me, either. Please
specify which branch you want to use on the command line and
try again (e.g. 'git pull <repository> <refspec>').
See git-pull(1) for details.

If you often merge with the same branch, you may want to
use something like the following in your configuration file:

    [branch "my_branch"]
    remote = <nickname>
    merge = <remote-ref>

    [remote "<nickname>"]
    url = <url>
    fetch = <refspec>

See git-config(1) for details.

Aprendí que puedo hacer que funcione con:

git branch --set-upstream my_branch origin/my_branch

Pero, ¿por qué necesito hacer esto para cada rama que creo? No es obvio que si empujo my_branchhacia origin/my_branch, a continuación, me gustaría tirar origin/my_branchhacia my_branch? ¿Cómo puedo hacer que este sea el comportamiento predeterminado?

Un atajo, que no depende de recordar la sintaxis para git branch --set-upstream ¹ es hacer:

git push -u origin my_branch

... la primera vez que empujas esa rama. O, para pasar a la rama actual a una rama del mismo nombre (útil para un alias):

git push -u origin HEAD

Solo necesita usar -uuna vez, y eso establece la asociación entre su rama y la originde la misma manera que lo git branch --set-upstreamhace.

Personalmente, creo que es bueno tener que establecer esa asociación entre su sucursal y una en el control remoto explícitamente. Es una pena que las reglas sean diferentes para git pushygit pull .

¹ Puede sonar tonto, pero con frecuencia olvido especificar la rama actual, suponiendo que sea la predeterminada, no lo es, y los resultados son muy confusos :)

Actualización 2012-10-11 : ¡Aparentemente no soy la única persona a la que le resultó fácil equivocarse! Gracias a VonC por señalar que git 1.8.0 presenta lo más obvio git branch --set-upstream-to, que puede usarse de la siguiente manera, si está en la rama my_branch:

git branch --set-upstream-to origin/my_branch

... o con la opción corta:

git branch -u origin/my_branch

Este cambio y su razonamiento se describen en las notas de la versión de git 1.8.0, versión candidata 1 :

Fue tentador decirlo git branch --set-upstream origin/master, pero eso le dice a Git que organice la sucursal local origin/masterpara que se integre con la sucursal actualmente desprotegida, lo que es muy poco probable a qué se refería el usuario. La opción está en desuso; use la nueva opción --set-upstream-to(con una -uopción corta y dulce ) en su lugar.

Puede hacer que esto suceda con menos tipeo. Primero, cambie la forma en que funciona su empuje:

git config --global push.default current

Esto inferirá la origin my_branchparte, por lo que puede hacer:

git push -u

Lo cual creará la rama remota con el mismo nombre y la rastreará.

Puedes simplemente

git checkout -b my-branch origin/whatever

en primer lugar. Si establece branch.autosetupmergeo branch.autosetuprebase(mi favorito) en always(predeterminado es true), my-branchse realizará un seguimiento automático origin/whatever.

Ver git help config.

Este es mi uso más común para The Fuck .

$ git push
fatal: The current branch master has no upstream branch.
To push the current branch and set the remote as upstream, use

    git push --set-upstream origin master

$ fuck
git push --set-upstream origin master [enter/↑/↓/ctrl+c]
Counting objects: 9, done.
...

Además, es divertido escribir palabras groseras en su terminal.

Puede configurar upstream más simple de dos maneras. Primero cuando creas la rama:

git branch -u origin/my-branch

o después de haber creado una rama, puede usar este comando.

git push -u origin my-branch

También puede ramificar, verificar y configurar en un solo comando:

git checkout -b my-branch -t origin/my-branch

Mi preferencia personal es hacer esto en un comando de dos pasos:

git checkout -b my-branch
git push -u origin my-branch

Puedes usar:

git config --global branch.autosetupmerge siempre

que vinculará la rama ascendente cada vez que cree o finalice una nueva rama.

Ver https://felipec.wordpress.com/2013/09/01/advanced-git-concepts-the-upstream-tracking-branch/

Esto también funciona branch.autosetuprebasesi sigue un flujo de trabajo más centrado en rebase, pero no lo use a menos que sepa lo que está haciendo, ya que su comportamiento de extracción cambiará a rebase, lo que puede causar resultados extraños.

Por cierto, el atajo para empujar la rama actual a un control remoto con el mismo nombre:

$ git push -u origin HEAD

Yo personalmente uso estos siguientes alias en bash

en el archivo ~ / .gitconfig

[alias]
    pushup = "!git push --set-upstream origin $(git symbolic-ref --short HEAD)"

y en el archivo ~ / .bashrc o ~ / .zshrc

alias gpo="git pushup"
alias gpof="gpo -f"
alias gf="git fetch"
alias gp="git pull"

Si lo siguiente no funciona:

git config --global push.default current

También debe actualizar la configuración local de su proyecto, ya que es posible que su proyecto tenga configuraciones locales de git:

git config --local push.default current

También puede decirle explícitamente a git pull qué rama remota extraer (como se menciona en el mensaje de error):

git pull <remote-name> <remote-branch>

Sin embargo, tenga cuidado con esto: si se encuentra en una rama diferente y realiza una extracción explícita, la especificación de referencia que extraiga se fusionará con la rama en la que se encuentra.

Por lo que vale, si está intentando rastrear una rama que ya existe en el control remoto (por ejemplo, origen / alguna rama) pero aún no la ha extraído localmente, puede hacer lo siguiente:

$ git checkout --track origin/somebranch

Nota: '-t' es la versión abreviada de la opción '--track'.

Esto establece la misma asociación desde el principio.

git branch --set-upstream-to=origin/master<branch_name>

Uso este alias de Git en lugar de copiar / pegar la sugerencia de Git cada vez: https://gist.github.com/ekilah/88a880c84a50b73bd306

Fuente copiada a continuación (agregue esto a su ~/.gitconfigarchivo):

[alias]
  pushup = "!gitbranchname() { git symbolic-ref --short HEAD; }; gitpushupstream() { git push --set-upstream origin `gitbranchname`; }; gitpushupstream"

Puede configurar un alias realmente bueno que pueda manejar esto sin la sintaxis demasiado detallada.

Tengo el siguiente alias en ~/.gitconfig:

po = "!git push -u origin \"$(git rev-parse --abbrev-ref HEAD)\""

Después de realizar una confirmación en una nueva rama, puede empujar su nueva rama simplemente escribiendo el comando:

git po

Para aquellos que buscan un alias que funcione git pull, esto es lo que uso:

alias up="git branch | awk '/^\\* / { print \$2 }' | xargs -I {} git branch --set-upstream-to=origin/{} {}"

Ahora cada vez que obtienes:

$ git pull
There is no tracking information for the current branch.
...

Solo corre:

$ up
Branch my_branch set up to track remote branch my_branch from origin.
$ git pull

Y eres bueno para ir

Porque git tiene la capacidad genial de empujar / jalar diferentes ramas a diferentes repositorios "aguas arriba". Incluso podría usar repositorios separados para empujar y tirar, en la misma rama. Esto puede crear un flujo distribuido de varios niveles, puedo ver que esto es útil en proyectos como el kernel de Linux. Git fue originalmente construido para ser usado en ese proyecto.

Como consecuencia, no supone qué repositorio debe rastrear su sucursal.

Por otro lado, la mayoría de las personas no usan git de esta manera, por lo que podría ser un buen caso para una opción predeterminada.

Git generalmente es de bajo nivel y puede ser frustrante. Sin embargo, hay interfaces gráficas de usuario y debería ser fácil escribir scripts de ayuda si todavía desea usarlo desde el shell.

También puedes hacer git push -u origin $(current_branch)

Me re-descubrí legitpor este problema (solo OS X). Ahora todo lo que uso cuando ramifico son estos dos comandos:

legit publish [<branch>] Publica la rama especificada en el control remoto. (alias: pub)

legit unpublish <branch> Elimina la rama especificada del control remoto. (alias: unp)

SublimeGit viene con legitsoporte por defecto, lo que hace que toda la rutina de ramificación sea tan fácil como presionar Ctrl-b.

Usamos phabricator y no empujamos usando git. Tuve que crear bash alias que funciona en Linux / mac

vim ~/.bash_aliases

new_branch() {
    git checkout -b "$1"
    git branch --set-upstream-to=origin/master "$1"
}

salvar

source ~/.bash_aliases
new_branch test #instead of git checkout -b test
git pull

Aquí hay un alias bash para git push que es seguro de ejecutar para cada empuje y cambiará automáticamente entre la configuración aguas arriba para el primer empuje y luego hacer los empujes normales después de eso.

alias gpu='[[ -z $(git config "branch.$(git symbolic-ref --short HEAD).merge") ]] && git push -u origin $(git symbolic-ref --short HEAD) || git push'

Publicación original