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

2390

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

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

git  version-control  git-filter-branch  git-rewrite-history 
— फ्लेवियो एमिएरो
स्रोत
13
प्रश्न: क्या git फ़िल्टर-शाखा का उपयोग SHA1 के पिछले टैग, संस्करण और ऑब्जेक्ट के लिए सुरक्षित है? या लेखक का नाम बदलने से संबंधित SHA1 की स्थिति बदल जाएगी?
— एंडीएल
36
हैश में परिवर्तन होगा
— उपलब्ध नहीं
3
मूर्त रूप से, मैंने एक छोटी स्क्रिप्ट बनाई, जिसने आखिरकार मेरे लिए मूल कारण तय किया। gist.github.com/tripleee/16767aa4137706fd896c
— ट्रिपलआई
2
@impinball प्रश्न की उम्र शायद ही प्रासंगिक है। एक नया डुप्लिकेट प्रश्न बनाना सवाल से बाहर है। मुझे लगता है कि मैं एक प्रश्न बना सकता हूं जो इस विशेष उत्तर को भीख देता है लेकिन मैं पूरी तरह से आश्वस्त नहीं हूं कि यह सब दृश्यता प्राप्त करेगा। ऐसा नहीं है कि यहाँ Git प्रश्नों की कमी है ... ख़ुशी है कि मैं वैसे भी मदद कर सकता हूँ।
— ट्रिपल
8
GitHub के पास इसके लिए विशेष स्क्रिप्ट है: help.github.com/articles/changing-author-info
— तैमूर बर्निकोविच

जवाबों:

1210

यह उत्तर उपयोग करता है git-filter-branch, जिसके लिए डॉक्स अब यह चेतावनी देते हैं:

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

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

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

#!/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
— पैट नोट्ज़
स्रोत
610
Github के पास उस help.github.com/articles/changing-author-info के लिए एक सार्वजनिक स्क्रिप्ट है और यह बहुत अच्छा काम करता है!
— defvol
34
स्क्रिप्ट निष्पादित करने के बाद आप "git update-ref -d refs / original / refs / heads / master" निष्पादित करके बैकअप शाखा को हटा सकते हैं।
— DR
7
@rodowi, यह मेरे सभी कमेंट्स की नकल करता है।
— राफेल बैरोस
6
@RafaelBarros लेखक की जानकारी (इतिहास में कुछ और की तरह) कमिट की sha कुंजी का हिस्सा है। इतिहास में कोई भी बदलाव एक नए सिरे से लिखा गया है, जो सभी आईडी के लिए नए आईडी के लिए अग्रणी है। तो एक साझा रेपो पर फिर से लिखना न करें या यह सुनिश्चित करें कि सभी उपयोगकर्ता इसके बारे में जानते हैं ...
— johannes
20
हल का उपयोग करgit push --force --tags origin HEAD:master
— mcont
1577

नोट: यह उत्तर SHA1s को बदलता है, इसलिए इसका उपयोग उस शाखा पर करने पर ध्यान दें जिसे पहले ही धकेल दिया गया है। यदि आप केवल एक नाम की वर्तनी को ठीक करना चाहते हैं या एक पुराने ईमेल को अपडेट करना चाहते हैं, तो git आपको इतिहास का उपयोग किए बिना इसे फिर से लिखने की अनुमति देता है .mailmap। मेरा दूसरा जवाब देखिए ।

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

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

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

सिंगल कमिट

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

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

यह नाम निर्दिष्ट करने के लिए लेखक बदल जाएगा, लेकिन committer में अपने कॉन्फ़िगर किए गए उपयोगकर्ता के लिए स्थापित किया जाएगा 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उन्हें समतल कर देगा (और वैसे, यदि आप गिटहब पुल अनुरोधों का उपयोग करते हैं, तो आपके इतिहास में मर्ज कमिट का एक टन होने जा रहा है)। यह बहुत बार बहुत अलग इतिहास का कारण बन सकता है (जैसा कि डुप्लिकेट परिवर्तन "रिबेड आउट" हो सकता है), और सबसे खराब स्थिति में, यह git rebaseआपको कठिन मर्ज संघर्षों को हल करने के लिए कह सकता है (जो पहले से ही मर्ज कमिट में हल हो गए थे)। समाधान -pध्वज का उपयोग करना है git rebase, जो आपके इतिहास के मर्ज संरचना को संरक्षित करेगा। मानवपृष्ठ git rebaseचेतावनी देता है कि उपयोग करने -pऔर -iमुद्दों को जन्म दे सकता है, लेकिन मेंBUGS अनुभाग में कहा गया है "संपादन करना और उनके प्रतिबद्ध संदेशों को फिर से लिखना ठीक काम करना चाहिए।"

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

