git - सवर - खाता न. का सत्यापन




Git में लेखक और कमिटेटर का नाम और कई कॉम्पटिट का ई-मेल कैसे बदलें? (20)

मैं स्कूल के कंप्यूटर में एक सरल स्क्रिप्ट लिख रहा था, और Git में परिवर्तन (एक रेपो में जो मेरे पेनड्राइव में था, घर पर मेरे कंप्यूटर से क्लोन किया गया था) में बदलाव कर रहा था। कई कमिट्स के बाद मुझे एहसास हुआ कि मैं रूट यूजर के रूप में सामान कर रहा था।

क्या इन तरीकों के लेखक को मेरे नाम पर बदलने का कोई तरीका है?


इंटरएक्टिव रिबेस का उपयोग करना

तुम यह कर सकते थे

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

फिर अपने सभी बुरे कमेंट्स को रिबेस फाइल में "एडिट" के रूप में चिह्नित करें। यदि आप अपनी पहली कमिट को बदलना चाहते हैं, तो आपको इसे रिबास फ़ाइल में पहली पंक्ति के रूप में मैन्युअल रूप से जोड़ना होगा (अन्य लाइनों के प्रारूप का पालन करें)। फिर, जब git आपसे प्रत्येक कमिट में संशोधन करने के लिए कहता है, करते हैं

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

संपादन या खुलने वाले संपादक को बंद करें, और फिर करें

git rebase --continue

रिबास जारी रखने के लिए।

आप संपादक को पूरी तरह से यहाँ पर छोड़ कर --no-edit ताकि कमांड होगी:

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

सिंगल कमिट

जैसा कि कुछ टिप्पणीकारों ने उल्लेख किया है, यदि आप अभी हाल की प्रतिबद्धताओं को बदलना चाहते हैं, तो रिबेस कमांड आवश्यक नहीं है। बस करो

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

यह लेखक को निर्दिष्ट नाम में बदल देगा, लेकिन कमिट आपके कॉन्फ़िगर किए गए उपयोगकर्ता को git config user.name और git config user.email में सेट किया जाएगा। यदि आप कुछ निर्दिष्ट करने के लिए कमिटर सेट करना चाहते हैं, तो यह लेखक और कमिटर दोनों को सेट करेगा:

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

मर्ज कमिट्स पर ध्यान दें

मेरी मूल प्रतिक्रिया में थोड़ी खामी थी। यदि आपके <some HEAD before all your bad commits> , वर्तमान HEAD और आपके <some HEAD before all your bad commits> बीच कोई मर्ज कमिट हैं, तो git rebase उन्हें समतल कर देगा (और वैसे, यदि आप GitHub पुल अनुरोधों का उपयोग करते हैं, तो एक टन विलय होने जा रहा है अपने इतिहास में करता है)। यह बहुत बार बहुत अलग इतिहास को जन्म दे सकता है (जैसा कि डुप्लिकेट परिवर्तन "रिबेड आउट" हो सकता है), और सबसे खराब स्थिति में, यह git rebase को जन्म दे सकता है जो आपको कठिन मर्ज संघर्षों को हल करने के लिए कह सकता है (जो पहले से ही मर्ज किए गए हल में हल हो गए थे) )। समाधान -p को -p लिए -p फ्लैग का उपयोग करना है, जो आपके इतिहास की मर्ज संरचना को संरक्षित करेगा। git rebase मैनपेज में चेतावनी दी गई है कि -p और -i उपयोग से समस्याएँ हो सकती हैं, लेकिन BUGS अनुभाग में यह कहा गया है "संपादन करना और उनके प्रतिबद्ध संदेशों को फिर से लिखना ठीक काम करना चाहिए।"

मैंने उपरोक्त कमांड में -p जोड़ा है। उस मामले के लिए जहां आप अभी हाल ही में कमिट कर रहे हैं, यह कोई समस्या नहीं है।


  1. रन git rebase -i <sha1 or ref of starting point>
  2. उन सभी चिह्नों को चिह्नित करें जिन्हें आप edit (या e ) से बदलना चाहते हैं
  3. निम्नलिखित दो आदेशों को तब तक लूप करें जब तक आप सभी कमिट को संसाधित नहीं कर लेते:

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

यह अन्य सभी प्रतिबद्ध जानकारी (तिथियों सहित) को रखेगा। --reuse-message=HEAD विकल्प संदेश संपादक को लॉन्च करने से रोकता है।


Github का एक अच्छा समाधान है , जो निम्नलिखित शेल स्क्रिप्ट है:

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

आप इसे एक उपनाम के रूप में उपयोग कर सकते हैं ताकि आप कर सकें:

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

या अंतिम 10 के लिए:

