Tratar con una gran solicitud de extracción

Actualmente estoy trabajando en un proyecto con un equipo que usa un flujo de trabajo git. Es bastante simple, el maestro debe estar en un estado desplegable y las ramas se utilizan para crear características y revisiones. Cada vez que tenemos una función o corrección de errores completada y probada, la trasladamos a master lo antes posible. La idea es que las ramas sean lo más pequeñas posible para que sea más fácil fusionarlas nuevamente en master. Tenemos una política de que cualquier código enviado a la rama maestra debe estar en un estado desplegable y pasar las pruebas.

Tenemos una situación en la que uno de los desarrolladores ha trabajado mucho (unos meses) en una sola rama y esta rama aún no se ha fusionado con el maestro. Ahora hay algunas características separadas y un montón de confirmaciones en esta rama, esencialmente esta rama realmente debería haberse fusionado varias veces, pero hasta ahora no lo ha sido. La mayor parte del código está en buen estado con las pruebas unitarias que podrían fusionarse nuevamente en el maestro, pero los cambios más recientes ciertamente no deberían ser ya que no se completan y no se prueban.

¿Cuál es la mejor manera de lidiar con una situación en la que una rama está muy lejos de las demás? ¿De qué maneras podemos evitar que las sucursales obtengan una gran cantidad de confirmaciones del maestro en el futuro?

Deje que el desarrollador que estuvo un par de meses sin fusionar lo arregle. Tal vez puedan obtener un gran fragmento de código para fusionar, tal vez puedan obtener un montón de pequeños fragmentos para fusionar uno a la vez. En cualquier caso, deberían estar haciendo el trabajo preliminar para solucionar el problema, ya que lo causaron.

¿Cuál es la mejor manera de lidiar con una situación en la que una rama está muy lejos de las demás?

En general, no te preocupes por eso: es el problema del otro desarrollador. Si dos ramas están realmente demasiado separadas para fusionarse, entonces ya no forman parte del mismo proyecto y tienes una bifurcación de facto. Si se trata de un proyecto de código abierto, puede que ni siquiera sea un problema.

Si este desarrollador es realmente brillante, y su código es mejor / más inteligente / más importante que el resto del equipo combinado, entonces vale la pena convertirlo en su problema en lugar del suyo. De lo contrario, no lo es.

Para responder a la pregunta literal: la mejor manera de lidiar con este tipo de situación es no entrar en ese tipo de situación.

¿De qué maneras podemos evitar que las sucursales obtengan una gran cantidad de confirmaciones del maestro en el futuro?

Asegúrese de que todos se den cuenta de que el desarrollador que pasó meses sin fusionarse tiene que solucionar el problema que causaron. Asegúrese de que todos sepan que es más fácil comprometerse a dominar con frecuencia que con poca frecuencia, ya que menos cambios significan menos oportunidades para conflictos.

Asegúrese de que las personas sepan que pueden pasar de maestro a mantenerse al día con los cambios de otras personas.

"Si te unes todos los días, de repente nunca llegas al punto en que tienes grandes conflictos que son difíciles de resolver". --Linus Torvalds

Esa cita es de una charla que dio en Google, aquí está la transcripción , y aquí está el video .

Si tiene una confirmación de que sabe esto y todas las confirmaciones anteriores están bien probadas y deben fusionarse, simplemente bifurquese de esta última buena confirmación y fusione la nueva rama con master.

Si tiene algunos commits que le gustaría fusionar, pero están intercalados con otros commits que no están listos para la producción, entonces veo 2 posibilidades:

1. Cree una nueva sucursal, y escoja buenos compromisos, fusione con el maestro.
2. Trate de rebajar los compromisos no deseados en la parte superior (tal vez en una nueva rama solo para estar seguro).

En cuanto a los métodos de prevención, intente definir algunas reglas divertidas del equipo como "Una que no se fusiona con el maestro dentro de una semana pedirá pizza por un mes".

Primero, vea si realmente hay commits separados que se puedan fusionar o seleccionar, como sugiere @Maciej Chalpuk. Si este es el caso, entonces la situación realmente no es tan mala, y no me preocuparía demasiado por eso en el futuro.

