version-control squash - Come modificare il nome dell'autore e del committente e l'e-mail di più commit in Git?




rebase interactive (25)

Stavo scrivendo una semplice sceneggiatura nel computer della scuola e ho commesso le modifiche a Git (in un repository che era nella mia chiavetta, clonato dal mio computer a casa). Dopo diversi commit mi sono reso conto che stavo commettendo cose come utente root.

C'è un modo per cambiare l'autore di questi commit al mio nome?


Answers

Voglio aggiungere anche il mio esempio. Voglio creare una bash_function con un determinato parametro.

questo funziona in mint-linux-17.3

# $1 => email to change, $2 => new_name, $3 => new E-Mail

function git_change_user_config_for_commit {

 # defaults
 WRONG_EMAIL=${1:-"[email protected]"}
 NEW_NAME=${2:-"your name"}
 NEW_EMAIL=${3:-"[email protected]"}

 git filter-branch -f --env-filter "
  if [ \$GIT_COMMITTER_EMAIL = '$WRONG_EMAIL' ]; then
    export GIT_COMMITTER_NAME='$NEW_NAME'
    export GIT_COMMITTER_EMAIL='$NEW_EMAIL'
  fi
  if [ \$GIT_AUTHOR_EMAIL = '$WRONG_EMAIL' ]; then
    export GIT_AUTHOR_NAME='$NEW_NAME'
    export GIT_AUTHOR_EMAIL='$NEW_EMAIL'
  fi
 " --tag-name-filter cat -- --branches --tags;
}

Github ha una bella soluzione , che è il seguente script di shell:

#!/bin/sh

git filter-branch --env-filter '

an="$GIT_AUTHOR_NAME"
am="$GIT_AUTHOR_EMAIL"
cn="$GIT_COMMITTER_NAME"
cm="$GIT_COMMITTER_EMAIL"

if [ "$GIT_COMMITTER_EMAIL" = "[email protected]" ]
then
    cn="Your New Committer Name"
    cm="Your New Committer Email"
fi
if [ "$GIT_AUTHOR_EMAIL" = "[email protected]" ]
then
    an="Your New Author Name"
    am="Your New Author Email"
fi

export GIT_AUTHOR_NAME="$an"
export GIT_AUTHOR_EMAIL="$am"
export GIT_COMMITTER_NAME="$cn"
export GIT_COMMITTER_EMAIL="$cm"
'

Cambiare l'autore (o il committer) richiederebbe riscrivere tutta la cronologia. Se stai bene con quello e pensi che ne valga la pena, allora dovresti dare un'occhiata a git filter-branch . La pagina man include diversi esempi per iniziare. Si noti inoltre che è possibile utilizzare le variabili di ambiente per modificare il nome dell'autore, il committer, le date e così via. Vedere la sezione "Variabili d'ambiente" della pagina man di git .

In particolare, puoi correggere tutti i nomi di autori e le email sbagliati per tutti i rami e tag con questo comando (fonte: Guida di GitHub ):

#!/bin/sh

git filter-branch --env-filter '
OLD_EMAIL="[email protected]"
CORRECT_NAME="Your Correct Name"
CORRECT_EMAIL="[email protected]"
if [ "$GIT_COMMITTER_EMAIL" = "$OLD_EMAIL" ]
then
    export GIT_COMMITTER_NAME="$CORRECT_NAME"
    export GIT_COMMITTER_EMAIL="$CORRECT_EMAIL"
fi
if [ "$GIT_AUTHOR_EMAIL" = "$OLD_EMAIL" ]
then
    export GIT_AUTHOR_NAME="$CORRECT_NAME"
    export GIT_AUTHOR_EMAIL="$CORRECT_EMAIL"
fi
' --tag-name-filter cat -- --branches --tags

Ho adattato questa solution che funziona inserendo un semplice file author-conv-file (il formato è lo stesso di git-cvsimport ). Funziona cambiando tutti gli utenti come definito nel author-conv-file attraverso tutte le filiali.

Lo abbiamo usato insieme a cvs2git per migrare il nostro repository da cvs a git.

vale a dire author-conv-file

john=John Doe <[email protected]>
jill=Jill Doe <[email protected]>

