Как изменить имя автора и коммиттера, а также адрес электронной почты нескольких коммитов в Git?

StackOverflow https://stackoverflow.com/questions/750172

Вопрос

Я писал простой сценарий на школьном компьютере и фиксировал изменения в Git (в репозитории, который был на моей флешке и клонирован с моего домашнего компьютера).После нескольких коммитов я понял, что делаю коммит от имени пользователя root.

Есть ли способ изменить автора этих коммитов на мое имя?

Это было полезно?

Решение

Изменение автора (или коммиттера) потребует переписывания всей истории.Если вас это устраивает и вы думаете, что оно того стоит, вам стоит попробовать. git-ветвь фильтра.Страница руководства содержит несколько примеров, которые помогут вам начать работу.Также обратите внимание, что вы можете использовать переменные среды для изменения имени автора, коммиттера, дат и т. д.-- см. раздел «Переменные среды» документа справочная страница git.

В частности, вы можете исправить все неправильные имена и адреса электронной почты авторов. для всех веток и тегов с помощью этой команды (источник: Справка GitHub):

#!/bin/sh

git filter-branch --env-filter '
OLD_EMAIL="your-old-email@example.com"
CORRECT_NAME="Your Correct Name"
CORRECT_EMAIL="your-correct-email@example.com"
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

Другие советы

Использование интерактивной перебазировки

Ты мог бы сделать

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

Затем отметьте все свои плохие коммиты как «редактируемые» в файле перебазирования.Если вы также хотите изменить свой первый коммит, вам придется вручную добавить его в качестве первой строки в файле перебазирования (следуйте формату остальных строк).Затем, когда git попросит вас изменить каждый коммит, выполните 

 git commit --amend --author "New Author Name <email@address.com>"

отредактируйте или просто закройте открывшийся редактор, а затем выполните

git rebase --continue

чтобы продолжить перебазирование.

Вы можете вообще не открывать редактор, добавив --no-editтак что команда будет:

git commit --amend --author "New Author Name <email@address.com>" --no-edit && \
git rebase --continue

Одиночная фиксация

Как заметили некоторые комментаторы, если вы просто хотите изменить самый последний коммит, команда rebase не требуется.Просто делать 

 git commit --amend --author "New Author Name <email@address.com>"

Это изменит имя автора на указанное имя, но коммиттером будет назначен настроенный вами пользователь в git config user.name и git config user.email.Если вы хотите установить в качестве коммиттера то, что вы укажете, это установит и автора, и коммиттера:

 git -c user.name="New Author Name" -c user.email=email@address.com commit --amend --reset-author

Примечание о коммитах слияния

В моем первоначальном ответе была небольшая ошибка.Если есть какие-либо коммиты слияния между текущими HEAD и ваш <some HEAD before all your bad commits>, затем git rebase сгладит их (и, кстати, если вы используете запросы на извлечение GitHub, в вашей истории будет масса коммитов слияния).Очень часто это может привести к совсем другой истории (поскольку повторяющиеся изменения могут быть «перебазированы»), а в худшем случае это может привести к git rebase с просьбой разрешить сложные конфликты слияния (которые, вероятно, уже были разрешены в коммитах слияния).Решение состоит в том, чтобы использовать -p пометить git rebase, который сохранит структуру слияния вашей истории.Страница руководства для git rebase предупреждает, что использование -p и -i может привести к проблемам, но в BUGS В разделе говорится: «Редактирование коммитов и изменение формулировок их сообщений о коммитах должно работать нормально».

я добавил -p к вышеуказанной команде.В случае, когда вы просто меняете самый последний коммит, это не проблема.

Вы также можете сделать:

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 "$@";
        else
                git commit-tree "$@";
        fi' HEAD

Обратите внимание: если вы используете эту команду в командной строке Windows, вам необходимо использовать " вместо ':

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 "$@";
        else
                git commit-tree "$@";
        fi" HEAD

Один вкладыш, но будьте осторожны, если у вас многопользовательский репозиторий — это изменится. все обязуется иметь одного и того же (нового) автора и коммиттера.

