Saya baru-baru belajar bahwa ketika menggabungkan dua cabang di git, jika ada perubahan pada dua baris yang berdekatan git menyatakan ini sebagai konflik. Misalnya, jika file test.txtmemiliki konten ini:

Line 1: A
Line 2: B
Line 3: C
Line 4: D

dan di cabang masterkita ubah ini menjadi

Line 1: A
Line 2: B1
Line 3: C
Line 4: D

sementara di cabang testingkita ubah ini menjadi

Line 1: A
Line 2: B
Line 3: C1
Line 4: D

dan kemudian mencoba untuk menggabung testingke dalam master, git menyatakan gabungan konflik. Harapan naif saya adalah bahwa merger akan terjadi tanpa konflik dan menghasilkan ini:

Line 1: A
Line 2: B1
Line 3: C1
Line 4: D

Saya yakin ada alasan bagus mengapa git tidak bergabung dengan cara ini. Adakah yang bisa menjelaskan alasan ini?

Dengan asumsi bahwa potongan kode ini

x=0
x+=1 if foo
x+=1 if bar
return x

telah diubah dalam satu cabang menjadi ini

x=0
x+=1 if foo && xyzzy
x+=1 if bar
return x

dan di cabang lain ke dalam ini

x=0
x+=1 if foo
x+=1 if bar && xyzzy
return x

maka saya tidak ingin git menggabungkannya dengan ini

x=0
x+=1 if foo && xyzzy
x+=1 if bar && xyzzy
return x

tanpa membuatku khawatir.

Untuk menghindari menyebabkan masalah seperti itu, git biasanya menolak untuk secara otomatis menggabungkan perubahan menyentuh garis terdekat. Ini memberi Anda kesempatan untuk memverifikasi apakah logika program akan rusak atau tidak.

Contoh ini sepele, tetapi ketika menggabungkan cabang besar risiko konflik "logis" serupa jauh lebih besar. Kadang-kadang saya bahkan ingin konteksnya menjadi lebih besar daripada saat ini.

Apakah ini hanya perilaku git?

Setelah berdiskusi dengan seorang kolega, saya baru mencoba, dan SVN menanganinya tanpa masalah: Anda mendapatkan 2 baris yang dimodifikasi.

Kemampuan gabungan dari beberapa VCS diuji di sini untuk bazaar, darcs, git, dan lincah : https://github.com/mndrix/merge-this

Tampaknya hanya darcs yang berhasil menggabungkan kasus "garis yang berbatasan".

Menerapkan perubahan yang berdekatan ke file bukanlah masalah yang sulit. Saya benar-benar berpikir perilaku ini telah dipilih dengan sengaja.

Mengapa seseorang memutuskan bahwa memodifikasi garis yang berdekatan menghasilkan konflik?

Saya akan berpikir ini untuk memaksa Anda melihatnya .

int max = MAX_ITEMS;
for(unsigned int i = 0; i < max; i++)
    do_stuff(i);

Modif nomor 1, pada master:

int max = MAX_ITEMS/2; // Do stuff only on the first half
for(unsigned int i = 0; i < max; i++)
    do_stuff(i);

Modif nomor 2, digabung dari cabang:

int max = MAX_ITEMS;
for(unsigned int i = 0; i < max/2; i++) // max/2: only on 1st half
    do_stuff(i);

Setelah bergabung, Anda tidak menginginkan itu:

int max = MAX_ITEMS/2; // Do stuff only on the first half
for(unsigned int i = 0; i < max/2; i++) // max/2: only on 1st half
    do_stuff(i);

Melihat perilaku ini sebagai fitur

Anda dapat mengubah perilaku penggabungan git menjadi keuntungan. Ketika Anda perlu menjaga 2 baris konsisten tetapi Anda tidak dapat mendeteksinya (pada waktu kompilasi, di awal tes Anda atau yang lain), Anda dapat mencoba untuk bergabung dengannya.

Tulis ulang ini ...:

for(unsigned int i = 0; i < max; i++)
    r = do_stuff(i);
    // Need to do something else
    do_something_else(r);

...untuk ini:

for(unsigned int i = 0; i < max; i++)
    r = do_stuff(i);
    do_something_else(r); // Need to do something else

Jadi ketika Anda menggabungkan Modif 1 ...:

for(unsigned int i = 0; i < max; i++)
    r = do_stuff(i)/2; // we need only the half
    do_something_else(r); // Need to do something else

... dengan Modif 2 ...:

for(unsigned int i = 0; i < max; i++)
    r = do_stuff(i);
    if(r < 0) // do_stuff can return an error
        handle_error(r);
    do_something_else(r/2); // Need to do something else

..., git akan menghasilkan konflik, dan Anda akan memaksa Anda untuk melihatnya.

Aku kebanyakan menebak, tapi saya pikir itu ada hubungannya dengan baris 2 digunakan sebagai konteks untuk baris 3 perubahan.

Git tidak bisa hanya mengatakan bahwa "Baris dengan C menjadi garis dengan C1" karena mungkin ada baris lain dengan "C", jadi ia mengatakan "Baris dengan C, itu tepat setelah awal file, baris dengan A, dan garis dengan B, sekarang C1 "

Jika "baris dengan B" tidak ada lagi di sana, maka beberapa konteksnya hilang, dan git hanya dapat mengetahui secara kasar ke mana baris baru harus pergi.

Jawaban yang lain di sini adalah semua tentang hal, tetapi bagi saya ini selalu tampak seperti pembatasan yang tidak perlu.

Seperti orang lain berkata, dalam kasus ini Anda pasti akan tidak ingin Git menggabungkan garis tanpa peringatan.

Tetapi saya masih menginginkan opsi untuk melakukannya secara otomatis, setelah diperingatkan. Jadi saya menulis sopir gabungan git kustom yang bisa menggabungkan konflik pada yang berdekatan (atau individu) garis interaktif:

Ini menghemat banyak waktu, karena saya mengelola proyek di mana orang sering mengerjakan file yang sama dan refactoring banyak kode.

Skrip tersedia di GitHub di bawah lisensi GPLv3 +. Mungkin Anda akan merasakan manfaatnya:

https://github.com/paulaltin/git-subline-merge