Zmiana nazwy gałęzi master zarówno dla repozytoriów lokalnych jak i zdalnych Git

Zakładając, że aktualnie jesteś na 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. najpierw Utwórz gałąź master-old w repozytorium origin, opartą na commicie master w repozytorium lokalnym.
2. Utwórz nową lokalną gałąź dla nowej gałęzi origin/master-old (która zostanie automatycznie poprawnie skonfigurowana jako gałąź śledząca).
3. teraz wskaż lokalny master na dowolny commit, na który chcesz go wskazać.
4. na koniec Wymuś zmianę master w repozytorium origin, aby odzwierciedlić Twój nowy lokalny master.

(jeśli zrobisz to w jakikolwiek inny sposób, potrzebujesz co najmniej jednego kroku, aby upewnić się, że master-old jest prawidłowo skonfigurowany do śledzenia origin/master-old. Żadne z innych rozwiązań opublikowanych w czasie pisania tego tekstu nie zawiera tego.)

Z Git v1. 7, myślę, że to się nieco zmieniło. Zaktualizowanie referencji śledzenia oddziału lokalnego do nowego pilota jest teraz bardzo łatwe.

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

Być może będziesz musiał ręcznie przełączyć się na new-branch-name przed usunięciem old-branch-name

Istnieje wiele sposobów na zmianę nazwy gałęzi, ale skupię się na większym problemie: "Jak umożliwić klientom szybkie przewijanie do przodu i nie musieć mieszać ze swoimi gałęziami lokalnie" .

Najpierw szybkie zdjęcie:

Zmiana nazwy gałęzi:

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

Tworzenie nowa gałąź "master":

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

Tworzenie commita scalającego, aby mieć historię rodzic-dziecko:

# 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

I voila.

git push origin master

Działa to, ponieważ utworzenie merge commit pozwala na szybkie przekierowanie gałęzi do nowej rewizji.

Użycie sensownego komunikatu merge 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

Zakładam, że nadal pytasz o tę samą sytuację, co w poprzednim pytaniu . Oznacza to, że master-new nie będzie zawierał master-old w swojej historii.* Jeśli zadzwonisz master-nowy "master", skutecznie będziesz miał przepisaną historię. Nie ma znaczenia Jak dostajesz się do stanu, w którym master nie jest potomkiem poprzedniej pozycji mistrza, po prostu jest w tym stanie.

Inni użytkownicy próbujący ściągnąć, gdy master nie istnieje, po prostu będą mieli swoje ściągnięcia nie powiodą się (nie ma takiego ref na zdalnym), a gdy ponownie pojawi się w nowym miejscu, ich ściągnięcia będą musiały spróbować połączyć swój master z nowym zdalnym master, tak jak gdybyś połączył master-stary i master-nowy w repozytorium. Biorąc pod uwagę to, co próbujesz zrobić, połączenie może mieć konflikt. (Gdyby zostały rozwiązane, a wynik został wepchnięty z powrotem do repozytorium, byłbyś w jeszcze gorszym stanie - obie wersje historii tam.)

Aby odpowiedzieć na twoje pytanie po prostu: powinieneś zaakceptuj, że czasami będą błędy w twojej historii. W porządku. Każdemu się to zdarza. W git są cofnięte commity.repozytorium git. Ważne jest to, że kiedy opublikujemy historię, każdy może jej zaufać.

*gdyby tak było, byłoby to równoznaczne z przepchnięciem pewnych zmian na master, a następnie utworzeniem nowej gałęzi tam, gdzie kiedyś była. Nie ma sprawy.

Wybrana odpowiedź nie powiodła się, gdy próbowałem. Wyświetla błąd: refusing to delete the current branch: refs/heads/master. Chyba napiszę co u mnie działa:

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.

Sztuczka polega na tym, aby przejść do pliku zastępczego tuż przed wysłaniem go do zdalnego repozytorium. Reszta jest oczywista, usunięcie gałęzi master i wypchnięcie jej do zdalnego repozytorium powinno działać teraz. Fragment TUTAJ .

Dobrze. Moje 2 centy. Co powiesz na zalogowanie się na serwerze, przejście do katalogu git i zmianę nazwy gałęzi w repozytorium. Nie ma to wszystkich problemów związanych z reuploadingiem tej samej gałęzi. W rzeczywistości "klienci" automatycznie rozpoznają zmodyfikowaną nazwę i zmienią swoje zdalne odniesienie. Później (lub wcześniej) możesz również zmodyfikować lokalną nazwę gałęzi.

A co z:

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

Jest to najprostszy i najbardziej "czytelny" sposób, jaki znam:

'Przenieś' lokalny oddział używając -m

git branch -m my_old_branch_name my_new_branch_name

Przesuń gałąź 'moved' do pilota, Ustaw 'upstream' używając -u

git push origin -u my_new_branch_name

(Ustawienie 'upstream' zasadniczo 'łączy' Twoją lokalną gałąź ze zdalnym, aby takie rzeczy jak fetch, pull i push działały)

Usuń starą gałąź ze zdalnego

git push origin -D <old_name>

(twój lokalny oddział już zniknął, ponieważ "przeniosłeś" go w pierwszym kroku)

OK, Zmiana nazwy gałęzi zarówno lokalnie jak i na zdalnym jest dość prosta!...

Jeśli na gałęzi, można łatwo zrobić:

git branch -m <branch>

Lub jeśli nie, musisz zrobić:

git branch -m <your_old_branch> <your_new_branch>

Następnie przesuń usunięcie do pilota w następujący sposób:

git push origin <your_old_branch>

Teraz gotowe, Jeśli pojawi się błąd upstream podczas próby wciśnięcia, po prostu zrób:

git push --set-upstream origin <your_new_branch>

Tworzę również poniższy obrazek, aby pokazać kroki w real command linia, po prostu wykonaj kroki i będziesz dobry:

Możesz wykonać następujące czynności:

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

Ale wymuszanie jest złym pomysłem, jeśli inni ludzie dzielą się tym repozytorium. Force push spowoduje konflikt ich historii wersji z nową.

Do skryptu powłoki można zapisać:

Na przykład:

remote="origin"

if [ "$#" -eq 0 ] # if there are no arguments, just quit
then
    echo "Usage: $0 oldName newName or $0 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=$1
else
    oldBranchName=$1
    newBranchName=$2
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

Należy pamiętać, że tutaj domyślna nazwa zdalnego "origin" jest zakodowany na twardo, można rozszerzyć skrypt, aby if konfigurowalny!

Wtedy ten skrypt może być używany z aliasami bash, aliasami git lub na przykład w niestandardowych akcjach sourcetree.

Wierzę, że kluczem jest uświadomienie sobie, że wykonujesz podwójne zmienić nazwę: master na master-old, a także master-new na master.

Z wszystkich innych odpowiedzi, które zsyntetyzowałem to:

doublerename master-new master master-old

Gdzie najpierw musimy zdefiniować doublerename funkcję Bash:

# 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=$1
  local CUR=$2
  local OLD=$3
  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
}

Jest to podobne do zmieniającej się historii git rebase w tym, że zawartość gałęzi jest zupełnie inna, ale różni się tym, że klienci mogą bezpiecznie przewijać do przodu za pomocą git pull master.

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