— asmeurer
स्रोत
27
हालांकि, अगर आप जोड़ी और लेखक को बदलना भूल जाते हैं, तो अजीब कमिट के लिए बढ़िया है
— mloughran
32
+1 ठेठ एक-गलती सुधार के लिए usecase का उल्लेख करने के लिए: git कमिट --amend --author = उपयोगकर्ता नाम
— नाथन किड
12
यह एकदम सही है, मेरा सबसे आम उपयोग यह है कि मैं दूसरे कंप्यूटर पर बैठ जाता हूं और लेखक को सेट करना भूल जाता हूं और इस तरह आमतौर पर ठीक करने के लिए <5 कमिट करता हूं।
— Zitrax
57
git commit --amend --reset-authorएक बार भी काम करता है user.nameऔर user.emailसही ढंग से कॉन्फ़िगर किया गया है।
— १६:०४ पर
14
<commit>उपयोग करने के बाद user.nameऔर आने user.emailसे सभी लेखक की जानकारी फिर से लिखना ~/.gitconfig: भागो git rebase -i <commit> --exec 'git commit --amend --reset-author --no-edit', बचाओ, छोड़ो। संपादित करने की आवश्यकता नहीं है!
— ntc2
588

आप भी कर सकते हैं:

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
— Rognon
स्रोत
4
Env- फ़िल्टर का उपयोग आसान समाधान नहीं है? यकीन नहीं होता कि यह अधिक वोट क्यों मिल रहा है, फिर।
— कलंक
3
फिर लिंक टूटा है। हम इन परिवर्तनों को दूसरे भंडार में कैसे धकेलेंगे?
— रसेल
28
env-filter सभी कमिट को बदल देगा। यह समाधान एक सशर्त अनुमति देता है।
— user208769
5
"A previous backup already exists in refs/original/ Force overwriting the backup with -f"क्षमा करें, लेकिन -f-flag इस स्क्रिप्ट को दो बार निष्पादित करते समय क्या होने वाला है। दरअसल यह ब्रायन के जवाब में है, फिल्टर-ब्रांच के समाधान के बाद गड़बड़ी के बारे में खेद है।
— hhh
2
@ user208769 एनवी-फिल्टर भी एक सशर्त की अनुमति देता है; मेरा जवाब
— देखिए
558

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

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

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

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
— ब्रायन गियानफोर्को
स्रोत
मामूली बिंदु, निर्यात वास्तव में बहुत ही कम है, हालांकि इससे कोई नुकसान नहीं होता है। जैसे git-filter-branch --env-filter "GIT_AUTHOR_NAME = 'नया नाम'; GIT_AUTHOR_EMAIL = 'नया ईमेल'" HEAD।
— एलेक द गीक
4
यदि आप HEADकमांड के अंत में निर्दिष्ट करते हैं तो यह सभी कमिट को फिर से क्यों लिखता है ?
— निक वोल्किन
1
यह मेरी बिटबकेट रिपॉजिटरी, किसी भी विचार के लिए काम नहीं करता है? मैं git push --force --tags origin 'refs/heads/*'सलाह दी गई आज्ञा के बाद करता
— हूं
1
इसके लिए पुश कमांड है:$git push --force --tags origin 'refs/heads/master'
— HARSH NILESH PATHAK
1
साफ; यह पुराने टाइमस्टैम्प भी रखता है।
— धर्मटर्ट
221

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

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 के साथ परीक्षण किया गया

— lrkwz
स्रोत
9
यह अंतिम प्रतिबद्ध पर वास्तव में अच्छी तरह से काम करता है। अच्छा और सरल। नहीं करता है , का उपयोग कर एक वैश्विक परिवर्तन होने के लिए --localभी काम करता है
— बेन
यह मेरे लिए एक बड़ा विजेता था! git commit --amend --reset-author --no-editआदेश यदि आप गलत लेखक जानकारी के साथ प्रतिबद्ध बनाया है, उसके बाद सही लेखक के बाद-तथ्य के माध्यम से सेट विशेष रूप से उपयोगी है git config। जब मैंने अपना ईमेल अपडेट करना था, तब ही मैंने अपना $ $ बचा लिया।
— इकोब्रॉडी
186