git change-commits GIT_AUTHOR_EMAIL "[email protected]" "[email protected]" 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\" [email protected]; }; f "

स्रोत: https://github.com/brauliobo/gitconfig/blob/master/configs/.gitconfig

आशा है कि यह उपयोगी है।


इंटरएक्टिव रिबास का उपयोग करके, आप प्रत्येक बदलाव के बाद एक संशोधन कमांड रख सकते हैं। उदाहरण के लिए:

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

इस मामले में, जहां शीर्ष कुछ कमिट्स में बुरे लेखक हैं, आप यह सब git rebase -i अंदर कर सकते हैं, जो कि कमांड कमांड और --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="..." जोड़ें exec ... --author="..." सभी पंक्तियों के बाद खराब लेखक:

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

सहेजें और बाहर निकलें संपादक (चलाने के लिए)।

यह समाधान कुछ अन्य लोगों की तुलना में लंबा हो सकता है, लेकिन यह अत्यधिक नियंत्रणीय है - मुझे पता है कि वास्तव में यह हिट क्या करता है।

प्रेरणा के लिए @asmeurer को धन्यवाद।


एक लाइनर, लेकिन सावधान रहें यदि आपके पास एक बहु-उपयोगकर्ता रिपॉजिटरी है - तो यह सभी नए (लेखक) और कमिटर्स के समान होने पर बदल जाएगा।

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

स्ट्रिंग में लाइनब्रेक के साथ (जो बाश में संभव है):

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

जब किसी अन्य लेखक से अनमैरिड कमिटमेंट लेते हैं, तो इसे संभालने का एक आसान तरीका है।

git commit --amend --reset-author


ध्यान दें कि गिट दो अलग-अलग ई-मेल पते संग्रहीत करता है, एक कमिट करने वाले के लिए (वह व्यक्ति जिसने बदलाव किया है) और एक अन्य लेखक के लिए (वह व्यक्ति जिसने बदलाव लिखा है)।

अधिकांश स्थानों पर कमिट जानकारी प्रदर्शित नहीं होती है, लेकिन आप इसे git log -1 --format=%cn,%ce (या किसी विशेष कमिट को निर्दिष्ट करने के लिए log बजाय show उपयोग करके) के साथ देख सकते हैं।

अपने अंतिम कमिट के लेखक को बदलते समय git commit --amend --author "Author Name <[email protected]>" जितना सरल है, उतना ही जानकारी देने वाले के लिए कोई एक-लाइनर या तर्क नहीं है।

इसका समाधान है (अस्थायी रूप से, या नहीं) अपनी उपयोगकर्ता जानकारी बदलें, फिर उस कमिट में संशोधन करें, जो आपकी वर्तमान स्थिति के लिए कमेंट को अपडेट करेगा:

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

मान लीजिए कि आप अंतिम एन के लिए लेखक को बदलना चाहते हैं:

git rebase -i HEAD~4 -x "git commit --amend --author 'Author Name <[email protected]>' --no-edit"

टिप्पणियाँ

  • git commit --amend --no-edit ध्वज यह सुनिश्चित करता है कि git commit --amend अतिरिक्त पुष्टि नहीं करता है
  • जब आप git rebase -i उपयोग करते हैं, तो आप मैन्युअल रूप से उन कमिट का चयन कर सकते हैं जहाँ लेखक को बदलना है,

आपके द्वारा संपादित फ़ाइल इस तरह दिखाई देगी:

pick 897fe9e simplify code a little
exec git commit --amend --author 'Author Name <[email protected]>' --no-edit
pick abb60f9 add new feature
exec git commit --amend --author 'Author Name <[email protected]>' --no-edit
pick dc18f70 bugfix
exec git commit --amend --author 'Author Name <[email protected]>' --no-edit

आप फिर भी कुछ पंक्तियों को संशोधित करके देख सकते हैं कि आप लेखक को कहाँ बदलना चाहते हैं। यह आपको स्वचालन और नियंत्रण के बीच एक अच्छा मध्य क्षेत्र देता है: आप उन चरणों को देखते हैं जो चलेंगे, और एक बार जब आप सब कुछ बचा लेंगे तो एक बार में लागू किया जाएगा।


मैं संपूर्ण भंडार के लिए लेखक को फिर से लिखने के लिए उपयोग करता हूं, जिसमें टैग और सभी शाखाएं शामिल हैं:

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

फिर, जैसा कि फ़िल्टर-शाखा के MAN पृष्ठ में वर्णित है, फ़िल्टर-शाखा द्वारा समर्थित सभी मूल रेफ को हटा दें (यह विनाशकारी, बैकअप पहले है):

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

