Eu aprendi recentemente que, ao mesclar duas ramificações no git, se houver alterações em duas linhas adjacentes , o git declara isso um conflito. Por exemplo, se o arquivo test.txttiver este conteúdo:

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

e no ramo mastermudamos isso para

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

enquanto no ramo testing, mudamos isso para

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

e depois tentar fundir testingem master, git declara um conflito de mesclagem. Minha ingênua expectativa era que a fusão ocorresse sem conflito e produzisse o seguinte:

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

Estou certo de que há uma boa razão pela qual o git não se funde dessa maneira. Alguém pode explicar esse motivo?

Supondo que esse trecho de código

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

foi alterado em um ramo para este

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

e em outro ramo neste

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

então eu não gostaria que o git mesclasse isso

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

sem me alarmar.

Para evitar causar tais problemas, o git geralmente se recusa a mesclar automaticamente as alterações que tocam nas linhas próximas. Permite verificar se a lógica do programa estaria quebrada ou não.

Este exemplo é trivial, mas ao mesclar ramificações enormes, o risco de conflitos "lógicos" semelhantes é muito maior. Às vezes, eu adoraria que o contexto fosse ainda maior do que é atualmente.

Esse comportamento é apenas para git?

Depois de discutir com um colega, tentei, e o SVN lida com isso sem problemas: você modifica as duas linhas.

Os recursos de mesclagem de vários VCS são testados aqui para bazar, darcs, git e mercurial : https://github.com/mndrix/merge-this

Parece que apenas os dardos mesclam com êxito o caso "linhas adjacentes".

A aplicação de alterações adjacentes aos arquivos não é um problema difícil. Eu realmente acho que esse comportamento foi escolhido de propósito.

Por que alguém decidiria que modificar linhas adjacentes produz um conflito?

Eu acho que isso é forçar você a olhar para ele .

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

Modif número 1, no mestre:

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

Modif número 2, mesclado de uma filial:

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

Após a mesclagem, você não deseja isso:

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

Vendo esse comportamento como um recurso

Você pode transformar o comportamento de mesclagem do git em vantagem. Quando você precisar manter duas linhas consistentes, mas não conseguir detectá-las (no momento da compilação, no início dos testes ou de outra forma), tente juntar-se a elas.

Reescreva isso ...:

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

...para isso:

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

Então, quando você mescla o 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

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

..., o git produzirá um conflito, e você forçará você a olhar para ele.

Estou adivinhando, mas acho que tem a ver com a linha 2 ser usada como contexto para a mudança da linha 3.

O Git não pode simplesmente dizer que "A linha com C se tornou uma linha com C1" porque poderia haver outra linha com "C", então diz "A linha com C, logo após o início do arquivo, a linha com A, e a linha com B, agora é C1 "

Se "a linha com B" não estiver mais lá, parte do contexto será perdida, e o git pode dizer apenas aonde a nova linha deve ir.

As outras respostas aqui são importantes, mas para mim isso sempre pareceu uma limitação desnecessária.

Como outros já disseram, nesses casos, você definitivamente não gostaria que o Git mesclasse as linhas sem aviso.

Mas eu ainda queria a opção de fazer isso automaticamente, depois de ser avisado. Então, escrevi um driver de mesclagem git personalizado que pode mesclar conflitos em linhas adjacentes (ou individuais) interativamente:

Isso economiza muito tempo, pois gerencio um projeto em que as pessoas geralmente trabalham nos mesmos arquivos e refatoram muito código.

O script está disponível no GitHub sob uma licença GPLv3 +. Talvez você ache útil:

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