विलय conflics का समाधान करते समय गिट स्वचालित रूप से सम्मिलन संभाल सकता है?

Question

मर्ज विवादों को हल करते समय, अधिकांश समय ऐसा होता है क्योंकि फ़ाइल के एक ही बिंदु पर दो लोग डाले जाते हैं। और मैं हमेशा वही करता हूं: बाईं ओर से नया कोड का उपयोग करें, दाएं तरफ से नया कोड कॉपी करें और बाईं ओर से कोड के बाद इसे संलग्न करें।

यह मैं सोच रहा है, अगर मैं हमेशा एक ही है, यह इस स्वचालित करने के लिए संभव हो जाना चाहिए मिला है। क्या मैं गिट को भरोसा दिला सकता हूं कि दोनों नए हिस्सों का इस्तेमाल सिर्फ एक के बाद किया जा सकता है?

मुझे लगता है कि, अगर सम्मिलन कुछ लाइनें अलग होगा (एक स्थिति Git स्वचालित रूप से हल करता है), यह किसी भी कम बग प्रस्तुत करने की संभावना नहीं होगा। मैं वैसे भी परिणाम की जांच करने जा रहा हूँ।

(वर्तमान में मैं अपने mergetool रूप DiffMerge उपयोग कर रहा हूँ, कि यदि कोई फर्क नहीं पड़ता।)

Answer 1

आप उस के लिए declare a merge driver करने की आवश्यकता होगी:

यह assigned in a .gitattributes गंतव्य शाखा में किया जाता है (जहां आपने मर्ज)

echo yourFiles merge=addTheirs>.gitattributes 
git add .gitattributes 
git commit -m "record addTheirs merge driver" 

(yourFiles की जगह फ़ाइलों के पैटर्न से आप को देखने के लिए कि मर्ज संकल्प लागू करना चाहते हैं)

01 कर रहे हैं

लेकिन यह भी जरूरत है स्थानीय स्तर पर विन्यस्त किया जा करने के लिए:

git config merge.addTheirs.name "keep additions only" 
git config merge.addTheirs.driver addTheirs.sh 

चाल addTheirs स्क्रिप्ट पर है, %O साथ कहा जाता है, %A, %B (पूर्वज, हमारा, उनकी)

एक diff -u %A %B आप जिसे दे देंगे जैसे भिन्नता की:

@@ -1,11 +1,11 @@ 
line 1 
line 2 
-line 3 from master 
+line 3 from dev 
line 4 
line 5 
line 6 
line 7 
line 8 
+line 8bis from dev 
line 9 
line 10 
-line 11 

हालांकि diff हेडर अनुपलब्ध है, एक patch अभी भी करने में सक्षम होगा नई लाइनों को जोड़ने और पुराने को हटा (और क्या आप चाहते हमारा रखने के लिए, और उनकी जोड़ने के लिए)।
विंडोज़ पर, आप gnu patch, but you need to add a manifest ले सकते हैं।

patch -u -p0 $3 $2 

आप इसे लागू करने से पहले पैच से विलोपन को फिल्टर करने की कोशिश कर सकते।

patch=$(diff -u $2 $3 | grep -v "^-") 

लेकिन हंक हैडर (@@ -1,11 +1,11 @@) अब उम्मीद लाइनों की संख्या से मेल खाएंगे (यदि आप केवल 2 पंक्तियाँ जोड़ें और 0 निकाल देता है, यह +1,13 साथ, खत्म होना चाहिए निट +1,11)

आप की जरूरत है करने के लिए अपने पैच पर कार्रवाई: बाहर विलोपन

• फिल्टर
• समायोजित हंक हेडर

इसका मतलब है कि addTheirs.sh (यहां तक ​​कि विंडोज पर अपने पथ में डाल करने के लिए,) हो सकता है:

#!/bin/bash 

patch=$(diff -u $2 $3) 
echo "${patch}" > f.pp 

patch2=$(./padd f.pp) 
echo "$patch2" > f.p 

patch -u -p0 $2 -i f.p 

(diff 200+ यूनिक्स का हिस्सा कमांड git-for-windows package का हिस्सा है, इसलिए फिर से है, के सभी यह विंडोज या यूनिक्स पर काम करता है)

'पैड' (पैच एड) उपयोगिता एक स्क्रिप्ट है जो प्रत्येक हंक से किसी भी विलोपन रेखा को हटाती है, और वास्तविक लाइन नंबर का ट्रैक रखने के लिए हंक हेडर को अद्यतन करती है।

मैं जाओ में मेरा बनाया (https://golang.org/, बस unzip a go distro कहीं भी आप चाहते हैं और अपने PATH में जोड़ने)

कॉपी एक padd.go फ़ाइल में निम्न, और टाइप go build padd.go: आप padd निष्पादन मिलता है कि मर्ज चालक कर सकते हैं पैच समायोजित करने के लिए कॉल करें।

package main 

import (
    "fmt" 
    "io/ioutil" 
    "os" 
    "regexp" 
    "strconv" 
    "strings" 
) 

// @@ 1,11 1,13 @@ <= extract prefix '@@ 1, 11 1,' and counter '13' 
var chunkre = regexp.MustCompile(`(?m)^(@@.*,)(\d+)\s+@@.*$`) 
var patch = "" 

func main() { 
    fname := os.Args[1] 
    f := "" 
    if b, err := ioutil.ReadFile(fname); err != nil { 
     panic(err) 
    } else { 
     f = string(b) 
    } 
    lines := strings.Split(f, "\n") 

    prefix := "" 
    counter := 0 
    var err error 
    hunk := "" 
    for _, line := range lines { 
     snbadd := chunkre.FindAllStringSubmatch(line, -1) 
     if len(snbadd) > 0 { 
      updatePatch(hunk, prefix, counter) 
      hunk = "" 
      prefix = snbadd[0][1] 
      if counter, err = strconv.Atoi(snbadd[0][2]); err != nil { 
       panic(err) 
      } 
     } else if prefix != "" { 
      if strings.HasPrefix(line, "-") { 
       counter = counter + 1 
       line = " " + line[1:] 
      } 
      hunk = hunk + line + "\n" 
     } 
    } 
    updatePatch(hunk, prefix, counter) 
    fmt.Println(patch) 
} 

func updatePatch(hunk, prefix string, counter int) { 
    if hunk != "" { 
     header := prefix + fmt.Sprintf("%d @@\n", counter) 
     patch = patch + header + hunk 
    } 
}