Existe-t-il une différence entre les fusions dans svn et git ou mercurial?

D'après ma compréhension, SVN est «facile à créer. Difficile de fusionner ». Pourquoi donc? Y a-t-il une différence dans leur fusion?

Veuillez consulter ma réponse Stack Overflow pour une situation très concrète où Mercurial (et Git) fusionne sans problème et où Subversion vous présente un faux conflit. La situation est un simple refactoring effectué sur une branche où vous renommez certains fichiers.

En ce qui concerne la réponse des tdammers, il y a alors un certain nombre de malentendus:

• Subversion, Mercurial et Git tous les instantanés du projet à l'échelle du référentiel. Les appeler versions , révisions ou ensembles de modifications ne fait aucune différence. Ce sont tous des instantanés logiquement atomiques d'un ensemble de fichiers.

• La taille de vos validations ne fait aucune différence en matière de fusion. Les trois systèmes fusionnent avec l'algorithme de fusion à trois voies standard et les entrées de cet algorithme sont

  • la plus grande version d'ancêtre commun
  • version sur une branche
  • version sur une autre branche

  Il n'a pas d' importance comment les deux versions de la branche ont été créées. Vous pouvez avoir utilisé 1000 petites validations depuis la version ancêtre, ou vous pouvez avoir utilisé 1 validation. Tout ce qui compte, c'est la version finale des fichiers. (Oui, c'est surprenant! Oui, beaucoup de guides DVCS se trompent horriblement.)

Il soulève également quelques bons points sur les différences:

• Subversion a une certaine « voodoo » où vous pouvez fusionner à partir /trunken, disons, /branches/foo. Mercurial et Git n'utilisent pas ce modèle - les branches sont plutôt modélisées directement dans l'historique. L'histoire devient donc un graphe acyclique dirigé au lieu d'être linéaire. C'est un modèle beaucoup plus simple que celui utilisé par Subversion et cela supprime un certain nombre de cas d'angle.

• Vous pouvez facilement retarder une fusion ou même laisser quelqu'un d'autre s'en occuper. Si cela hg mergevous donne une tonne de conflits, vous pouvez demander à votre collègue hg pullde vous et ensuite il a exactement le même état. Il peut donc hg mergeet peut -être qu'il est mieux à même de résoudre les conflits que vous.

  C'est très difficile avec Subversion où vous devez mettre à jour avant de pouvoir valider. Vous ne pouvez pas simplement ignorer les modifications sur le serveur et continuer à vous engager sur votre propre branche anonyme. En général, Subversion vous oblige à jouer avec une copie de travail sale lorsque vous svn update. C'est un peu risqué car vous n'avez pas stocké vos modifications dans un endroit sûr. Git et Mercurial vous permettent de valider d'abord, puis de mettre à jour et de fusionner si nécessaire.

La vraie raison pour laquelle Git et Mercurial fusionnent mieux que Subversion est une question d'implémentation. Il existe des conflits de changement de nom que Subversion ne peut tout simplement pas gérer même si la réponse correcte est claire. Mercurial et Git les manipulent facilement. Mais il n'y a aucune raison pour que Subversion ne puisse pas gérer cela aussi - la centralisation n'est certainement pas la raison.

Le problème principal réside dans la façon dont ces systèmes représentent une structure de répertoires versionnée.

Le concept de base de Subversion autour duquel tourne tout le système est celui d'une version (ou, dans le jargon svn, "révision"): un instantané d'un fichier à un certain point. Tant que l'historique est parfaitement linéaire, tout va bien, mais si vous devez fusionner les modifications de deux lignes de développement indépendantes, svn doit comparer les versions actuelles des deux, puis faire une comparaison à trois entre la dernière version partagée et les deux versions de tête. Les lignes qui semblent modifiées dans l'une des têtes, mais pas dans l'autre, peuvent facilement être résolues; les lignes qui s'écartent exactement de la même manière dans les deux têtes sont plus dures, mais généralement réalisables; les lignes qui s'écartent de différentes manières sont ce qui fait dire à svn "Je ne peux pas comprendre ça, humain, s'il te plait résous ça pour moi."