एक एकल वचन के लिए:

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

(asmeurer के जवाब से निकाला)

— blueyed
स्रोत
14
लेकिन यह केवल तभी है जब यह सबसे हालिया प्रतिबद्ध है
— रिचर्ड
4
के अनुसार git help commit, git commit --amend"वर्तमान शाखा के सिरे" (जो कि HEAD है) पर कमिट को बदलता है। यह आम तौर पर सबसे हाल की प्रतिबद्धता है, लेकिन आप इसे किसी भी प्रतिबद्ध बना सकते हैं जिसे आप चाहते हैं कि पहले से जाँच करें git checkout <branch-name>या साथ git checkout <commit-SHA>।
— रोरी ओ'केन
12
लेकिन अगर आप ऐसा करते हैं, तो माता-पिता के रूप में पहले से ही कमिट करने वाले सभी गलत कामों की ओर इशारा करेंगे। उस बिंदु पर फ़िल्टर-शाखा का उपयोग करना बेहतर है।
— जॉन गिएटजेन
3
@ जॉनगैनज़ेन: आप कमिट्स को वापस उसी पर वापस कर सकते हैं जिसे ठीक करने के लिए बदल दिया गया है। हालाँकि, अगर आप> 1 कमिट कर रहे हैं, तो जैसा कि उल्लेख किया गया है, फ़िल्टर-शाखा शायद बहुत आसान होने जा रही है।
— थानाटोस
5
ध्यान दें कि यह परिवर्तन केवल प्रतिबद्ध है authorऔर नहींcommitter
— निक वोलिनकिन
179

इस मामले में, जहां शीर्ष कुछ कमिट्स में बुरे लेखक हैं, आप कमांड और कमिट 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 को धन्यवाद।

— एलेक्स ब्राउन
स्रोत
26
निश्चित रूप से भयानक। क्या आप रेपो के स्थानीय विन्यास में user.name और user.email को सेट करके इसे छोटा कर सकते हैं, और फिर प्रत्येक पंक्ति केवल है exec git commit --amend --reset-author -C HEAD?
— एंड्रयू
1
फिल्टर-शाखा का उपयोग करने के लिए विहित जवाब, मेरे लिए बस हटाए गए refs / प्रमुख / मास्टर। तो आपके नियंत्रणीय, संपादन योग्य समाधान के लिए +1। धन्यवाद!
— jmtd 20
आप Someone else's commitइसके बजाय क्यों शुरू करते हैं my bad commit 1? मैंने अभी HEAD^^पिछले 2 कमिट में संशोधन करने की कोशिश की , और यह पूरी तरह से ठीक काम किया।
— fredoverflow
3
git rebase -i HEAD^^^^^^आप के स्थान पर भी लिख सकते हैंgit rebase -i HEAD~6
— पैट्रिक श्ल्टर
1
कृपया ध्यान दें कि इससे आवागमन का समय बदल जाता है। सही टाइमस्टैम्प पर वापस जाने के लिए stackoverflow.com/a/11179245/1353267 देखें
— Samveen
111

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" = "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"
'
— ओलिवियर वर्डीयर
स्रोत
5
पूरी तरह से काम किया। git reset --hard HEAD^अन्य स्थानीय रिपॉजिटरी पर बस कुछ समय के लिए उन्हें पहले वाले संस्करण में, git pullसंशोधित संस्करण में लाने के लिए था , और यहाँ मैं बिना किसी लाइन वाले unknown <stupid-windows-user@.StupidWindowsDomain.local>(git के डिफॉल्ट को प्यार करने वाला) पाया गया।
— एलन प्लम
1
मैं इसके बाद धक्का नहीं दे सकता। क्या मुझे "-f" का उपयोग करना है?
— फिश मॉनीटर
9
मैंने किया git push -f। साथ ही, इसके बाद स्थानीय रिपोज को फिर से मंगाना पड़ता है।
— फिश मॉनीटर
यदि आपको किसी विशिष्ट शाखा पर शेल स्क्रिप्ट को चलाने की आवश्यकता है तो आप अंतिम पंक्ति को इसमें बदल सकते हैं: "'master..your-branch-name" (यह मानते हुए कि आप मास्टर की शाखित हैं)।
— रॉबर्ट काजिक
लिंक पर क्लिक करें <अच्छा समाधान> जैसा कि स्क्रिप्ट को अपडेट किया गया है
— gxpr
82