Sin embargo, si la situación real es que se han desarrollado múltiples características simultáneamente en una sola rama, dentro de las mismas confirmaciones, entonces se vuelve mucho más difícil lidiar con ellas. Afortunadamente, el método de prevención está integrado: requiere que el desarrollador separe los cambios para cada característica en ramas separadas y extraiga las solicitudes antes de fusionarlas. Ambos obtendrán sus fusiones atómicas, así como disuadir a este desarrollador de hacerlo en el futuro.

El proceso real de separar las características es completamente manual. Cree nuevas ramas fuera de master, y copie cualquier cambio de la mega rama que esté relacionado con él. Compile, pruebe la función, envíe y emita una solicitud de extracción. Cuanto menos entremezclados estén los cambios de código, más fácil será hacerlo. Si estaba pirateando un método único para todos ellos, bueno, diviértete. No lo volverá a hacer.

Aquí hay una solución simple.

Haga un seguimiento de las características que esta persona ha implementado y vaya a cada confirmación en esa rama que se actualizó por característica. Toma este compromiso y combínalo con el repositorio principal.

Permítanme analizar esto en forma de ejemplo.

Sea: Rama A sea la rama del maestro Rama A + = Rama A + nueva característica 1 Rama A ++ = Rama A + nueva característica 2 y así sucesivamente

Lo que debe hacer es volver a: Rama A +

Toma la Rama A + y combínala con el Maestro.

Ahora ve a Branch A ++ y combínalo con (Master + Branch A +).

Repita hasta que haya alcanzado la rama final A + ... + que sea estable.

Al principio, este método puede sonar contra-intuitivo, pero si combina cada característica nueva por separado con la maestra, es fácil alternar entre la rama maestra " por característica adicional ".

¿De qué maneras podemos evitar que las sucursales obtengan una gran cantidad de confirmaciones del maestro en el futuro?

Creo que mi solución anterior indica qué método futuro debería adoptar. Vaya con un método por función o por tarea para cada rama.

Sugeriría usar un enfoque de:

pre-maestro y maestro

master: Final / nivel de producción. Se modifica con poca frecuencia. Se considera siempre estable

pre-master: el área donde se agrega una nueva característica al código existente. Se prueba exhaustivamente para trabajar con la base de código existente, y es el lugar donde otras ramas pueden bifurcarse para la implementación de nuevas funciones.

También debe intentar agrupar características y apuntar a la segmentación por versión.

Orientación por versión: especifique un número arbitrario que actuará como marcador de posición para la rama maestra. "En V1.0.0, queremos lograr las características X, Y, Z. V1.0.0 también tendrá todas estas funcionalidades disponibles: ..."

Al mantener una versión contra master, también puede ser una forma de mantener "master" estable y listo para la producción en todo momento.

Solucionar el problema de la solicitud de extracción grande es una cosa, y hay algunas buenas respuestas al respecto. Pero en cuanto a tratar con sucursales que están muy desactualizadas, es posible que desee volver a visitar sus procesos para tratar con el trabajo en equipo.

Si está trabajando dentro de un marco Agile o SCRUM, el equipo realmente debería preguntarse por qué la característica no se completó y se fusionó como parte de la iteración / sprint. Si fue "demasiado grande" para caber dentro de una iteración, debería haberse dividido en fragmentos más pequeños.

También plantea una cuestión de propiedad del código: dentro de su equipo, ¿los desarrolladores individuales son dueños de su propio trabajo por separado o el equipo completo trabaja en conjunto para garantizar que se realicen los elementos?

Por supuesto, lo anterior supone que su equipo está dentro de algún tipo de estructura de la empresa. Si este es un proyecto de código abierto con colaboradores voluntarios, esa es otra historia. En general, estos proyectos tienen un control más flexible sobre los flujos de trabajo, pero la responsabilidad de generar solicitudes de extracción aceptables recae con mayor frecuencia en los contribuyentes individuales.

En muchos sentidos, esto se convierte en una cuestión de proceso. Quizás su proceso necesario incluye la verificación periódica (¿semanal? ¿Mensual?) De ramas no fusionadas de larga duración. Algunas herramientas hacen que esto sea simple de verificar visualmente; por ejemplo, en github, visite el enlace "ramas" y muestra qué tan adelante / atrás está cada rama.