En revanche, git et mercurial track changesets plutôt que des versions. Le référentiel entier est un arbre de changesets, chacun dépendant d'un parent, où un changeset parent peut avoir n'importe quel nombre d'enfants, et la racine de l'arbre représente un répertoire vide. En d'autres termes, git / hg dit "d'abord je n'avais rien, puis ce patch a été appliqué, puis ce patch, etc.". Lorsque vous devez fusionner deux lignes de développement, git / hg sait non seulement à quoi ressemble chaque tête actuellement, et à quoi ressemblait la dernière version commune, mais il sait également comment la transition s'est produite, permettant une fusion beaucoup plus intelligente.

Une autre chose qui facilite la fusion dans un DVCS est une conséquence indirecte de la séparation des concepts de commit et de push, et d'autoriser à tout moment toutes sortes de fusions croisées entre deux clones du même référentiel. Avec svn, les utilisateurs ont tendance à valider des ensembles de modifications volumineux avec des modifications souvent indépendantes, car une validation est également une mise à jour du référentiel central qui affecte tous les autres membres de l'équipe; si vous commettez une version cassée, tout le monde sera en colère contre vous. Étant donné que la plupart des configurations impliquent un serveur svn en réseau, la validation implique également le pompage de données sur le réseau, ce qui signifie que la validation introduit un retard considérable dans le flux de travail (en particulier lorsque votre copie de travail est obsolète et que vous devez d'abord tirer). Avec git et mercurial, la validation se produit localement, et parce que les deux sont très efficaces pour gérer les systèmes de fichiers locaux, elle se termine généralement instantanément. En conséquence, les gens (une fois qu'ils s'y sont habitués) commettent de petits changements incrémentiels, puis quand cela fonctionne, pousser une douzaine de commits en une seule fois. Ensuite, lorsque le temps de fusion arrive, le SCM dispose d'informations beaucoup plus détaillées et peut mieux résoudre les conflits en toute sécurité et automatiquement.

Et puis il y a les jolis détails qui rendent les choses encore plus faciles:

• Vous pouvez avoir plusieurs têtes et toujours vous engager sur l'une ou l'autre; contrairement à la subversion, vous n'avez pas besoin de combiner l'extraction, la mise à jour et la fusion avant de recommencer - les têtes multiples restent telles quelles jusqu'à ce que vous choisissiez de fusionner
• Les répertoires ne sont pas traités spécialement; au lieu de cela, le chemin n'est considéré que comme un grand nom de fichier et tous vos répertoires doivent être à la même révision à tout moment. Cela signifie que vous ne pouvez pas faire le vaudou de subversion où les sous-dossiers d'un projet sont à différentes révisions, mais cela signifie également que la copie de travail est moins susceptible de devenir un énorme gâchis cassé ingérable, et plus intéressant encore, un mouvement n'est pas représenté comme une suppression -et-ajouter (qui se briserait entièrement dans svn s'il n'y avait pas les métadonnées de modification), mais simplement comme un renommage; si vous déplacez un fichier, tout son historique est conservé; la fusion peut même appliquer des modifications au fichier déplacé qui ont été apportées à une version non déplacée du même fichier après le déplacement, dans une autre branche
• La plupart du temps, vous n'avez même pas besoin de créer de branche: à la place, vous clonez simplement le référentiel entier. Le clonage est bon marché, surtout s'il est fait sur le même système de fichiers, et si vous décidez de vous débarrasser du clone, vous supprimez simplement le répertoire dans lequel il vit et c'est tout. Vous n'avez même pas besoin d'utiliser hg ou git pour cela.
• Il y a peu (le cas échéant) de restrictions sur ce que vous pouvez fusionner. Vous pouvez avoir six clones du même référentiel et fusionner (ou plutôt, pousser ou tirer; une fusion explicite n'est souvent pas requise) de A vers B, puis C vers B, puis B vers D, puis C vers D, B retour à A, D à E, à tout moment et aussi souvent que vous le souhaitez.
• Vous pouvez tester une fusion en clonant l'un des référentiels que vous souhaitez fusionner, puis en tirant dessus de l'autre. S'il fait ce que vous voulez, vous pouvez repousser vers la cible réelle, sinon, vous jetez le clone et recommencez.