Renommer la branche principale pour les dépôts Git locaux et distants

en supposant que vous êtes actuellement sur master :

git push origin master:master-old        # 1
git branch master-old origin/master-old  # 2
git reset --hard $new_master_commit      # 3
git push -f origin                       # 4

1. faire D'abord une branche master-old dans le dépôt origin , basée sur la propagation master dans le dépôt local.
2. crée une nouvelle branche locale pour cette nouvelle branche origin/master-old (qui sera automatiquement configurée correctement comme une branche de suivi).
3. maintenant, pointez votre local master à l'endroit où vous le voulez. pour le pointage.
4. enfin, changez la force master dans le dépôt origin pour refléter votre nouveau local master .

(si vous le faites de toute autre manière, vous avez besoin d'au moins un pas de plus pour vous assurer que master-old est correctement configuré pour suivre origin/master-old . Aucune des autres solutions affiché au moment de cette écriture.)

Avec Git v1.7, je pense que cela a quelque peu changé. Mettre à jour la référence de suivi de votre branche locale vers la nouvelle télécommande est maintenant très facile.

git branch -m old_branch new_branch         # Rename branch locally    
git push origin :old_branch                 # Delete the old branch    
git push --set-upstream origin new_branch   # Push the new branch, set local branch to track the new remote

git checkout -b new-branch-name
git push remote-name new-branch-name :old-branch-name

vous pourriez devoir passer manuellement à new-branch-name avant de supprimer old-branch-name

il y a plusieurs façons de renommer la succursale, mais je vais me concentrer sur le plus gros problème: " comment permettre aux clients d'accélérer et de ne pas avoir à jouer avec leurs succursales localement " .

D'abord une photo rapide:

c'est quelque chose de facile à faire, mais n'en abusez pas. L'idée toute entière repose sur la fusion commits; comme ils permettent des histoires fast-forward, et link d'une branche à l'autre.

renommer la branche:

# rename the branch "master" to "master-old"
# this works even if you are on branch "master"
git branch -m master master-old

la création du nouveau "maître" de la branche:

# create master from new starting point
git branch master <new-master-start-point>

la création d'une opération de fusion s'engagent à avoir un parent-enfant de l'histoire:

# now we've got to fix the new branch...
git checkout master

# ... by doing a merge commit that obsoletes
# "master-old" hence the "ours" strategy.
git merge -s ours master-old

et voilà.

git push origin master

cela fonctionne parce que la création d'une merge commit permet fast-forwarding la branche à une nouvelle révision.

à l'aide d'un judicieux de fusionner message de commit:

renamed branch "master" to "master-old" and use commit ba2f9cc as new "master"
-- this is done by doing a merge commit with "ours" strategy which obsoletes
   the branch.

these are the steps I did:

git branch -m master master-old
git branch master ba2f9cc
git checkout master
git merge -s ours master-old

je suppose que vous posez toujours la même question que dans votre question précédente . Qui est, maître-nouveau testament contient pas de maître-ancien dans son histoire.* Si vous appelez maître-nouveau "maître", vous avez réécrit l'histoire. Il n'a pas d'importance comment , vous entrez dans un état dans lequel le maître n'est pas un descendant d'un ancien poste de maître, simplement que c'est dans cet état.

autres utilisateurs tentant de tirez alors que le maître n'existe pas en auront simplement leur tire échec (réf sur la télécommande), et une fois qu'il existe à nouveau dans un nouveau lieu, leur tire vont tenter de fusionner leur maître avec la nouvelle télécommande maître, comme si vous fusionnées maître-vieux-maître de nouveau dans votre référentiel. Étant donné ce que vous essayez de faire ici, la fusion aurait des conflits. (S'ils étaient résolus, et le résultat repoussé dans le dépôt, vous seriez dans un État encore pire - les deux versions de l'histoire là-bas.)

pour répondre à votre question simplement: vous devez accepter que parfois il y aura des erreurs dans votre histoire. Ce n'est pas grave. Il arrive à tout le monde. Il y a des propagations inversées dans le git.le dépôt git. L'important est qu'une fois que nous publions l'histoire, c'est quelque chose en quoi tout le monde peut avoir confiance.

*si c'était le cas, cela équivaudrait à apporter des changements à master, puis à créer une nouvelle branche là où elle était. Pas de problème.

la réponse sélectionnée a échoué quand je l'ai essayée. Il lance une erreur: refusing to delete the current branch: refs/heads/master . Je suppose que je vais poster ce qui fonctionne pour moi:

git checkout master             # if not in master already

git branch placeholder          # create placeholder branch
git checkout placeholder        # checkout to placeholder
git push remote placeholder     # push placeholder to remote repository

git branch -d master            # remove master in local repository
git push remote :master         # remove master from remote repository.

le truc est de vérifier le trou juste avant de le pousser vers le dépôt distant. Le reste est explicite, en supprimant la branche principale et en la poussant vers le dépôt distant devrait fonctionner maintenant. Extrait de ici .

bien. Mes 2 cents. Pourquoi ne pas se connecter au serveur, aller dans le répertoire git et renommer la branche dans le dépôt nu. Ceci n'a pas tous les problèmes associés au rechargement de la même branche. En fait, les' clients ' reconnaîtront automatiquement le nom modifié et changeront leur référence distante. Après (ou avant), vous pouvez également modifier le nom local de la direction générale.

Ce sujet:

git checkout old-branch-name
git push remote-name new-branch-name
git push remote-name :old-branch-name
git branch -m new-branch-name

C'est la manière la plus simple et la plus "lisible" que je connaisse:

'Move', branche locale à l'aide de m

git branch -m my_old_branch_name my_new_branch_name

pousser la branche 'moved' vers la télécommande, régler 'upstream' en utilisant -u

git push origin -u my_new_branch_name

(paramètre "en amont" essentiellement "liant" à votre succursale locale de la distance, de sorte que des choses comme les extraire, tirer et pousser de travail)

Supprimer l'ancienne branche de la télécommande

git push origin -D <old_name>

(votre succursale locale est déjà partie, parce que vous l'avez "déplacée" dans la première étape)

OK , renommer une branche à la fois localement et sur la télécommande est assez facile!...

si vous sur la branche, vous pouvez facilement faire:

git branch -m <branch>

ou si non, vous devez faire:

git branch -m <your_old_branch> <your_new_branch>

puis, pousser suppression à la télécommande comme ceci:

git push origin <your_old_branch>

Maintenant vous avez fait, si vous obtenez une erreur en amont pendant que vous essayez de pousser, faites simplement:

git push --set-upstream origin <your_new_branch>

je crée aussi l'image ci-dessous pour montrer les étapes en ligne de commande réelle, il suffit de suivre les étapes et vous seriez bon:

vous pouvez faire ce qui suit:

git -m master master-old #rename current master
git checkout -b master   #create a new branch master
git push -f origin master #force push to master

mais forcer est une mauvaise idée si d'autres personnes partagent ce dépôt. Force push fera entrer leur historique de révision en conflit avec le nouveau.

ce qui suit peut être sauvegardé dans le script shell pour faire le travail:

par exemple:

remote="origin"

if [ "$#" -eq 0 ] # if there are no arguments, just quit
then
    echo "Usage: "151900920" oldName newName or "151900920" newName" >&2
    exit 1
elif
    [ "$#" -eq 1 ] # if only one argument is given, rename current branch
then 
    oldBranchName="$(git branch | grep \* | cut -d ' ' -f2)" #save current branch name
    newBranchName=
else
    oldBranchName=
    newBranchName=
fi

git branch -m $oldBranchName $newBranchName

git push $remote :$oldBranchName #delete old branch on remote
git push --set-upstream $remote $newBranchName # add new branch name on remote and track it

veuillez noter que ici le nom par défaut" origine " est codé en dur, vous pouvez étendre le script pour le rendre si configurable!

alors ce script peut être utilisé avec des alias bash, des alias git ou dans, par exemple, des actions personnalisées sourcetree.

je crois que la clé est la réalisation que vous effectuez un double renommer: master en master-old et aussi master-new en master .

de toutes les autres réponses, j'ai synthétisé ceci:

doublerename master-new master master-old

où il faut d'abord définir la fonction de Bash doublerename :

# doublerename NEW CURRENT OLD
#   - arguments are branch names
#   - see COMMIT_MESSAGE below
#   - the result is pushed to origin, with upstream tracking info updated
doublerename() {
  local NEW=
  local CUR=
  local OLD=
  local COMMIT_MESSAGE="Double rename: $NEW -> $CUR -> $OLD.

This commit replaces the contents of '$CUR' with the contents of '$NEW'.
The old contents of '$CUR' now lives in '$OLD'.
The name '$NEW' will be deleted.

This way the public history of '$CUR' is not rewritten and clients do not have
to perform a Rebase Recovery.
"

  git branch --move $CUR $OLD
  git branch --move $NEW $CUR

  git checkout $CUR
  git merge -s ours $OLD -m $COMMIT_MESSAGE

  git push --set-upstream --atomic origin $OLD $CUR :$NEW
}

c'est similaire à un changement historique git rebase en ce que la branche le contenu est très différent, mais il diffère en ce que les clients peuvent encore en toute sécurité fast-forward avec git pull master .

git update-ref newref oldref
git update-ref -d oldref newref