Como faço para empurrar uma nova ramificação local para um repository Git remoto e acompanhá-lo também?

Eu quero ser capaz de fazer o seguinte:

  1. Crie um branch local baseado em algum outro branch (remoto ou local) (via git branch ou git checkout -b )

  2. Empurre o ramo local para o repository remoto (publicar), mas torne-o rastreável para que git pull e git push funcionem imediatamente.

Como faço isso?

Eu sei sobre --set-upstream no Git 1.7, mas isso é uma ação pós-criação. Eu quero encontrar uma maneira de fazer uma alteração semelhante ao empurrar o ramo para o repository remoto.

No Git 1.7.0 e posterior, você pode verificar uma nova ramificação:

 git checkout -b  

Edite arquivos, adicione e confirme. Em seguida, pressione com a opção -u (abreviação de --set-upstream ) :

 git push -u origin  

O Git irá configurar as informações de rastreamento durante o envio.

Se você não estiver compartilhando seu repository com outras pessoas, é útil enviar todas as suas ramificações para o controle remoto e --set-upstream rastreamento corretamente para você:

 git push --all -u 

(Não é exatamente o que o OP estava pedindo, mas esse one-liner é bem popular)

Se você está compartilhando seu repository com outras pessoas, isso não é realmente uma boa forma, pois você vai entupir o repository com todos os seus ramos experimentais desonestos.

Antes da introdução do git push -u , não havia opção de git push para obter o que você deseja. Você teve que adicionar novas instruções de configuração.

Se você criar uma nova ramificação usando:

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

Você pode usar o comando git config para evitar a edição diretamente do arquivo .git/config .

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

Ou você pode editar manualmente o arquivo .git/config para obter informações de rastreamento para essa ramificação.

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

Simplificando, para criar um novo ramo local , faça:

 git branch  

Para empurrá-lo para o repository remoto , faça:

 git push -u origin  

Uma ligeira variação das soluções já dadas aqui:

  1. Crie uma ramificação local com base em alguma outra ramificação (remota ou local):

     git checkout -b branchname 
  2. Empurre o ramo local para o repository remoto (publicar), mas torne-o rastreável para que git pull e git push funcionem imediatamente

     git push -u origin HEAD 

    Usar o HEAD é uma “maneira prática de enviar o ramo atual para o mesmo nome no controle remoto”. Fonte: https://git-scm.com/docs/git-push Nos termos do Git, HEAD (em maiúsculas) é uma referência ao topo da ramificação atual (tree).

    A opção -u é apenas a abreviação de --set-setupstream . Isso adicionará uma referência de rastreamento upstream para o branch atual. você pode verificar isso procurando em seu arquivo .git / config:

    Digite a descrição da imagem aqui

Eu suponho que você já tenha clonado um projeto como:

 git clone http://github.com/myproject.git 
  1. Em seguida, na sua cópia local, crie uma nova ramificação e confira:

     git checkout -b  
  2. Supondo que você fez um “git bare –init” no seu servidor e criou o myapp.git, você deve:

     git remote add origin ssh://example.com/var/git/myapp.git git push origin master 
  3. Depois disso, os usuários devem poder

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

NOTA: Estou supondo que você tenha seu servidor instalado e funcionando. Se não for, não vai funcionar. Um bom tutorial está aqui .

ADICIONADO

Adicione um ramo remoto:

 git push origin master:new_feature_name 

Verifique se tudo está bem (busque a origem e liste as ramificações remotas):

 git fetch origin git branch -r 

Crie uma ramificação local e rastreie a ramificação remota:

 git checkout -tb new_feature_name origin/new_feature_name 

Atualize tudo:

 git pull 

Eu simplesmente faço

 git push -u origin localBranch:remoteBranchToBeCreated 

sobre um projeto já clonado.

O Git cria um novo branch chamado remoteBranchToBeCreated sob meus commits que fiz no localBranch .

editar Desatualizado, apenas use o git push -u origin $BRANCHNAME


Use git publish-branch de diversas ferramentas do Git de William ( repository e clone gitorious ).

OK, não Ruby, então – ignorando as salvaguardas! – pegue as últimas três linhas do script e crie um 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} 

Em seguida, execute git-publish-branch REMOTENAME BRANCHNAME , onde REMOTENAME geralmente é origin (você pode modificar o script para ter origem como padrão, etc …)

Para criar uma nova ramificação ramificando a partir da ramificação existente

git checkout -b

e, em seguida, empurre essa nova ramificação para o repository usando

git push -u origin

Isso cria e envia todas as confirmações locais para uma origin/ ramificação remota recém-criada origin/

Eu criei um alias para que, sempre que eu criasse uma nova ramificação, ela ativasse e rastreasse a ramificação remota de acordo. Eu coloquei o seguinte pedaço no arquivo .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 : apenas digite gcb thuy/do-sth-kool com thuy/do-sth-kool é o novo nome da minha filial.

Para a versão do GitLab anterior a 1.7, use:

git checkout -b name_branch

(name_branch, ex: master)

Para empurrá-lo para o repository remoto, faça:

git push -u origin name_new_branch

(name_new_branch, exemplo: feature)

Construindo um pouco sobre as respostas aqui, eu envolvi este processo como um simples script Bash, que poderia ser usado como um alias do Git também.

A adição importante para mim é que isso me pede para executar testes de unidade antes de confirmar e passar o nome atual da ramificação por padrão.

 $ 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} eg 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 <  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 

Para fazer upload de sua ramificação local de um repository público, você precisa criar um cd para o repository público e, em seguida, usar o seguinte código:

 git push -u origin branchname