जैसा कि उल्लेख किया गया है, इतिहास का पुनर्लेखन खतरनाक है और अन्य लोगों के भंडार को तोड़ देगा।

लेकिन अगर आप वास्तव में ऐसा करना चाहते हैं और आप एक बैश वातावरण में हैं (लिनक्स में कोई समस्या नहीं है, तो विंडोज पर, आप गिट बैश का उपयोग कर सकते हैं, जो गिट की स्थापना के साथ प्रदान किया जाता है), गिट फ़िल्टर-शाखा का उपयोग करें :

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
— svick
स्रोत
2
ध्यान दें कि यह पुराने कमिट्स की ओर इशारा करते हुए किसी भी टैग को छोड़ देगा। --tag-name-filter cat"यह काम करो" विकल्प है।
— रोमन स्टार्कोव
@romkyn किसी भी विचार को टैग कैसे बदलें?
— निक वोल्किन
@NickVolynkin हाँ, आप निर्दिष्ट करें --tag-name-filter cat। यह वास्तव में डिफ़ॉल्ट व्यवहार होना चाहिए था।
— रोमन स्टार्कोव
48

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

git commit --amend --reset-author

— Ryanmt
स्रोत
1
एक सिंगल कमिट के लिए, और यदि आप अपना उपयोगकर्ता नाम रखना चाहते हैं, तो यह सबसे आसान तरीका है।
— पेड्रो बेनेविदेस
7
आप इसे --no-editऔर भी आसान बनाने के लिए जोड़ सकते हैं , जैसा कि आम तौर पर ज्यादातर लोग केवल ईमेल पते को अपडेट करना चाहते हैं न कि प्रतिबद्ध संदेश
— प्लेगहैमर
तुम लोग अभी पिछले अद्यतन करने के लिए के लिए नए के साथ की ई-मेल / उपयोगकर्ता नाम प्रतिबद्ध Git आदेश का हिस्सा कृपया कर सकते
— आदि
क्या आपने यह कोशिश की? इसका एक साइड इफेक्ट होना चाहिए, अगर नहीं stackoverflow.com/a/2717477/654245 एक अच्छे रास्ते की तरह दिखता है।
— रेयान्मट
46

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

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

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

— brauliobo
स्रोत
"git: 'change-commits' कोई git कमांड नहीं है। 'git --help' देखें।"
— Native_Mobile_Arch_Dev
इस कमांड और मास्टर के साथ सिंक करने के बाद इतिहास में सभी कमेंट्स डुप्लिकेट हैं! अन्य उपयोगकर्ताओं के भी :(
— व्लादिमीर
@ व्लादिमीर से उम्मीद की जाती है, कृपया इतिहास को बदलने के बारे में अध्ययन करें
— brauliobo
39

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

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

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 / मूल में बैकअप है )

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

— stigkj
स्रोत
एक ऐसी प्रक्रिया की आपूर्ति के लिए यश जो सभी रेफ / शाखाओं पर परिवर्तन करता है ।
— जॉनी उटाह
25

आखिरी एन के लिए लेखक को बदलने के लिए एक एकल आदेश :

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

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

— क्रिस Maes
स्रोत
बहुत बढ़िया! धन्यवाद!
— पाब्लो लल्लोनी
मैंने HEAD ~ 8 का इस्तेमाल किया और यह पिछले 8 कमिट्स से ज्यादा रास्ता दिखाता है।
— ब्रायन ब्राइस
1
@BryanBryce अगर वहाँ मर्ज शामिल हैं, चीजें जटिल हो जाती हैं :)
— क्रिस Maes
@ क्रिसमिस आह, मैं देख रहा हूं कि क्या चल रहा है। मैं उन लोगों के साथ गड़बड़ नहीं करना चाहता, बस मैं जिस शाखा पर हूं।
— ब्रायन ब्राइस
उस मामले में, माना जाता है कि आप मास्टर से शाखित हैं, आप कर सकते हैं:git rebase -i master -x ...
— क्रिस मेस
23
  1. Daud 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विकल्प शुभारंभ से संदेश संपादक से बचाता है।

— sporsh
स्रोत
23

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

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
— टन वैन डेन हेवेल
स्रोत
2
इसका उपयोग करना बहुत महत्वपूर्ण है --tag-name-filter cat। अन्यथा आपके टैग कमिट्स की मूल श्रृंखला पर बने रहेंगे। अन्य उत्तर इसका उल्लेख करने में विफल रहते हैं।
— जेबरल
21