Il copione:

 #!/bin/bash

 export $authors_file=author-conv-file

 git filter-branch -f --env-filter '

 get_name () {
     grep "^$1=" "$authors_file" |
     sed "s/^.*=\(.*\) <.*>$/\1/"
 }

 get_email () {
     grep "^$1=" "$authors_file" |
     sed "s/^.*=.* <\(.*\)>$/\1/"
 }

 GIT_AUTHOR_NAME=$(get_name $GIT_COMMITTER_NAME) &&
     GIT_AUTHOR_EMAIL=$(get_email $GIT_COMMITTER_NAME) &&
     GIT_COMMITTER_NAME=$GIT_AUTHOR_NAME &&
     GIT_COMMITTER_EMAIL=$GIT_AUTHOR_EMAIL &&
     export GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL &&
     export GIT_COMMITTER_NAME GIT_COMMITTER_EMAIL
 ' -- --all

Puoi anche fare:

git filter-branch --commit-filter '
        if [ "$GIT_COMMITTER_NAME" = "<Old Name>" ];
        then
                GIT_COMMITTER_NAME="<New Name>";
                GIT_AUTHOR_NAME="<New Name>";
                GIT_COMMITTER_EMAIL="<New Email>";
                GIT_AUTHOR_EMAIL="<New Email>";
                git commit-tree "[email protected]";
        else
                git commit-tree "[email protected]";
        fi' HEAD

Nota, se stai usando questo comando nel prompt dei comandi di Windows, allora devi usare " invece di ' :

git filter-branch --commit-filter "
        if [ "$GIT_COMMITTER_NAME" = "<Old Name>" ];
        then
                GIT_COMMITTER_NAME="<New Name>";
                GIT_AUTHOR_NAME="<New Name>";
                GIT_COMMITTER_EMAIL="<New Email>";
                GIT_AUTHOR_EMAIL="<New Email>";
                git commit-tree "[email protected]";
        else
                git commit-tree "[email protected]";
        fi" HEAD

Come accennato, la cronologia della riscrittura è pericolosa e distruggerà i repository di altre persone.

Ma se vuoi davvero farlo e sei in un ambiente bash (nessun problema in Linux, su Windows, puoi usare git bash, che è fornito con l'installazione di git), usa git filter-branch :

git filter-branch --env-filter '
  if [ $GIT_AUTHOR_EMAIL = [email protected] ];
    then [email protected]email;
  fi;
export GIT_AUTHOR_EMAIL'

Per velocizzare le cose, puoi specificare un intervallo di revisioni che desideri riscrivere:

git filter-branch --env-filter '
  if [ $GIT_AUTHOR_EMAIL = [email protected] ];
    then [email protected];
  fi;
export GIT_AUTHOR_EMAIL' HEAD~20..HEAD

Se sei l'unico utente di questo repository, puoi riscrivere la cronologia usando git filter-branch (come svick scritto ), oppure git fast-export / git fast-import più script di filtro (come descritto nell'articolo a cui si fa riferimento in docgnome answer ), o rebase interattivo. Ma uno di questi cambierebbe le revisioni dal primo cambio di impegno in poi; questo significa problemi per chiunque abbia basato le sue modifiche sulla pre-riscrittura del tuo ramo.

RECUPERO

Se altri sviluppatori non hanno basato il loro lavoro sulla versione di pre-riscrittura, la soluzione più semplice sarebbe quella di ri-clonare (clone di nuovo).

