Quero poder fazer o seguinte:

1. Crie uma filial local com base em outra filial (remota ou local) (via git branchou git checkout -b)

2. Envie a ramificação local para o repositório remoto (publicação), mas torne-a rastreável git pulle git pushfuncionará imediatamente.

Como faço isso?

Eu conheço o --set-upstreamGit 1.7, mas essa é uma ação pós-criação. Quero encontrar uma maneira de fazer uma alteração semelhante ao enviar a ramificação para o repositório remoto.

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

git checkout -b <branch>

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

git push -u origin <branch>

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

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

git push --all -u

(Não é exatamente o que o OP estava pedindo, mas essa linha é bastante popular)

Se você está compartilhando seu repositório com outras pessoas, essa não é uma forma muito boa, pois você irá entupi-lo com todos os seus ramos experimentais desonestos.

Antes da introdução de git push -u, não havia git pushopção para obter o que você deseja. Você precisava 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 git configcomando para evitar a edição direta do .git/configarquivo.

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

Ou você pode editar manualmente o .git/configarquivo para obter informações de rastreamento para esse ramo.

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

Simplificando, para criar uma nova filial local , faça:

git branch <branch-name>

Para enviá-lo ao repositório remoto , faça:

git push -u origin <branch-name>

Uma pequena variação das soluções já fornecidas aqui:

1. Crie uma filial local com base em outra filial (remota ou local):

   git checkout -b branchname
   

2. Envie a ramificação local para o repositório remoto (publicação), mas torne-a rastreável git pulle git pushfuncionará imediatamente

   git push -u origin HEAD
   

   O uso HEADé uma "maneira útil de enviar a ramificação 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 à parte superior do ramo atual (árvore).

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

   

Eu simplesmente faço

git push -u origin localBranch:remoteBranchToBeCreated

sobre um projeto já clonado.

O Git cria um novo ramo chamado remoteBranchToBeCreatedsob meus commits que fiz localBranch.

Editar : isso altera o seu ramo local atual (possivelmente nomeado localBranch) a montante para origin/remoteBranchToBeCreated. Para corrigir isso, basta digitar:

git branch --set-upstream-to=origin/localBranch

Portanto, sua filial local atual agora é rastreada origin/localBranch.

Suponho que você já tenha clonado um projeto como:

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

1. Em sua cópia local, crie uma nova ramificação e confira:

   git checkout -b <newbranch>
   

2. Supondo que você criou um "git bare --init" em 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: Suponho que você tenha seu servidor instalado e funcionando. Se não for, não funcionará. Um bom tutorial está aqui .

ADICIONADO

Adicione uma filial remota:

git push origin master:new_feature_name

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

git fetch origin
git branch -r

Crie uma filial local e acompanhe a filial remota:

git checkout -tb new_feature_name origin/new_feature_name

Atualize tudo:

git pull

editar Desatualizado, basta usargit push -u origin $BRANCHNAME

Use as diversas ferramentas Gitgit publish-branch de William ( repositório gitorioso e clone ).

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 git-publish-branch REMOTENAME BRANCHNAME, execute , onde REMOTENAME geralmente é origem (você pode modificar o script para ter origem como padrão, etc ...)

Para criar uma nova ramificação ramificando-se de uma ramificação existente

git checkout -b <new_branch>

e empurre esse novo ramo para repositório usando

git push -u origin <new_branch>

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

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

git checkout -b name_branch

(name_branch, ex: master)

Para enviá-lo ao repositório remoto, faça:

git push -u origin name_new_branch

(name_new_branch, exemplo: feature)

Criei um alias para que sempre que eu criar uma nova ramificação, ela enviará e rastreará a ramificação remota de acordo. Coloquei o seguinte pedaço no .bash_profilearquivo:

# 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 : basta digitar gcb thuy/do-sth-koolcom thuy/do-sth-koolé o meu novo nome de filial.

Com base nas respostas aqui, envolvi esse processo como um script Bash simples, que também poderia ser usado como um alias do Git.

A adição importante para mim é que isso me pede para executar testes de unidade antes de confirmar e passa no nome da filial atual 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

Você pode fazer isso em duas etapas:

1. Use o checkoutpara criar a ramificação local:

git checkout -b yourBranchName

Trabalhe com sua filial como quiser.

2. Use o pushcomando para criar automaticamente a ramificação e enviar o código ao repositório remoto:

git push -u origin yourBanchName

Existem várias maneiras de fazer isso, mas acho que dessa maneira é realmente simples.

Para maior flexibilidade, você pode usar um comando Git personalizado . Por exemplo, crie o seguinte script Python em algum lugar no seu $PATHsob o nome git-publishe torne-o executável:

#!/usr/bin/env python3

import argparse
import subprocess
import sys


def publish(args):
    return subprocess.run(['git', 'push', '--set-upstream', args.remote, args.branch]).returncode


def parse_args():
    parser = argparse.ArgumentParser(description='Push and set upstream for a branch')
    parser.add_argument('-r', '--remote', default='origin',
                        help="The remote name (default is 'origin')")
    parser.add_argument('-b', '--branch', help='The branch name (default is whatever HEAD is pointing to)',
                        default='HEAD')
    return parser.parse_args()


def main():
    args = parse_args()
    return publish(args)


if __name__ == '__main__':
    sys.exit(main())

Então git publish -h , mostrará as informações de uso:

usage: git-publish [-h] [-r REMOTE] [-b BRANCH]

Push and set upstream for a branch

optional arguments:
  -h, --help            show this help message and exit
  -r REMOTE, --remote REMOTE
                        The remote name (default is 'origin')
  -b BRANCH, --branch BRANCH
                        The branch name (default is whatever HEAD is pointing to)