Mercurial fusiona genialidad: ¿qué me estoy perdiendo?

Question

He estado usando Mercurial por un tiempo y hay un "hecho" que se da muchas veces.

De hecho, me di cuenta ayer mientras miraba un vídeo hecho por Fogcreek. este video:Horno de Fog Creek:Libere el poder de DVCS para su empresa que parece haber algo que no me funciona aquí.

Alrededor del minuto 1:39 de ese video en adelante, se insiste en decir que mientras otros sistemas de control de versiones rastrean las revisiones (es decir,instantáneas), conjuntos de cambios de pistas Mercurial similares a DVCS (es decir,qué pasó entre las instantáneas.)

Esto les da una ventaja a la hora de fusionar escenarios y luego se muestra un ejemplo.Si mueve una función en una rama y cambia la misma función en otra rama, Mercurial puede fusionarla.

Y he visto esto mencionado en otra parte, aunque ahora no puedo encontrar ningún enlace directo.

Esto no parece funcionar para mí.

---

Editar:Este es un problema con la configuración predeterminada de la herramienta de combinación "beyondcompare3" para TortoiseHg.Agregué la siguiente configuración a mi archivo Mercurial.ini y ahora funciona como se esperaba.Claro, accederá a la herramienta GUI si no puede fusionarse automáticamente, pero ahora la fusión descrita en esta pregunta aquí se ejecuta sin ningún mensaje y simplemente hace lo correcto desde el primer momento.

[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

---

Para probar esto, envié este archivo a un repositorio:

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

Luego, en dos conjuntos de cambios paralelos diferentes que se ramifican a partir de este, hice los dos cambios siguientes:

1. Moví la función Función1 al final del archivo.
2. Cambié el mensaje dentro de Función1

Luego intenté fusionarme y Mercurial me muestra una ventana de conflicto de fusión, intentando descubrir qué hice.

Básicamente, intenta cambiar el texto en la Función2, que ahora está en la posición que estaba la Función1 antes de ser movida.

¡Esto no tenía que suceder!

---

Aquí están los archivos fuente para reproducir mi ejemplo:

Archivo por lotes para producir el repositorio:

@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"

Las 3 versiones del archivo, ejemplo1.linq, ejemplo2.linq y ejemplo3.linq:

Ejemplo1.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");
}

Ejemplo2.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);
}

Ejemplo3.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

Bueno, actualmente estás alcanzando una de las limitaciones de, básicamente, CUALQUIER VCS actual (DVCS o no, no importa).

La cuestión es que actualmente los VCS son independientes del idioma, la base de su algoritmo de fusión es una diferencia textual.Significa que están buscando qué cambio y cuál es la relación. contexto.
La parte importante aquí es el contexto.No es más que unas líneas antes y después de los cambios que realizaste.

Esto significa que son realmente malos para lidiar con la reorganización del código dentro de un mismo archivo, porque básicamente estás arruinando todo el contexto en el que pueden confiar.
Normalmente, en su ejemplo, al cambiar las dos funciones, no solo invirtió completamente el contexto entre los dos conjuntos de cambios, sino que, peor aún, al no tener líneas adicionales después de la última función, redujo implícitamente el contexto del último cambio, disminuyendo las posibilidades. que un algoritmo de fusión pudo descubrir lo que realmente hiciste.

Actualmente sólo conozco una herramienta de diferenciación, de msft, para XML, que intenta solucionar el problema. semántico de su cambio y no sólo su representación textual.
También sé que los chicos de PlasticSCM están intentando implementar dicha característica para algunos lenguajes convencionales, pero en realidad es un lugar donde hay margen de mejora.