मैंने इस solution अनुकूलित किया, जो एक साधारण author-conv-file (फॉर्मेट, git-cvsimport लिए एक जैसा है) को git-cvsimport । यह सभी उपयोगकर्ताओं को बदलकर काम करता है जैसा कि सभी शाखाओं में author-conv-file में परिभाषित किया गया है।

cvs2git से git तक हमारी रिपॉजिटरी को स्थानांतरित करने के लिए हमने cvs2git के साथ संयोजन में इसका उपयोग किया।

यानी नमूना author-conv-file

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

लिपी:

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

यदि आप इस रिपॉजिटरी के एकमात्र उपयोगकर्ता हैं, तो आप git filter-branch (जैसा कि svick लिखा गया है ), या git fast-export / git fast-import प्लस फिल्टर स्क्रिप्ट (जैसा कि आलेख में वर्णित उत्तर में वर्णित है) का उपयोग करके इतिहास को फिर से लिख सकते हैं, या इंटरैक्टिव rebase । लेकिन उन दोनों में से कोई भी बदलाव पहले बदलाव के बाद से बदल जाएगा; इसका मतलब यह है कि किसी के लिए भी परेशानी जो आपकी शाखा के पूर्व-पुनर्लेखन पर उसके बदलावों के आधार पर है।

वसूली

यदि अन्य डेवलपर्स पूर्व-पुनर्लेखन संस्करण पर अपना काम आधारित नहीं करते हैं, तो सबसे सरल समाधान फिर से क्लोन (फिर से क्लोन) होगा।

वैकल्पिक रूप से वे git rebase --pull कोशिश कर सकते हैं, जो तेजी से आगे बढ़ेगा यदि उनकी रिपॉजिटरी में कोई बदलाव नहीं हुआ है, या फिर से लिखे गए कमिट के शीर्ष पर अपनी शाखा को रिबेस करें (हम मर्ज से बचना चाहते हैं, क्योंकि यह पूर्व में रहेगा- हमेशा के लिए फिर से लिखना)। यह सब मानते हुए कि उन्होंने काम नहीं किया है; परिवर्तन को दूर करने के लिए git stash का उपयोग करें अन्यथा परिवर्तन।

यदि अन्य डेवलपर्स फ़ीचर शाखाओं का उपयोग करते हैं, और / या git pull --rebase काम नहीं करता है जैसे कि अपस्ट्रीम सेट अप नहीं होने के कारण, उन्हें अपने काम को फिर से लिखने के बाद पुनः लिखना पड़ता है। उदाहरण के लिए, नए परिवर्तन लाने के बाद ( git fetch ), origin/master से / forked के आधार पर एक master शाखा के लिए, एक को चलाने की आवश्यकता है

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

यहाँ origin/[email protected]{1} पूर्व-पुनर्लेखन स्थिति ( gitrevisions से पहले), gitrevisions देखें।

