Por que eu preciso fazer o `--set-upstream` o tempo todo?

Eu crio uma nova ramificação no Git:

git branch my_branch

Empurre-o:

git push origin my_branch

Agora digamos que alguém fez algumas alterações no servidor e eu quero retirar origin/my_branch. Eu faço:

git pull

Mas eu entendo:

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.

Aprendi que posso fazê-lo funcionar com:

git branch --set-upstream my_branch origin/my_branch

Mas por que preciso fazer isso para cada ramo que eu criar? Não é óbvio que, se eu my_branchentrar origin/my_branch, eu gostaria de origin/my_branchentrar my_branch? Como posso tornar esse comportamento padrão?

Um atalho, que não depende da lembrança da sintaxe para git branch --set-upstream ^1, é o seguinte:

git push -u origin my_branch

... a primeira vez que você empurra esse galho. Ou, para enviar para a ramificação atual para uma ramificação com o mesmo nome (útil para um alias):

git push -u origin HEAD

Você só precisa usar -uuma vez, e isso configura a associação entre sua filial e a originda mesma maneira que git branch --set-upstreamfaz.

Pessoalmente, acho bom ter que estabelecer essa associação entre sua filial e a filial remota explicitamente. É uma pena que as regras sejam diferentes para git pushegit pull .

¹ Pode parecer bobagem, mas eu frequentemente esqueço de especificar o ramo atual, assumindo que esse é o padrão - não é, e os resultados são mais confusos :)

Atualização 11/10/2012 : Aparentemente, não sou a única pessoa que achou fácil errar! Agradecemos ao VonC por apontar que o git 1.8.0 apresenta o mais óbvio git branch --set-upstream-to, que pode ser usado da seguinte maneira, se você estiver no ramo my_branch:

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

... ou com a opção curta:

git branch -u origin/my_branch

Essa alteração e seu raciocínio estão descritos nas notas de lançamento do git 1.8.0, candidato a lançamento 1 :

Era tentador dizer git branch --set-upstream origin/master, mas isso diz ao Git para organizar a filial local origin/masterpara integrar-se à filial atualmente com check-out, o que é altamente improvável o que o usuário quis dizer. A opção está obsoleta; use a nova opção --set-upstream-to(com um pequeno e doce -u).

Você pode fazer isso acontecer com menos digitação. Primeiro, mude a maneira como seu push funciona:

git config --global push.default current

Isso inferirá a origin my_branchparte, assim você pode fazer:

git push -u

O que criará a ramificação remota com o mesmo nome e a rastreará.

Você pode simplesmente

git checkout -b my-branch origin/whatever

em primeiro lugar. Se você definir branch.autosetupmergeou branch.autosetuprebase(o meu favorito) para always(o padrão é true), my-branchrastreará automaticamente origin/whatever.

Veja git help config.

Este é o meu uso mais comum 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.
...

Além disso, é divertido digitar palavrões no seu terminal.

Você pode configurar o upstream mais simples de duas maneiras. Primeiro quando você cria a ramificação:

git branch -u origin/my-branch

ou depois de criar uma ramificação, você pode usar este comando.

git push -u origin my-branch

Você também pode ramificar, fazer check-out e configurar o upstream em um único comando:

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

Minha preferência pessoal é fazer isso em um comando de duas etapas:

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

Você pode usar:

git config --global branch.autosetupmerge always

que vinculará a ramificação upstream sempre que você criar ou efetuar checkout de uma nova ramificação.

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

Isso também funciona com branch.autosetuprebase, se você seguir um fluxo de trabalho mais focado em rebase, mas não o use a menos que saiba o que está fazendo, pois o padrão de comportamento do pull será rebase, o que pode causar resultados estranhos.

A propósito, o atalho para enviar a ramificação atual para um controle remoto com o mesmo nome:

$ git push -u origin HEAD

Eu pessoalmente uso estes alias seguintes no bash

no arquivo ~ / .gitconfig

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

e no arquivo ~ / .bashrc ou ~ / .zshrc

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

Se o abaixo não funcionar:

git config --global push.default current

Você também deve atualizar a configuração local do seu projeto, pois é possível que seu projeto tenha configurações locais do git:

git config --local push.default current

Você também pode dizer explicitamente ao git pull qual ramificação remota puxar (conforme mencionado na mensagem de erro):

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

No entanto, tenha cuidado com isso: se você estiver em um ramo diferente e fizer um puxão explícito, o refspec que você puxará será mesclado no galho em que você está!

Pelo que vale a pena, se você estiver tentando rastrear um ramo que já existe no controle remoto (por exemplo, origin / somebranch), mas ainda não o fez check-out localmente, você pode:

$ git checkout --track origin/somebranch

Nota: '-t' é a versão abreviada da opção '--track'.

Isso cria a mesma associação logo de cara.

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

Eu uso esse alias do Git em vez de copiar / colar a sugestão do Git sempre: https://gist.github.com/ekilah/88a880c84a50b73bd306

Fonte copiada abaixo (adicione isso ao seu ~/.gitconfigarquivo):

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

Você pode configurar um alias realmente bom que possa lidar com isso sem a sintaxe excessivamente detalhada.

Eu tenho o seguinte alias em ~/.gitconfig:

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

Depois de fazer uma confirmação em uma nova ramificação, você pode enviar sua nova ramificação simplesmente digitando o comando:

git po

Para quem procura um alias que funcione git pull, é isso que eu uso:

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

Agora sempre que você obtiver:

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

Apenas corra:

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

E você está pronto para ir

Porque o git tem a capacidade legal de enviar / puxar ramificações diferentes para diferentes repositórios "upstream". Você pode até usar repositórios separados para empurrar e puxar - no mesmo ramo. Isso pode criar um fluxo distribuído em vários níveis; posso ver isso sendo útil em projetos como o kernel do Linux. O Git foi originalmente desenvolvido para ser usado nesse projeto.

Como conseqüência, ele não assume que repositório sua filial deve rastrear.

Por outro lado, a maioria das pessoas não usa o git dessa maneira, portanto pode ser uma boa opção para uma opção padrão.

O Git geralmente é de nível bastante baixo e pode ser frustrante. No entanto, existem GUIs e deve ser fácil escrever scripts auxiliar se você ainda quiser usá-lo no shell.

Você também pode fazer git push -u origin $(current_branch)

Eu meio que re-descobri legitpor causa desse problema (apenas OS X). Agora, tudo o que uso ao ramificar são esses dois comandos:

legit publish [<branch>] Publica ramificação especificada no controle remoto. (pseudónimo: pub)

legit unpublish <branch> Remove a ramificação especificada do controle remoto. (pseudónimo: unp)

O SublimeGit vem com legitsuporte por padrão, o que torna toda a rotina de ramificação tão fácil quanto pressionar Ctrl-b.

Usamos o phabricator e não pressionamos usando o git. Eu tive que criar o alias do bash que funciona no Linux / mac

vim ~/.bash_aliases

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

Salve 

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

Aqui está um alias do bash para o git push, que é seguro para executar a cada push e alternará automaticamente entre a configuração upstream para o primeiro push e a execução de push normais depois disso.

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

Correio Original