In alternativa, possono provare git rebase --pull , che farebbe avanzare rapidamente se non ci fossero cambiamenti nel loro repository, o rebase il loro ramo sopra a commit re-scritti (vogliamo evitare l'unione, poiché manterrebbe riscrivi i comizi per sempre). Tutto ciò presupponendo che essi non abbiano svolto attività lavorativa; usa git stash per nascondere le modifiche altrimenti.

Se altri sviluppatori utilizzano i rami delle funzionalità e / o git pull --rebase non funziona, ad esempio perché upstream non è impostato, devono rebase loro lavoro in cima ai commit post-riscrittura. Ad esempio, subito dopo aver recuperato le nuove modifiche ( git fetch ), per un ramo master basato su / forked da origin/master , è necessario eseguire

$ git rebase --onto origin/master origin/[email protected]{1} master

Qui origin/[email protected]{1} è stato di pre-riscrittura (prima del recupero), vedere gitrevisions .

La soluzione alternativa sarebbe quella di usare refs / replace / mechanism, disponibile in Git dalla versione 1.6.5. In questa soluzione fornisci sostituzioni per commit che hanno email errate; quindi chiunque recuperi i rimpetti "replace" (qualcosa come fetch = +refs/replace/*:refs/replace/* refspec in un posto appropriato nel proprio .git/config ) otterrebbe le sostituzioni in modo trasparente, e chi non recupera quei refs vedere i vecchi commit.

La procedura è simile a questa:

  1. Trova tutti i commit con e-mail errate, ad esempio utilizzando

    $ git log [email protected] --all
    
  2. Per ogni commit errato, creare un commit sostitutivo e aggiungerlo al database dell'oggetto

    $ git cat-file -p <ID of wrong commit> | 
      sed -e 's/[email protected]\.email/[email protected]/g' > tmp.txt
    $ git hash-object -t commit -w tmp.txt
    <ID of corrected commit>
    
  3. Ora che hai corretto il commit nel database degli oggetti, devi dire a git di sostituire automaticamente e in modo trasparente il commit sbagliato con quello corretto usando il comando git replace :

    $ git replace <ID of wrong commit> <ID of corrected commit>
    
  4. Infine, elencare tutte le sostituzioni per verificare se questa procedura è riuscita

    $ git replace -l
    

    e controllare se le sostituzioni avvengono

    $ git log [email protected] --all
    

Ovviamente puoi automatizzare questa procedura ... beh, tutto eccetto usare git replace che non ha (ancora) la modalità batch, quindi dovresti usare il ciclo di shell per quello, o sostituire "a mano".

NON TESTATO! YMMV.

Nota che potresti riscontrare delle spigolosità quando usi refs/replace/ meccanismo: è nuovo e non ancora molto ben testato .


Utilizzo di Rebase interattivo

Potresti farlo

git rebase -i -p <some HEAD before all of your bad commits>

Quindi contrassegna tutti i tuoi cattivi commit come "modifica" nel file di rebase. Se si desidera modificare anche il primo commit, è necessario aggiungerlo manualmente come prima riga nel file di rebase (seguire il formato delle altre righe). Quindi, quando git ti chiede di modificare ogni commit, fallo

 git commit --amend --author "New Author Name <[email protected]>" 

modificare o semplicemente chiudere l'editor che si apre, e poi fare

git rebase --continue

per continuare il rebase.

Puoi saltare completamente l'editor qui aggiungendo --no-edit modo che il comando sia:

git commit --amend --author "New Author Name <[email protected]>" --no-edit && \
git rebase --continue

Single Commit

Come alcuni dei commentatori hanno notato, se si desidera solo modificare il commit più recente, il comando rebase non è necessario. Basta fare

 git commit --amend --author "New Author Name <[email protected]>"

Ciò cambierà l'autore nel nome specificato, ma il committer verrà impostato sul tuo utente configurato in git config user.name e git config user.email . Se vuoi impostare il committer su qualcosa che specifichi, questo imposterà sia l'autore che il committer:

 git -c user.name="New Author Name" -c user.email=[email protected].com commit --amend --reset-author

Nota su Merge Commits

C'era un leggero difetto nella mia risposta originale. Se ci sono commit di merge tra l' HEAD corrente e il tuo <some HEAD before all your bad commits> , git rebase li appiattirà (e comunque, se usi le richieste di pull GitHub, ci sarà un tonnellata di fusioni commette nella tua storia). Questo può molto spesso portare a una storia molto diversa (poiché le modifiche duplicate possono essere "ridefinite"), e nel peggiore dei casi, può portare a git rebase che ti chiede di risolvere i conflitti di fusione difficili (che erano probabilmente già risolti nell'unione di commit) ). La soluzione è usare il flag -p per git rebase , che preserverà la struttura di fusione della cronologia. La manpage di git rebase avverte che l'uso di -p e -i può portare a problemi, ma nella sezione BUGS si dice "La modifica dei commit e la riformulazione dei messaggi di commit dovrebbero funzionare correttamente".

Ho aggiunto -p al comando precedente. Per il caso in cui stai solo cambiando il commit più recente, questo non è un problema.


Nel caso in cui solo i più --amend commit abbiano un cattivo autore, puoi farlo all'interno di git rebase -i usando il comando exec e il comando --amend , come segue:

git rebase -i HEAD~6 # as required

che ti presenta con l'elenco modificabile di commit:

pick abcd Someone else's commit
pick defg my bad commit 1
pick 1234 my bad commit 2

Quindi aggiungi exec ... --author="..." linee dopo tutte le linee con autori cattivi:

pick abcd Someone else's commit
pick defg my bad commit 1
exec git commit --amend --author="New Author Name <[email protected]>" -C HEAD
pick 1234 my bad commit 2
exec git commit --amend --author="New Author Name <[email protected]>" -C HEAD

salva ed esci dall'editor (per eseguire).

Questa soluzione potrebbe essere più lunga da digitare rispetto ad altri, ma è altamente controllabile - so esattamente cosa impegna a colpire.

Grazie a @asmeurer per l'ispirazione.


Un solo liner, ma fai attenzione se hai un repository multi-utente - questo cambierà tutti i commit per avere lo stesso (nuovo) autore e committer.

git filter-branch -f --env-filter "GIT_AUTHOR_NAME='Newname'; GIT_AUTHOR_EMAIL='[email protected]'; GIT_COMMITTER_NAME='Newname'; GIT_COMMITTER_EMAIL='[email protected]';" HEAD

Con interruzioni di riga nella stringa (che è possibile in bash):

git filter-branch -f --env-filter "
    GIT_AUTHOR_NAME='Newname'
    GIT_AUTHOR_EMAIL='[email protected]'
    GIT_COMMITTER_NAME='Newname'
    GIT_COMMITTER_EMAIL='[email protected]'
  " HEAD

  1. eseguire git rebase -i <sha1 or ref of starting point>
  2. segna tutti i commit che vuoi cambiare con edit (o e )
  3. loop i seguenti due comandi finché non hai elaborato tutti i commit:

    git commit --amend --reuse-message=HEAD --author="New Author <[email protected]>" ; git rebase --continue

Ciò manterrà tutte le altre informazioni di commit (comprese le date). L' --reuse-message=HEAD impedisce l'avvio dell'editor di messaggi.


Usando il rebase interattivo, puoi inserire un comando di modifica dopo ogni commit che vuoi modificare. Per esempio:

pick a07cb86 Project tile template with full details and styling
x git commit --amend --reset-author -Chead

Il modo più semplice e veloce per farlo è usare l'argomento --exec di git rebase:

git rebase -i -p --exec 'git commit --amend --reset-author --no-edit'

Questo creerà un elenco di cose da fare in questo modo:

pick ef11092 Blah blah blah
exec git commit --amend --reset-author --no-edit
pick 52d6391 Blah bloh bloo
exec git commit --amend --reset-author --no-edit
pick 30ebbfe Blah bluh bleh
exec git commit --amend --reset-author --no-edit
...

e funzionerà tutto automaticamente, il che funziona quando si hanno centinaia di commit.


  1. Modifica il author name & email commit da Amend , quindi sostituisci old-commit with new-one :

    $ git checkout <commit-hash>                            # checkout to the commit need to modify  
    $ git commit --amend --author "name <[email protected]>" # change the author name and email
    
    $ git replace <old-commit-hash> <new-commit-hash>      # replace the old commit by new one
    $ git filter-branch -- --all                           # rewrite all futures commits based on the replacement                   
    
    $ git replace -d <old-commit-hash>     # remove the replacement for cleanliness 
    $ git push -f origin HEAD              # force push 
    
  2. Un altro modo di Rebasing :

    $ git rebase -i <good-commit-hash>      # back to last good commit
    
    # Editor would open, replace 'pick' with 'edit' before the commit want to change author
    
    $ git commit --amend --author="author name <[email protected]>"  # change the author name & email
    
    # Save changes and exit the editor
    
    $ git rebase --continue                # finish the rebase
    

Se i commit che vuoi correggere sono gli ultimi, e solo un paio di questi, puoi usare una combinazione di git reset e git stash per tornare indietro e git stash nuovamente dopo aver configurato il nome e l'email corretti.

La sequenza sarà simile a questa (per 2 commit errati, senza modifiche in sospeso):

git config user.name <good name>
git config user.email <good email>
git reset HEAD^
git stash
git reset HEAD^
git commit -a
git stash pop
git commit -a

Io uso il seguente per riscrivere l'autore per un intero repository, compresi i tag e tutti i rami:

git filter-branch --tag-name-filter cat --env-filter "
  export GIT_AUTHOR_NAME='New name';
  export GIT_AUTHOR_EMAIL='New email'
" -- --all

Quindi, come descritto nella pagina MAN di filter-branch , rimuovi tutti i ref originali di cui è stato eseguito il filter-branch (questo è distruttivo, il backup prima):

git for-each-ref --format="%(refname)" refs/original/ | \
xargs -n 1 git update-ref -d

Puoi usare questo alias in modo che tu possa fare:

git change-commits GIT_AUTHOR_NAME "old name" "new name"

o per gli ultimi 10 commit:

git change-commits GIT_AUTHOR_EMAIL "[email protected]" "[email protected]" HEAD~10..HEAD

Alias:

change-commits = "!f() { VAR=$1; OLD=$2; NEW=$3; shift 3; git filter-branch --env-filter \"if [[ \\\"$`echo $VAR`\\\" = '$OLD' ]]; then export $VAR='$NEW'; fi\" [email protected]; }; f "

Fonte: https://github.com/brauliobo/gitconfig/blob/master/configs/.gitconfig

Spero che sia utile


Quando si assume un commit non diviso da un altro autore, c'è un modo semplice per gestirlo.

git commit --amend --reset-author


Se sei l'unico utente di questo repo o non ti preoccupi di interrompere il repository per altri utenti, allora si. Se hai spinto questi commit e loro esistono dove da qualche altra parte possono accedervi, allora no, a meno che non ti preoccupi di rompere i repository di altre persone. Il problema è cambiando questi commit che genererai nuovi SHA che li faranno trattare come commit diversi. Quando qualcun altro prova a inserire questi cambiamenti commessi, la storia è diversa e kaboom.

Questa pagina http://inputvalidation.blogspot.com/2008/08/how-to-change-git-commit-author.html descrive come farlo. (Non ho provato questo così YMMV)


Oggi abbiamo riscontrato un problema in cui un carattere UTF8 nel nome di un autore causava problemi al server di build, quindi abbiamo dovuto riscrivere la cronologia per correggere questo problema. I passi compiuti sono stati:

Passaggio 1: modifica il tuo nome utente in git per tutti i futuri commit, come da istruzioni qui: https://help.github.com/articles/setting-your-username-in-git/

Passaggio 2: eseguire il seguente script di bash:

#!/bin/sh

REPO_URL=ssh://path/to/your.git
REPO_DIR=rewrite.tmp

# Clone the repository
git clone ${REPO_URL} ${REPO_DIR}

# Change to the cloned repository
cd ${REPO_DIR}

# Checkout all the remote branches as local tracking branches
git branch --list -r origin/* | cut -c10- | xargs -n1 git checkout

# Rewrite the history, use a system that will preseve the eol (or lack of in commit messages) - preferably Linux not OSX
git filter-branch --env-filter '
OLD_EMAIL="[email protected]"
CORRECT_NAME="New Me"

if [ "$GIT_COMMITTER_EMAIL" = "$OLD_EMAIL" ]
then
    export GIT_COMMITTER_NAME="$CORRECT_NAME"
fi
if [ "$GIT_AUTHOR_EMAIL" = "$OLD_EMAIL" ]
then
    export GIT_AUTHOR_NAME="$CORRECT_NAME"
fi
' --tag-name-filter cat -- --branches --tags

# Force push the rewritten branches + tags to the remote
git push -f

# Remove all knowledge that we did something
rm -rf ${REPO_DIR}

# Tell your colleagues to `git pull --rebase` on all their local remote tracking branches

Panoramica rapida: controlla il tuo repository in un file temporaneo, controlla tutti i rami remoti, esegui lo script che riscriverà la cronologia, eseguirà una forzatura del nuovo stato e dirà a tutti i tuoi colleghi di eseguire un pull di rebase per ottenere le modifiche.

Abbiamo avuto problemi con l'esecuzione di questo su OS X perché in qualche modo ha incasinato le terminazioni di riga nei messaggi di commit, quindi abbiamo dovuto eseguirlo nuovamente su una macchina Linux in seguito.


Questa è una versione più elaborata della versione di @ Brian:

Per cambiare l'autore e il committer, puoi farlo (con interruzioni di riga nella stringa che è possibile in bash):

git filter-branch --env-filter '
    if [ "$GIT_COMMITTER_NAME" = "<Old name>" ];
    then
        GIT_COMMITTER_NAME="<New name>";
        GIT_COMMITTER_EMAIL="<New email>";
        GIT_AUTHOR_NAME="<New name>";
        GIT_AUTHOR_EMAIL="<New email>";
    fi' -- --all

Potresti ricevere uno di questi errori:

  1. La directory temporanea esiste già
  2. Refs che iniziano con refs / originale esiste già
    (questo significa che un altro filtro-ramo è stato eseguito precedentemente sul repository e il riferimento della succursale originale è stato eseguito il backup su refs / originale )

Se vuoi forzare la corsa nonostante questi errori, aggiungi il flag --force :

git filter-branch --force --env-filter '
    if [ "$GIT_COMMITTER_NAME" = "<Old name>" ];
    then
        GIT_COMMITTER_NAME="<New name>";
        GIT_COMMITTER_EMAIL="<New email>";
        GIT_AUTHOR_NAME="<New name>";
        GIT_AUTHOR_EMAIL="<New email>";
    fi' -- --all

Una piccola spiegazione dell'opzione -- --all potrebbe essere necessaria: Fa funzionare il filtro-ramo su tutte le revisioni su tutti i refs (che include tutti i rami). Ciò significa, ad esempio, che anche i tag vengono riscritti ed è visibile sui rami riscritti.

Un "errore" comune è utilizzare HEAD , che significa filtrare tutte le revisioni solo sul ramo corrente . E quindi nessun tag (o altri riferimenti) esisterebbe nel ramo riscritto.


Nota che git memorizza due diversi indirizzi e-mail, uno per il committer (la persona che ha effettuato il cambiamento) e un altro per l' autore (la persona che ha scritto la modifica).

Le informazioni del committer non vengono visualizzate nella maggior parte delle posizioni, ma è possibile visualizzarle con git log -1 --format=%cn,%ce (oppure utilizzare show anziché log per specificare un commit particolare).

Mentre cambiare l'autore del tuo ultimo commit è semplice come git commit --amend --author "Author Name <[email protected]>" , non esiste un solo liner o argomento per fare lo stesso con le informazioni del committer.

La soluzione è di (temporaneamente o meno) modificare le informazioni dell'utente, quindi modificare il commit, che aggiornerà il committer alle informazioni correnti:

git config user.email [email protected] 
git commit --amend

Se usi Eclipse con EGit, allora c'è una soluzione abbastanza semplice.
Presupposto: hai eseguito il commit in un ramo locale 'local_master_user_x' che non può essere trasferito a un "master" di ramo remoto a causa dell'utente non valido.

  1. Controlla il "master" del ramo remoto
  2. Seleziona i progetti / cartelle / file per i quali "local_master_user_x" contiene le modifiche
  3. Fai clic con il tasto destro del mouse - Sostituisci con - Branch - 'local_master_user_x'
  4. Applica nuovamente queste modifiche, questa volta come utente corretto e nel "master" del ramo locale
  5. Premi su "master" remoto

Il tuo problema è molto comune Vedi " Uso di Mailmap per correggere l'elenco di autori in Git "

Per semplicità, ho creato uno script per facilitare il processo: git-changemail

Dopo aver messo quello script sul tuo percorso, puoi impartire comandi come:

  • Modifica le corrispondenze dell'autore sul ramo corrente

    $ git changemail -a [email protected] -n newname -m [email protected]
    
  • Modifica le corrispondenze di autore e committer su <branch> e <branch2>. Passa -f per filtrare-ramo per consentire la riscrittura dei backup

    $ git changemail -b [email protected] -n newname -m [email protected] -- -f &lt;branch> &lt;branch2>
    
  • Mostra utenti esistenti su repo

    $ git changemail --show-both
    

A proposito, dopo aver apportato le modifiche, pulire il backup dal ramo filtro con: git-backup-clean


git versione 2.9.2

Se vuoi cambiare il nome del ramo locale su cui ti trovi:

git branch -m new_name

Se vuoi cambiare il nome di un ramo diverso:

git branch -m old_name new_name

Se si desidera modificare il nome di un ramo diverso con un nome già esistente:

git branch -M old_name new_name_that_already_exists

Nota: l'ultimo comando è distruttivo e rinominerà il tuo ramo, ma perderai il vecchio ramo con quel nome e quei commit perché i nomi dei rami devono essere univoci.





git version-control git-filter-branch git-rewrite-history