Mercurial merge suggestione - che cosa mi manca?

Question

Sto usando Mercurial per un po ', e non c'è un "fatto" che viene dato molte volte.

In realtà, lo ha colpito mentre si guarda un video realizzato da Fogcreek ieri, questo video: Fog Creek forno:. Sblocca il potere di DVCS per la vostra azienda che sembra che ci sia qualcosa che non funziona per me qui

Verso le 01:39 in quel video e poi fa un punto di dire che mentre gli altri sistemi di controllo versione tracce revisioni (es. Istantanee), DVCS' come Mercurial traccia di modifiche (ad es. Cosa è successo tra le istantanee.)

Questo dà loro un vantaggio in scenari fusione, e poi mostra un esempio. Se si sposta una funzione in un ramo, e si modifica la stessa funzione in un altro ramo, Mercurial è in grado di unire questo.

E ho visto questo menzionato altrove, anche se non riesco a trovare nessuna collegamenti diretti ora.

Questo non sembra funzionare per me.

---

Modifica: Questo è un problema con il default "beyondcompare3" Configurazione strumento di unione per TortoiseHg. Ho aggiunto la configurazione di seguito per il mio file Mercurial.ini, e ora funziona come previsto. Certo, sarà Punt allo strumento GUI se non può automerge, ma ora l'unione descritta in questa domanda qui viene eseguito senza alcuna richiesta e appena fa la cosa giusta, fuori dalla scatola

[ui]
merge = bc3

[merge-tools]
bc3.executable = C:\Program Files (x86)\Beyond Compare 3\bcomp.exe
bc3.args = $local $other $base $output /automerge /reviewconflicts /closescript
bc3.priority = 1
bc3.premerge = True
bc3.gui = True

---

Per verificare ciò, ho commesso questo file in un repository:

void Main()
{
    Function1();
    Function2();
}

public void Function1()
{
    Debug.WriteLine("Function 1");
    for (int index = 0; index < 10; index++)
        Debug.WriteLine("f1: " + index);
}

public void Function2()
{
    Debug.WriteLine("Function 1");
}

Poi in due diversi gruppi di modifiche parallele diramano da questo, ho fatto le seguenti due modifiche:

1. I spostato la funzione Function1 alla fine del file
2. ho cambiato il messaggio all'interno Funzione1

Ho poi cercato di fusione, e Mercurial mi dà una finestra di merge dei conflitti, cercando di capire quello che ho fatto.

In sostanza, si cerca di modificare il testo in Function2, che ora è nella posizione che Funzione1 era prima che fosse spostata.

Ciò è stato non doveva succedere!

---

Ecco i file di origine per la riproduzione il mio esempio:

file batch per la produzione di repository:

@echo off

setlocal

if exist repo rd /s /q repo
hg init repo
cd repo

copy ..\example1.linq example.linq
hg commit -m "initial commit" --addremove --user "Bob" --date "2010-01-01 18:00:00"

copy ..\example2.linq example.linq
hg commit -m "moved function" --user "Bob" --date "2010-01-01 19:00:00"

hg update 0
copy ..\example3.linq example.linq
hg commit -m "moved function" --user "Alice" --date "2010-01-01 20:00:00"

Le 3 versioni del file, example1.linq, example2.linq e example3.linq:

Example1.linq:

<Query Kind="Program" />

void Main()
{
    Function1();
    Function2();
}

public void Function1()
{
    Debug.WriteLine("Function 1");
    for (int index = 0; index < 10; index++)
        Debug.WriteLine("f1: " + index);
}

public void Function2()
{
    Debug.WriteLine("Function 1");
}

Example2.linq:

<Query Kind="Program" />

void Main()
{
    Function1();
    Function2();
}

public void Function2()
{
    Debug.WriteLine("Function 1");
}

public void Function1()
{
    Debug.WriteLine("Function 1");
    for (int index = 0; index < 10; index++)
        Debug.WriteLine("f1: " + index);
}

Example3.linq:

<Query Kind="Program" />

void Main()
{
    Function1();
    Function2();
}

public void Function1()
{
    Debug.WriteLine("Function 1b");
    for (int index = 0; index < 10; index++)
        Debug.WriteLine("f1: " + index);
}

public void Function2()
{
    Debug.WriteLine("Function 1");
}

Answer 1

Bene, si sta attualmente colpendo uno della limitazione della, in fondo, QUALSIASI VCS corrente (DVCS o no, non importa).

Il fatto è che VCS sono attualmente lingua agnostico, la base del loro algoritmo merge è un diff testuale. Ciò significa che sono alla ricerca di ciò che il cambiamento e ciò che è il relativo contesto .
La parte importante qui è il contesto. Non è niente di più che alcune linee prima e dopo le modifiche apportate.

Ciò significa che essi sono davvero male a trattare con il codice di riorganizzazione all'interno di un stesso file, perché si sta avvitando in fondo tutto il contesto su cui possono contare.
In genere, nel tuo esempio, passando le due funzioni, non solo, completamente capovolto contesto tra i due gruppi di modifiche, ma peggio, avendo senza linee in più dopo l'ultima funzione, è ridotto in modo implicito nel contesto della più recente cambiamento, diminuendo le probabilità che un algoritmo di fusione ottenuto in grado di capire che cosa si ha realmente fatto.

Attualmente conosco solo uno strumento diff, da MSFT, per XML, che sta cercando di trattare con il semantica del cambiamento e non solo la sua rappresentazione testuale.
So anche che i ragazzi di PlasticSCM stanno cercando di implementare tale funzione per alcune lingue tradizionali, ma è davvero un posto dove non c'è spazio per il miglioramento.