1.6.5 संस्करण के बाद से जीआईटी में उपलब्ध रेफल्स / रिप्लेसमेंट / मैकेनिज्म का उपयोग करना वैकल्पिक समाधान होगा। इस समाधान में आप गलत ईमेल वाले कमिट के लिए प्रतिस्थापन प्रदान करते हैं; फिर जो कोई भी 'रीप्लेस' (रीचेक जैसी कोई चीज़) लेता है, वह अपने रीजनल fetch = +refs/replace/*:refs/replace/* कॉन्फिगरेशन में उपयुक्त स्थान पर रिफ्लेक्ट fetch = +refs/replace/*:refs/replace/* रीस्पेक प्राप्त करता है, तो उसे रिप्लेसमेंट पारदर्शी रूप से मिलेगा, और जो लोग उन रीफ़्स को नहीं लाते हैं। पुराने कमिट देखें।

प्रक्रिया कुछ इस प्रकार है:

  1. उदाहरण के लिए, गलत ईमेल के साथ सभी कमिट्स ढूंढें

    $ git log [email protected] --all
    
  2. प्रत्येक गलत प्रतिबद्ध के लिए, एक प्रतिस्थापन प्रतिबद्ध बनाएं, और इसे ऑब्जेक्ट डेटाबेस में जोड़ें

    $ 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. अब जब आपने ऑब्जेक्ट डेटाबेस में कमिट कर दिया है, तो आपको git replace कमांड कमांड का उपयोग करके अपने आप को सही और पारदर्शी तरीके से गलत कमेंट को बदलने के लिए git को बताना होगा:

    $ git replace <ID of wrong commit> <ID of corrected commit>
    
  4. अंत में, यह जाँचने के लिए सभी प्रतिस्थापन को सूचीबद्ध करें कि क्या यह प्रक्रिया सफल हुई

    $ git replace -l
    

    और जांचें कि क्या प्रतिस्थापन होता है

    $ git log [email protected] --all
    

आप निश्चित रूप से इस प्रक्रिया को स्वचालित कर सकते हैं ... ठीक है, git replace का उपयोग करने के अलावा सभी जो (अभी तक) बैच मोड नहीं है, इसलिए आपको उसके लिए शेल लूप का उपयोग करना होगा, या "हाथ से" प्रतिस्थापित करना होगा।

टेस्ट नहीं हुआ! YMMV।

ध्यान दें कि आप refs/replace/ तंत्र का उपयोग करते समय कुछ मोटे कोनों का सामना कर सकते हैं: यह नया है, और अभी तक बहुत अच्छी तरह से परीक्षण नहीं किया गया है


यदि आप ईजीट के साथ ग्रहण का उपयोग कर रहे हैं, तो एक काफी आसान उपाय है।
मान लें: आपके पास एक स्थानीय शाखा 'local_master_user_x' है, जिसे अमान्य उपयोगकर्ता के कारण दूरस्थ शाखा 'मास्टर' में नहीं धकेला जा सकता है।

  1. दूरस्थ शाखा 'मास्टर' की जाँच करें
  2. उन परियोजनाओं / फ़ोल्डरों / फ़ाइलों का चयन करें जिनके लिए 'local_master_user_x' में परिवर्तन हैं
  3. राइट-क्लिक करें - इसके साथ बदलें - शाखा - 'local_master_user_x'
  4. सही उपयोगकर्ता और स्थानीय शाखा 'मास्टर' के रूप में, इस बार फिर से ये बदलाव करें
  5. दूरस्थ 'मास्टर' के लिए धक्का

यह तब होता है जब आपके पास $ HOME / .ITconfig इनिशियलाइज़ नहीं होता है। आप इसे ठीक कर सकते हैं:

git config --global user.name "you name"
git config --global user.email [email protected]
git commit --amend --reset-author

git संस्करण 1.7.5.4 के साथ परीक्षण किया गया


लेखक (या कमिटर) को बदलने के लिए पूरे इतिहास को फिर से लिखना होगा। यदि आप इसके साथ ठीक हैं और सोचते हैं कि यह इसके लायक है तो आपको git फ़िल्टर-शाखा की जाँच करनी चाहिए। मैन पेज में आपको शुरू करने के लिए कई उदाहरण शामिल हैं। यह भी ध्यान दें कि आप लेखक, कमिटर, दिनांक आदि के नाम को बदलने के लिए पर्यावरण चर का उपयोग कर सकते हैं - गिट मैन पेज के "पर्यावरण चर" अनुभाग देखें।

विशेष रूप से, आप इस आदेश के साथ सभी शाखाओं और टैग के लिए सभी गलत लेखक के नाम और ईमेल को ठीक कर सकते हैं (स्रोत: गीथहब मदद ):

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

यह @ ब्रायन के संस्करण का अधिक विस्तृत संस्करण है:

लेखक और कमेंट को बदलने के लिए, आप ऐसा कर सकते हैं (स्ट्रिंग में लाइनब्रेक के साथ जो बैश में संभव है):

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. Refs / मूल से शुरू होने वाले Refs पहले से मौजूद हैं
    (इसका अर्थ है कि एक और फ़िल्टर-शाखा पहले रिपॉजिटरी पर चलाई गई है और तत्कालीन मूल शाखा संदर्भ को refs / मूल में बैकअप लिया गया है)

यदि आप इन त्रुटियों के बावजूद रन को बाध्य करना चाहते हैं, तो --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 का उपयोग करना है, जिसका अर्थ है कि केवल वर्तमान शाखा पर सभी संशोधनों को फ़िल्टर करना। और फिर कोई भी टैग (या अन्य रेफरी) फिर से लिखित शाखा में मौजूद नहीं होगा।


ऐसा करने का सबसे तेज़, सबसे आसान तरीका है - git rebase के --exec तर्क का उपयोग करना:

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

और यह सब स्वचालित रूप से काम करेगा, जो तब काम करता है जब आपके पास सैकड़ों आवागमन होते हैं।


इसे आज़माएं। यह उपर्युक्त के समान ही करेगा, लेकिन अंतःक्रियात्मक रूप से।

bash <(curl -s  https://raw.githubusercontent.com/majdarbash/git-author-change-script/master/run.sh)

संदर्भ: https://github.com/majdarbash/git-author-change-script


मैं अपना उदाहरण भी जोड़ना चाहता हूं। मैं दिए गए पैरामीटर के साथ एक bash_function बनाना चाहता हूं

यह मिंट-लिनेक्स -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;
}






git-rewrite-history