Je veux pouvoir faire ce qui suit:

1. Créer une branche locale basée sur une autre branche (distante ou locale) (via git branchou git checkout -b)

2. Poussez la branche locale vers le référentiel distant (publication), mais rendez-la traçable git pullet git pushfonctionnera immédiatement.

Comment je fais ça?

Je sais --set-upstreamdans Git 1.7, mais c'est une action post-création. Je veux trouver un moyen d'apporter une modification similaire en poussant la branche vers le référentiel distant.

Dans Git 1.7.0 et versions ultérieures, vous pouvez extraire une nouvelle branche:

git checkout -b <branch>

Modifier des fichiers, ajouter et valider. Poussez-u--set-upstream ensuite avec l' option (abréviation de ) :

git push -u origin <branch>

Git configurera les informations de suivi pendant le push.

Si vous ne partagez pas votre repo avec d'autres, cela est utile pour pousser toutes vos branches vers la télécommande et effectuer un --set-upstreamsuivi correct pour vous:

git push --all -u

(Pas exactement ce que l'OP demandait, mais ce monoplace est assez populaire)

Si vous partagez votre repo avec d'autres, ce n'est pas vraiment une bonne forme car vous encombrerez le repo avec toutes vos branches expérimentales douteuses.

Avant l'introduction de git push -u, il n'y avait aucune git pushoption pour obtenir ce que vous désirez. Vous deviez ajouter de nouvelles instructions de configuration.

Si vous créez une nouvelle branche en utilisant:

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

Vous pouvez utiliser la git configcommande pour éviter de modifier directement le .git/configfichier.

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

Ou vous pouvez modifier manuellement le .git/configfichier pour avoir des informations de suivi dans cette branche.

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

Autrement dit, pour créer une nouvelle succursale locale , faites:

git branch <branch-name>

Pour le pousser vers le référentiel distant , procédez comme suit:

git push -u origin <branch-name>

Une légère variation des solutions déjà données ici:

1. Créez une branche locale basée sur une autre branche (distante ou locale):

   git checkout -b branchname
   

2. Poussez la branche locale vers le référentiel distant (publication), mais rendez-la traçable git pullet git pushfonctionnera immédiatement

   git push -u origin HEAD
   

   L'utilisation HEADest un "moyen pratique de pousser la branche actuelle vers le même nom sur la télécommande". Source: https://git-scm.com/docs/git-push En termes Git, HEAD (en majuscules) est une référence au sommet de la branche actuelle (arborescence).

   L' -uoption est juste courte pour --set-upstream. Cela ajoutera une référence de suivi en amont pour la branche actuelle. vous pouvez le vérifier en regardant dans votre fichier .git / config:

   

Je fais simplement

git push -u origin localBranch:remoteBranchToBeCreated

sur un projet déjà cloné.

Git crée une nouvelle branche nommée remoteBranchToBeCreatedsous mes commits que j'ai faits dans localBranch.

Modifier : cela change votre branche locale actuelle (éventuellement nommée localBranch) en amont en origin/remoteBranchToBeCreated. Pour résoudre ce problème, tapez simplement:

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

Ainsi, votre succursale locale actuelle effectue un suivi origin/localBranch.

Je suppose que vous avez déjà cloné un projet comme:

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

1. Ensuite, dans votre copie locale, créez une nouvelle branche et vérifiez-la:

   git checkout -b <newbranch>
   

2. Supposons que vous ayez créé un "git bare --init" sur votre serveur et créé myapp.git, vous devez:

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

3. Après cela, les utilisateurs devraient pouvoir

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

REMARQUE: je suppose que votre serveur est opérationnel. Si ce n'est pas le cas, cela ne fonctionnera pas. Un bon mode d'emploi est ici .

AJOUTÉE

Ajouter une branche distante:

git push origin master:new_feature_name

Vérifiez si tout va bien (récupérer l'origine et lister les branches distantes):

git fetch origin
git branch -r

Créez une branche locale et suivez la branche distante:

git checkout -tb new_feature_name origin/new_feature_name

Tout mettre à jour:

git pull

modifier obsolète, utilisez simplementgit push -u origin $BRANCHNAME

Utilisation à git publish-branchpartir des divers outils Git de William ( dépôt gitieux et clone ).

OK, pas de Ruby, donc - en ignorant les sauvegardes! - prendre les trois dernières lignes du script et de créer un 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}

Ensuite, exécutez git-publish-branch REMOTENAME BRANCHNAME, où REMOTENAME est généralement d'origine (vous pouvez modifier le script pour prendre l'origine par défaut, etc ...)

Pour créer une nouvelle branche en dérivant d'une branche existante

git checkout -b <new_branch>

puis pousser cette nouvelle branche vers le référentiel en utilisant

git push -u origin <new_branch>

Cela crée et pousse tous les commits locaux vers une branche distante nouvellement créée origin/<new_branch>

Pour la version GitLab antérieure à 1.7, utilisez:

git checkout -b name_branch

(name_branch, ex: master)

Pour le pousser vers le référentiel distant, procédez comme suit:

git push -u origin name_new_branch

(name_new_branch, par exemple: feature)

J'ai créé un alias de sorte que chaque fois que je crée une nouvelle branche, il pousse et suit la branche distante en conséquence. Je mets le morceau suivant dans le .bash_profilefichier:

# 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

Utilisation : il suffit de taper gcb thuy/do-sth-koolavec thuy/do-sth-koolmon nouveau nom de branche.

En s'appuyant légèrement sur les réponses ici, j'ai résumé ce processus sous la forme d'un simple script Bash, qui pourrait bien sûr également être utilisé comme alias Git.

L'ajout important pour moi est que cela m'invite à exécuter des tests unitaires avant de valider et passe par défaut le nom de la branche actuelle.

$ 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

Vous pouvez le faire en 2 étapes:

1. Utilisez le checkoutpour créer la branche locale:

git checkout -b yourBranchName

Travaillez avec votre succursale comme vous le souhaitez.

2. Utilisez la pushcommande pour créer automatiquement la branche et envoyer le code au référentiel distant:

git push -u origin yourBanchName

Il existe plusieurs façons de procéder, mais je pense que cette méthode est vraiment simple.

Pour une plus grande flexibilité, vous pouvez utiliser une commande Git personnalisée . Par exemple, créez le script Python suivant quelque part dans votre $PATHsous le nom git-publishet rendez-le exécutable:

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

Ensuite git publish -h, vous montrera les informations d'utilisation:

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)