Gestión de dependencies en SCM

En aras de la argumentación, digamos que estoy trabajando en un proyecto, X, que tiene una dependencia, Y. Ahora Y es un proyecto independiente de código abierto mantenido y actualizado regularmente por terceros. Reviso la última revisión de Y, la envío al repository que aloja a X, y con el paso del time puedo realizar cambios en Y en mi repository local. Dos meses después, decido que quiero fusionar los últimos cambios del repository de código abierto con los míos para get las últimas correcciones de errores, funciones, etc. Si estas dos twigs fueran parte del mismo repository, esto habría sido una obviedad. . ¿Cómo puedo [relativamente] sin dolor hacer esta fusión cruzada en Git, Mercurial y Subversion?

Gracias.

¿Estás diciendo que pondrías una copy de Y en tu repository para X? Si es así, esa no es la forma correcta de hacerlo por ninguno de los VCS que mencionaste. Desea "bifurcar" el repository de Y en Y-mine, en el que compromete sus cambios. Luego tiene el file de configuration de su sistema de compilation en el proyecto X que contiene como dependencia un puntero a una revisión específica en el repository Y-mine, cualquier sistema de compilation moderno hace esto.

Eso te brinda lo mejor de ambos mundos: puedes unirte a Y-mine desde Y siempre que lo desees, y tienes la versión exacta de Y-mine almacenada en X para comstackciones 100% reproducibles.

Git y Mercurial tienen sistemas subrepo que le permiten decir "Y-mine en la versión Z es parte de repo X", pero son más klunkier que dejar pip o maven o sbt o gem o visual studio o ivy2 o lo que sea … manejar la gestión de la dependencia.

Mi opinión es que podrías ver lo que hace Debian con su flujo de trabajo de empaquetado de Git utilizando la herramienta git-buildpackage .

El flujo de trabajo provisto por esta herramienta es independiente del VCS utilizado por el proveedor ascendente, y está organizado (más o less) así:

  • Tienes (al less) dos twigs: upstream y master .
  • upstream contiene instantáneas de fonts ascendentes (no modificadas) usualmente tomadas de files de lanzamiento proporcionados por el proveedor ascendente. Es decir, cada compromiso en esta twig resulta de estos pasos:

    1. La twig upstream está desprotegida.
    2. Se eliminan todos los files existentes ( git rm -rf . ).
    3. La nueva versión de las fonts ascendentes se desenvuelve y se copy en el tree de trabajo, y luego se agrega ( git add . ).
    4. Luego se registra una nueva confirmación (y se crea una label en upstream/vX.YZ apuntando a esta confirmación).
  • master contiene lo que está en process de upstream más un set de files que proporciona la infraestructura para build el package de Debian (en realidad, este es solo un directory único llamado "debian").

    Cada vez que se importa una nueva versión de las fonts ascendentes a la sucursal upstream , esa sucursal se fusiona con la master , y el mantenedor del package luego trabaja en la personalización de su "debianización" para que coincida con los cambios introducidos por la stream ascendente.

Creo que este enfoque podría ser usado en tu caso usando Git simple:

  • Mantenga una twig "ascendente" (puede llamarla "proveedor" o "ese marco", etc.). Solo debe recibir nuevas versiones de las fonts de origen (y también puede ser parches de aguas arriba ocasionales, etc.).
  • Después de importar las nuevas versiones de las fonts ascendentes a esa twig, combínelas con su master (o cualquier twig que se adapte mejor a su flujo de trabajo).

Trabajar con Mercurial y Subversion también podría hacerse usando sus respectivas calzas Git, pero sospecho (aunque no estoy del todo seguro) que esto complicaría las cosas, no simplificará.