Voglio essere in grado di fare quanto segue:

1. Creare una filiale locale basata su un'altra filiale (remota o locale) (tramite git brancho git checkout -b)

2. Spingere il ramo locale nel repository remoto (pubblicare), ma renderlo tracciabile git pulle git pushfunzionerà immediatamente.

Come lo faccio?

So di --set-upstreamGit 1.7, ma questa è un'azione post-creazione. Voglio trovare un modo per apportare una modifica simile quando si spinge il ramo nel repository remoto.

In Git 1.7.0 e versioni successive, puoi effettuare il checkout di una nuova filiale:

git checkout -b <branch>

Modifica i file, aggiungi e esegui il commit. Quindi premere con l'-u--set-upstream opzione (abbreviazione di ) :

git push -u origin <branch>

Git imposterà le informazioni di tracciamento durante il push.

Se non condividi il tuo repository con altri, questo è utile per spingere tutti i tuoi rami sul telecomando e --set-upstreamtracciarli correttamente:

git push --all -u

(Non esattamente quello che l'OP stava chiedendo, ma questo one-liner è piuttosto popolare)

Se condividi il tuo repository con altri, questa non è davvero una buona forma in quanto intaserai il repository con tutti i tuoi rami sperimentali.

Prima dell'introduzione di git push -u, non era git pushpossibile ottenere ciò che si desidera. È stato necessario aggiungere nuove dichiarazioni di configurazione.

Se si crea un nuovo ramo utilizzando:

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

È possibile utilizzare il git configcomando per evitare di modificare direttamente il .git/configfile.

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

Oppure puoi modificare manualmente il .git/configfile per avere informazioni di tracciamento su questo ramo.

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

In poche parole, per creare una nuova filiale locale , fare:

git branch <branch-name>

Per inviarlo al repository remoto , eseguire:

git push -u origin <branch-name>

Una leggera variazione delle soluzioni già fornite qui:

1. Crea un ramo locale basato su un altro ramo (remoto o locale):

   git checkout -b branchname
   

2. Spingere il ramo locale nel repository remoto (pubblicare), ma renderlo tracciabile git pulle git pushfunzionerà immediatamente

   git push -u origin HEAD
   

   L'utilizzo HEADè un "modo pratico per spingere il ramo corrente allo stesso nome sul telecomando". Fonte: https://git-scm.com/docs/git-push In termini Git, HEAD (in maiuscolo) è un riferimento alla parte superiore del ramo corrente (albero).

   L' -uopzione è solo breve --set-upstream. Ciò aggiungerà un riferimento di tracciamento a monte per il ramo corrente. puoi verificarlo guardando nel tuo file .git / config:

   

Lo faccio semplicemente

git push -u origin localBranch:remoteBranchToBeCreated

su un progetto già clonato.

Git crea una nuova filiale denominata remoteBranchToBeCreatedsotto i miei commit in cui ho fatto localBranch.

Modifica : questo cambia il tuo attuale ramo locale (possibilmente chiamato localBranch) a monte origin/remoteBranchToBeCreated. Per risolvere il problema, digita semplicemente:

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

Quindi la tua filiale locale attuale ora origin/localBranchritorna indietro.

Suppongo che tu abbia già clonato un progetto come:

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

1. Quindi nella tua copia locale, crea un nuovo ramo e provalo:

   git checkout -b <newbranch>
   

2. Supponendo che tu abbia creato un "git bare --init" sul tuo server e creato myapp.git, dovresti:

   git remote add origin ssh://example.com/var/git/myapp.git
   git push origin master
   

3. Successivamente, gli utenti dovrebbero essere in grado di farlo

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

NOTA: suppongo che il tuo server sia attivo e funzionante. In caso contrario, non funzionerà. Un buon how-to è qui .

AGGIUNTO

Aggiungi un ramo remoto:

git push origin master:new_feature_name

Controlla se tutto è a posto (recupera l'origine ed elenca i rami remoti):

git fetch origin
git branch -r

Crea un ramo locale e traccia il ramo remoto:

git checkout -tb new_feature_name origin/new_feature_name

Aggiorna tutto:

git pull

modifica Non aggiornato, basta usaregit push -u origin $BRANCHNAME

Usa git publish-branchdai vari strumenti Git di William ( repository e clone gitorious ).

OK, no Ruby, quindi - ignorando le protezioni! - prendi le ultime tre righe dello script e crea uno 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}

Quindi esegui git-publish-branch REMOTENAME BRANCHNAME, dove REMOTENAME è di solito origine (puoi modificare lo script in modo che diventi origine come predefinito, ecc ...)

Per creare un nuovo ramo ramificandosi da un ramo esistente

git checkout -b <new_branch>

e quindi spingere questo nuovo ramo nel repository utilizzando

git push -u origin <new_branch>

Ciò crea e trasferisce tutti gli commit locali in un ramo remoto appena creato origin/<new_branch>

Per la versione GitLab precedente alla 1.7, utilizzare:

git checkout -b name_branch

(name_branch, es: master)

Per inviarlo al repository remoto, eseguire:

git push -u origin name_new_branch

(name_new_branch, esempio: feature)

Ho creato un alias in modo che ogni volta che creo un nuovo ramo, spinga e segua il ramo remoto di conseguenza. Ho inserito il seguente pezzo nel .bash_profilefile:

# 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

Utilizzo : basta digitare gcb thuy/do-sth-koolcon thuy/do-sth-koolè il mio nuovo nome di filiale.

Basandomi leggermente sulle risposte qui, ho concluso questo processo come un semplice script di Bash, che ovviamente potrebbe essere usato anche come alias Git.

L'aggiunta importante per me è che questo mi spinge a eseguire unit test prima di eseguire il commit e passa il nome del ramo corrente per impostazione predefinita.

$ 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

Puoi farlo in 2 scatti:

1. Utilizzare checkoutper per creare il ramo locale:

git checkout -b yourBranchName

Lavora con la tua filiale come vuoi.

2. Utilizzare il pushcomando per creare automaticamente il ramo e inviare il codice al repository remoto:

git push -u origin yourBanchName

Ci sono molti modi per farlo ma penso che questo sia davvero semplice.

Per la massima flessibilità, è possibile utilizzare un comando Git personalizzato . Ad esempio, crea il seguente script Python da qualche parte $PATHsotto il tuo nome git-publishe rendilo eseguibile:

#!/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())

Quindi git publish -hti mostrerà le informazioni di utilizzo:

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)