git filter-branch -f --env-filter "GIT_AUTHOR_NAME='Newname'; GIT_AUTHOR_EMAIL='new@email'; GIT_COMMITTER_NAME='Newname'; GIT_COMMITTER_EMAIL='new@email';" HEAD

С переносами строк в строке (что возможно в bash):

git filter-branch -f --env-filter "
    GIT_AUTHOR_NAME='Newname'
    GIT_AUTHOR_EMAIL='new@email'
    GIT_COMMITTER_NAME='Newname'
    GIT_COMMITTER_EMAIL='new@email'
  " HEAD

Это происходит, когда у вас не инициализирован $HOME/.gitconfig.Вы можете исправить это как:

git config --global user.name "you name"
git config --global user.email you@domain.com
git commit --amend --reset-author

протестировано с версией git 1.7.5.4

Для одного коммита:

git commit --amend --author="Author Name <email@address.com>"

(извлечено из ответа Асмерера)

В случае, когда плохие авторы есть только у нескольких верхних коммитов, вы можете сделать все это внутри git rebase -i используя exec команда и --amend зафиксируйте следующим образом:

git rebase -i HEAD~6 # as required

который представляет вам редактируемый список коммитов:

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

Затем добавьте exec ... --author="..." строки после всех строк с плохими авторами:

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

сохраните и выйдите из редактора (для запуска).

Это решение, возможно, требует больше времени для ввода, чем некоторые другие, но оно легко управляемо — я точно знаю, какие коммиты оно затрагивает.

Спасибо @asmeurer за вдохновение.

На Гитхабе есть хорошее решение, который представляет собой следующий сценарий оболочки:

#!/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" = "your@email.to.match" ]
then
    cn="Your New Committer Name"
    cm="Your New Committer Email"
fi
if [ "$GIT_AUTHOR_EMAIL" = "your@email.to.match" ]
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"
'

Как упоминал docgnome, переписывание истории опасно и приведет к поломке чужих репозиториев.

Но если вы действительно хотите это сделать и находитесь в среде bash (в Linux нет проблем, в Windows вы можете использовать git bash, который предоставляется при установке git), используйте git-ветвь фильтра:

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

Чтобы ускорить процесс, вы можете указать диапазон ревизий, которые хотите переписать:

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

При принятии неслитого коммита от другого автора есть простой способ справиться с этим.

git commit --amend --reset-author

Вы можете использовать это как псевдоним поэтому вы можете сделать:

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

или для последних 10 коммитов:

git change-commits GIT_AUTHOR_EMAIL "old@email.com" "new@email.com" HEAD~10..HEAD

Добавьте в ~/.gitconfig:

[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\" $@; }; f "

Источник: https://github.com/brauliobo/gitconfig/blob/master/configs/.gitconfig

Надеюсь, это полезно.

Это более сложная версия версии @Brian:

Чтобы изменить автора и коммиттера, вы можете сделать это (с переносами строк в строке, что возможно в 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

Вы можете получить одну из этих ошибок:

  1. Временный каталог уже существует
  2. Ссылки, начинающиеся с ссылки/оригинал уже существует
    (это означает, что в репозитории ранее была запущена другая ветвь фильтра, а ссылка на исходную ветку резервируется по адресу ссылки/оригинал)

Если вы хотите принудительно выполнить запуск, несмотря на эти ошибки, добавьте --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

Небольшое пояснение к -- --all может понадобиться опция:Это заставляет ветку фильтра работать со всеми ревизиями на все ссылки (включая все филиалы).Это означает, например, что теги также перезаписываются и видны на переписанных ветках.

Распространенной «ошибкой» является использование HEAD вместо этого это означает фильтрацию всех редакций только по текущая ветка.И тогда в переписанной ветке не будет тегов (или других ссылок).

  1. бегать git rebase -i <sha1 or ref of starting point>
  2. отметьте все коммиты, которые вы хотите изменить, с помощью edit (или e)

  3. зацикливайте следующие две команды, пока не обработаете все коммиты:

    git commit --amend --reuse-message=HEAD --author="New Author <new@author.email>" ; git rebase --continue

Это сохранит всю остальную информацию о фиксации (включая даты).А --reuse-message=HEAD опция предотвращает запуск редактора сообщений.

Я использую следующее, чтобы переписать автора для всего репозитория, включая теги и все ветки:

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

Затем, как описано в MAN-страница ветки фильтра, удалите все оригинальные ссылки, подкрепленные filter-branch (это разрушительно, сначала сделайте резервную копию):

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

я адаптировал это решение который работает путем приема простого author-conv-file (формат такой же, как и для git-cvsimport).Он работает путем изменения всех пользователей, как определено в author-conv-file по всем филиалам.

Мы использовали это вместе с cvs2git перенести наш репозиторий с cvs на git.

то естьОбразец author-conv-file

john=John Doe <john.doe@hotmail.com>
jill=Jill Doe <jill.doe@hotmail.com>

Сценарий:

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

Представленные версии мне показались слишком агрессивными, особенно если вы фиксируете патчи от других разработчиков, это по сути украдет их код.

Версия ниже работает во всех ветках и меняет автора и автора отдельно, чтобы предотвратить это.

Спасибо leif81 за все варианты.

#!/bin/bash

git filter-branch --env-filter '
if [ "$GIT_AUTHOR_NAME" = "<old author>" ];
then
    GIT_AUTHOR_NAME="<new author>";
    GIT_AUTHOR_EMAIL="<youmail@somehost.ext>";
fi
if [ "$GIT_COMMITTER_NAME" = "<old committer>" ];
then
    GIT_COMMITTER_NAME="<new commiter>";
    GIT_COMMITTER_EMAIL="<youmail@somehost.ext>";
fi
' -- --all

  1. Изменить фиксацию author name & email к Amend, затем заменив old-commit with new-one: 

    $ git checkout <commit-hash>                            # checkout to the commit need to modify  
$ git commit --amend --author "name <author@email.com>" # 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. Другой путь 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 <author@email.com>"  # change the author name & email

# Save changes and exit the editor

$ git rebase --continue                # finish the rebase

Должен отметить, что если единственная проблема заключается в том, что автор/адрес электронной почты отличается от вашего обычного, это не проблема.Правильное решение — создать файл с именем .mailmap в основании каталога такими строками, как

Name you want <email you want> Name you don't want <email you don't want>

И с этого момента такие команды, как git shortlog будут считать эти два имени одинаковыми (если вы специально не скажете им этого не делать).Видеть http://schacon.github.com/git/git-shortlog.html Чтобы получить больше информации.

Это имеет преимущество перед всеми другими решениями здесь в том, что вам не нужно перезаписывать историю, что может вызвать проблемы, если у вас есть восходящий поток, и это всегда хороший способ случайно потерять данные.

Конечно, если вы зафиксировали что-то от себя, и это действительно должен быть кто-то другой, и вы не против переписать историю на этом этапе, изменение автора коммита, вероятно, будет хорошей идеей для целей атрибуции (в этом случае я направляю вас к моему другой ответ здесь).

А одна команда чтобы изменить автора последних N коммитов:

git rebase -i HEAD~4 -x "git commit --amend --author 'Author Name <author.name@mail.com>' --no-edit"

ПРИМЕЧАНИЯ

  • тот --no-edit флаг гарантирует, что git commit --amend не требует дополнительного подтверждения
  • когда ты используешь git rebase -i, можно вручную выбрать коммиты, где изменить автора,

файл, который вы редактируете, будет выглядеть так:

pick 897fe9e simplify code a little
exec git commit --amend --author 'Author Name <author.name@mail.com>' --no-edit
pick abb60f9 add new feature
exec git commit --amend --author 'Author Name <author.name@mail.com>' --no-edit
pick dc18f70 bugfix
exec git commit --amend --author 'Author Name <author.name@mail.com>' --no-edit

Затем вы все равно можете изменить некоторые строки, чтобы увидеть, где вы хотите изменить автора.Это дает вам хорошую золотую середину между автоматизацией и контролем:вы видите шаги, которые будут выполняться, и как только вы сохраните, все будет применено сразу.

Если вы единственный пользователь этого репозитория, вы можете переписать историю используя либо git filter-branch (как Свик написал), или git fast-export/git fast-import плюс сценарий фильтра (как описано в статье, указанной в ответ докгнома), или интерактивный перебазировать.Но любой из них изменит версии, начиная с первого измененного коммита;это означает проблемы для всех, кто основывал свои изменения на предварительной переписывании вашей ветки.

ВОССТАНОВЛЕНИЕ

Если бы другие разработчики не основывали свою работу на предварительно переписанной версии, самым простым решением было бы повторное клонирование (снова клонирование).

Альтернативно они могут попробовать git rebase --pull, которые бы перемотали вперед, если бы в их репозитории не было никаких изменений, или перебазировали бы свою ветку поверх переписанных коммитов (мы хотим избежать слияния, так как в этом случае предперезаписанные коммиты будут сохраняться навсегда).Все это при условии, что они не совершили несовершенной работы;использовать git stash в противном случае спрятать изменения.

Если другие разработчики используют ветки функций и/или git pull --rebase не работает, напримерпоскольку восходящий поток не настроен, им приходится перебазировать их работа поверх коммитов после перезаписи.Например, сразу после получения новых изменений (git fetch), для master ветка, основанная на/развитая от origin/master, нужно бежать

$ git rebase --onto origin/master origin/master@{1} master

Здесь origin/master@{1} это состояние перед перезаписью (перед выборкой), см. gitrevisions.

Альтернативным решением было бы использовать ссылки/заменить/ механизм, доступный в Git начиная с версии 1.6.5.В этом решении вы предоставляете замену коммитам с неправильным адресом электронной почты;затем любой, кто получает ссылки на замену (что-то вроде fetch = +refs/replace/*:refs/replace/* refspec в соответствующем месте в их .git/config) получит замену прозрачно, а те, кто не получит эти ссылки, увидят старые коммиты.

Процедура выглядит примерно так:

  1. Найдите все коммиты с неправильным адресом электронной почты, например, с помощью

    $ git log --author=user@wrong.email --all

  2. Для каждого неправильного коммита создайте заменяющий коммит и добавьте его в базу данных объектов.

    $ git cat-file -p <ID of wrong commit> | 
  sed -e 's/user@wrong\.email/user@example.com/g' > tmp.txt
$ git hash-object -t commit -w tmp.txt
<ID of corrected commit>

  3. Теперь, когда вы исправили фиксацию в базе данных объектов, вы должны указать git автоматически и прозрачно заменить неправильную фиксацию исправленной, используя git replace команда:

    $ git replace <ID of wrong commit> <ID of corrected commit>

  4. Наконец, перечислите все замены, чтобы проверить, прошла ли эта процедура успешно.

    $ git replace -l

    и проверьте, происходят ли замены

    $ git log --author=user@wrong.email --all

Конечно, можно автоматизировать эту процедуру...ну, все, кроме использования git replace в котором (пока) нет пакетного режима, поэтому для этого вам придется использовать цикл оболочки или заменить «вручную».

НЕ ИСПЫТАНО! ЮММВ.

Обратите внимание, что при использовании вы можете столкнуться с некоторыми неровными углами. refs/replace/ механизм:это новое и еще не очень хорошо проверенное.

Самый быстрый и простой способ сделать это — использовать аргумент --exec git rebase:

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

Это создаст список дел, который выглядит следующим образом:

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
...

и все это будет работать автоматически, что работает, когда у вас сотни коммитов.

Если коммиты, которые вы хотите исправить, являются последними и их всего пара, вы можете использовать комбинацию git reset и git stash чтобы вернуться и зафиксировать их снова после настройки правильного имени и адреса электронной почты.

Последовательность будет примерно такой (для двух неправильных коммитов нет ожидающих изменений):

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

Если вы используете Eclipse с EGit, есть довольно простое решение.
Предположение:у вас есть коммиты в локальной ветке «local_master_user_x», которые нельзя перенести в удаленную ветку «master» из-за недопустимого пользователя.

  1. Оформить заказ на удаленную ветку «master»
  2. Выберите проекты/папки/файлы, для которых «local_master_user_x» содержит изменения.
  3. Щелкните правой кнопкой мыши — Заменить на — Ветка — «local_master_user_x».
  4. Зафиксируйте эти изменения еще раз, на этот раз от имени правильного пользователя и в локальной ветке «master».
  5. Отправьте на удаленный «главный»

Используя интерактивную перебазировку, вы можете поместить команду изменения после каждого коммита, который хотите изменить.Например:

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

Обратите внимание, что git хранит два разные адреса электронной почты, один для коммиттер (человек, совершивший изменение) и еще один для автор (человек, написавший изменение).

Информация о коммиттере не отображается в большинстве мест, но вы можете увидеть ее с помощью git log -1 --format=%cn,%ce (или используйте show вместо log чтобы указать конкретный коммит).

Хотя изменить автора вашего последнего коммита так же просто, как git commit --amend --author "Author Name <email@example.com>", не существует однострочника или аргумента, позволяющего сделать то же самое с информацией о коммиттере.

Решение состоит в том, чтобы (временно или нет) изменить вашу информацию о пользователе, а затем изменить коммит, который обновит коммиттер до вашей текущей информации:

git config user.email my_other_email@example.com 
git commit --amend

Сегодня мы столкнулись с проблемой, когда символ UTF8 в имени автора вызывал проблемы на сервере сборки, поэтому нам пришлось переписать историю, чтобы исправить это.Предпринятые шаги заключались в следующем:

Шаг 1:Измените свое имя пользователя в git для всех будущих коммитов, как указано здесь:https://help.github.com/articles/setting-your-username-in-git/

Шаг 2:Запустите следующий 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="me@something.com"
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

Краткая информация:Извлеките свой репозиторий во временный файл, извлеките все удаленные ветки, запустите сценарий, который перезапишет историю, принудительно загрузит новое состояние и попросите всех своих коллег выполнить перебазирование, чтобы получить изменения.

У нас были проблемы с запуском этой программы на OS X, потому что она каким-то образом испортила окончания строк в сообщениях о фиксации, поэтому нам пришлось впоследствии повторно запустить ее на машине с Linux.

Ваша проблема действительно распространена.Видеть "Использование Mailmap для исправления списка авторов в Git"

Для простоты я создал скрипт, упрощающий этот процесс: git-changemail

Поместив этот скрипт на свой путь, вы можете выполнить такие команды, как:

  • Изменить совпадения авторов в текущей ветке

    $ git changemail -a old@email.com -n newname -m new@email.com

  • Измените сопоставления автора и коммиттера в <branch> и <branch2>.Проходить -f в ветку фильтра, чтобы разрешить перезапись резервных копий

    $ git changemail -b old@email.com -n newname -m new@email.com -- -f &lt;branch> &lt;branch2>

  • Показать существующих пользователей в репо

    $ git changemail --show-both

Кстати, после внесения изменений очистите резервную копию ветки фильтра с помощью: git-backup-clean

Если вы единственный пользователь этого репозитория или вас не волнует возможность нарушения репозитория для других пользователей, тогда да.Если вы отправили эти коммиты и они существуют там, где к ним может получить доступ кто-то еще, то нет, если только вас не заботит взлом репозиториев других людей.Проблема в том, что, изменяя эти коммиты, вы будете генерировать новые SHA, что приведет к тому, что они будут рассматриваться как разные коммиты.Когда кто-то другой пытается получить эти измененные коммиты, история меняется и бах.

Эта страница http://inputvalidation.blogspot.com/2008/08/how-to-change-git-commit-author.html описывает, как это сделать.(Я не пробовал это, так что YMMV)

Я тоже хочу добавить свой пример.Я хочу создать bash_function с заданным параметром.

это работает в 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:-"you_wrong_mail@hello.world"}
 NEW_NAME=${2:-"your name"}
 NEW_EMAIL=${3:-"new_mail@hello.world"}

 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;
}

git rebase -i YOUR_FIRTS_COMMIT_SHA^

while true; do git commit --amend --author="Name Surname <email@example.com>" --no-edit && git rebase --continue; done

Нажмите ^C # после завершения перебазирования (цикл будет продолжать обновлять последний коммит)

Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top