मैंने इस समाधान को अनुकूलित किया जो एक सरल 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
— लीफ ग्रुएनवोल्ड
स्रोत
धन्यवाद, मुझे आश्चर्य है कि यह कोर git (या git-svn) कार्यक्षमता क्यों नहीं है। यह git svn क्लोन के लिए एक ध्वज के साथ किया जा सकता है, लेकिन git फ़िल्टर-शाखा में नहीं ...
— Daniel Hershcovich
20

मुझे यह बताना चाहिए कि यदि एकमात्र समस्या यह है कि लेखक / ईमेल आपके सामान्य से अलग है, तो यह कोई समस्या नहीं है। सही फिक्स एक फाइल बनाना है जिसे .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 देखें ।

इससे यहां अन्य सभी समाधानों का लाभ मिलता है, जिसमें आपको इतिहास को फिर से लिखना नहीं पड़ता है, जो आपके ऊपर होने पर समस्या पैदा कर सकता है, और हमेशा गलती से डेटा खोने का एक अच्छा तरीका है।

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

— asmeurer
स्रोत
18

मैंने प्रस्तुत संस्करणों को आक्रामक तरीके से पाया, खासकर यदि आप अन्य डेवलपर्स से पैच करते हैं, तो यह अनिवार्य रूप से उनके कोड को चुराएगा।

नीचे दिया गया संस्करण सभी शाखाओं पर काम करता है और इसे रोकने के लिए लेखक और कॉमिटर को अलग-अलग बदलता है।

सभी विकल्प के लिए कुडोस से लीफ81।

#!/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
— drahnr
स्रोत
18

  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
— साजिब खान
स्रोत
2
बहुत अच्छा जवाब। मुझे यह पसंद है कि बदलाव बहुत अद्यतन से लपेटे जाते हैं, यहाँ तक कि गिट की सफाई भी करते हैं
— Aleks
12

इसका सबसे तेज़, सबसे आसान तरीका यह है कि 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
...

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

— रे रयान
स्रोत
9

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

स्वास्थ्य लाभ

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

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

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

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

यहाँ origin/master@{1} प्री-रीराइट स्टेट (लाने से पहले), gitrevisions देखें ।

