serve - git remote add




Como faço para empurrar uma nova ramificação local para um repositório Git remoto e acompanhá-lo também? (9)

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

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 repositório 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 repositório remoto.


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}

  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

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 .


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 <newbranch>
    
  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á here .

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

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 repositório remoto, faça:

git push -u origin name_new_branch

(name_new_branch, exemplo: feature)


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

git checkout -b <new_branch>

e, em seguida, empurre essa nova ramificação para o repositório usando

git push -u origin <new_branch>

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


Se você não estiver compartilhando seu repositório 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 repositório com outras pessoas, isso não é realmente uma boa forma, pois você vai entupir o repositório com todos os seus ramos experimentais desonestos.


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

git branch <branch-name>

Para empurrá-lo para o repositório remoto , faça:

git push -u origin <branch-name>

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

Use git publish-branch de diversas ferramentas do Git de William ( repositório 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 ...)





git-push