1.6.5 संस्करण के बाद से जीआईटी में उपलब्ध रेफल्स / रिप्लेसमेंट / मैकेनिज्म का उपयोग करना वैकल्पिक समाधान होगा । इस समाधान में आप गलत ईमेल वाले कमिट के लिए प्रतिस्थापन प्रदान करते हैं; फिर जो कोई भी 'रीप्लेस' को रीच करता है (कुछ इस तरह)fetch = +refs/replace/*:refs/replace/* रीफ़्स उनके स्थान पर रिफ़ेक चीज़ .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 replace:

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

  4. अंत में, यह जाँचने के लिए सभी प्रतिस्थापन को सूचीबद्ध करें कि क्या यह प्रक्रिया सफल हुई

    $ git replace -l

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

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

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

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

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

— जकुब नारबस्की
स्रोत
6

यदि आप जो ठीक करना चाहते हैं वह नवीनतम हैं, और उनमें से सिर्फ एक जोड़े हैं, तो आप संयोजन का उपयोग कर सकते हैं git resetऔरgit stash सही नाम और ईमेल को कॉन्फ़िगर करने के बाद फिर से उन्हें वापस करने के लिए ।

अनुक्रम कुछ इस तरह होगा (2 गलत कामों के लिए, कोई लंबित परिवर्तन नहीं):

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
— djromero
स्रोत
5

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

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

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

pick a07cb86 Project tile template with full details and styling
x git commit --amend --reset-author -Chead
— j16r
स्रोत
3
इसके साथ समस्या यह है कि अन्य प्रतिबद्ध मेटाडेटा (जैसे दिनांक और समय) में भी संशोधन किया गया है। मुझे सिर्फ इतना मुश्किल लगा ;-)।
— जूल
5

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

अधिकांश स्थानों पर कमिटरी जानकारी प्रदर्शित नहीं होती है, लेकिन आप इसे 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
— सर एथोस
स्रोत
ध्यान दें कि पुराना मान अभी भी कुछ स्थानों पर है path\to\repo\.git। मुझे अभी तक यकीन नहीं है कि आपको इसे पूरी तरह से समाप्त करने के लिए क्या करना होगा। दुर्भाग्य से संशोधन () मिटा नहीं लगता है।
— रफिन
5

हमने आज एक समस्या का अनुभव किया है जहां एक लेखक के नाम का एक UTF8 चरित्र बिल्ड सर्वर पर परेशानी पैदा कर रहा था, इसलिए हमें इसे ठीक करने के लिए इतिहास को फिर से लिखना पड़ा। उठाए गए कदम थे:

चरण 1: यहां दिए गए निर्देशों के अनुसार, भविष्य के सभी कार्यों के लिए अपने उपयोगकर्ता नाम को बदलें: https://help.github.com/articles/setting-your-username-in-git/

चरण 2: निम्न बैश स्क्रिप्ट चलाएँ:

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

त्वरित अवलोकन: अपनी रिपॉजिटरी को एक अस्थायी फ़ाइल में चेक करें, सभी दूरस्थ शाखाओं की जांच करें, स्क्रिप्ट को चलाएं जो इतिहास को फिर से लिखेगी, नए राज्य का एक बल पुश करें, और परिवर्तनों को प्राप्त करने के लिए अपने सभी सहयोगियों को एक रिबास पुल करने के लिए कहें।

ओएस एक्स पर इसे चलाने में हमें परेशानी हुई क्योंकि इसने किसी तरह से प्रतिबद्ध संदेशों में लाइन एंडिंग को गड़बड़ कर दिया था, इसलिए हमें इसे बाद में लिनक्स मशीन पर चलाना पड़ा।

— मिलो रानेलोविक
स्रोत
5

आपकी समस्या वास्तव में आम है। देखें " फिक्स लेखक Git में सूची को Mailmap का उपयोग करते हुए "

सरलता के लिए, मैंने इस प्रक्रिया को आसान बनाने के लिए एक स्क्रिप्ट बनाई है: गिट-चेंजमेल

उस स्क्रिप्ट को अपने रास्ते पर रखने के बाद, आप कमांड जारी कर सकते हैं जैसे:

  • वर्तमान शाखा पर लेखक मिलान बदलें

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

  • लेखक और कमेंट मिलान को <शाखा> और <शाखा 2> पर बदलें। -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 से साफ़ करें

— albfan
स्रोत
1
जब मैं आपकी आज्ञा चलाता हूं, तो यह कहता है कि "घातक: 'git-changemail' निष्पादित नहीं कर सकता: अनुमति से इनकार किया"
— गोविंद
3

मैं अपना उदाहरण भी जोड़ना चाहता हूं। मैं दिए गए पैरामीटर के साथ एक 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:-"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;
}
— stephanfriedrich
स्रोत
2

यदि आप इस रेपो के एकमात्र उपयोगकर्ता हैं या आप संभवतः अन्य उपयोगकर्ताओं के लिए रेपो को तोड़ने के बारे में परवाह नहीं करते हैं, तो हाँ। यदि आपने इन कमिटों को धकेल दिया है और वे मौजूद हैं जहां कहीं और उन्हें एक्सेस कर सकते हैं, तो नहीं, जब तक कि आप अन्य लोगों के रिपोज को तोड़ने के बारे में परवाह नहीं करते हैं। समस्या यह है कि इन कमिट्स को बदलने से आप नए SHAs उत्पन्न कर रहे हैं, जिसके कारण उन्हें अलग-अलग कमिट के रूप में माना जाएगा। जब कोई व्यक्ति इन बदले हुए कमिटों में खींचने की कोशिश करता है, तो इतिहास अलग और कबूम होता है।

यह पृष्ठ http://inputvalidation.blogspot.com/2008/08/how-to-change-git-commit-author.html यह बताता है कि यह कैसे करना है। (मैंने यह इतना YMMV की कोशिश नहीं की है)

— baudtack
स्रोत
तो, user.email को फिर से लिखने का कोई सुरक्षित तरीका नहीं है। बाकी सबको उड़ाए बिना। मुझे पता था कि इतिहास को फिर से लिखना एक बुरा विचार था, मैंने बस सोचा था कि इसे सुरक्षित रूप से करने का एक साफ तरीका हो सकता है। धन्यवाद।
— मनुभूमि ०
@ जल्दस्लेव: refs/replace/तंत्र की कोशिश करो ।
— जकुब नारबस्की 21
meta.stackexchange.com/a/8259/184684 - aka, उन्हें उत्तर में बनाने के लिए लिंक।
— रफिन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.