Dans le flux GitHub, est-il OK de baser la branche d'entité sur une autre branche d'entité?

22

Nous utilisons GitHub Flow dans notre projet et la plupart du temps, nous ouvrons une nouvelle branche de fonctionnalités à partir de master , y faisons un peu de travail, ouvrons un PR, examinons le code et fusionnons à nouveau dans master .

Cependant, mon travail actuel dépend d'un autre problème en cours d'élaboration en feature-branch-A. Est-il casher de créer ma branche à partir de cette autre branche ou est-ce contraire à l'esprit de GitHub Flow?

L'alternative serait de baser ma branche sur le maître et de fusionner les changements de feature-branch-A(fréquemment).

Quelle option est préférée dans GitHub Flow?

Borek Bernard
la source

Réponses:

24

Voici le flux de travail que je suis lorsque je dérive d'une branche de fonctionnalité:

  1. Créer à feature-branch-Bpartir defeature-branch-A
  2. Travailler sur feature-branch-B
  3. Si plusieurs validations sont ajoutées feature-branch-Aaprès la ramification, rebasez feature-branch-Bsurfeature-branch-A
  4. Terminez le travail feature-branch-Bet attendez jusqu'à ce qu'il feature-branch-Asoit fusionné master.
  5. Après avoir feature-branch-Aété fusionné dans master, rebaser feature-branch-Bsurmaster
  6. Fusionner feature-branch-Bdansmaster

En suivant le flux de travail ci-dessus, il apparaît que vous avez créé une branche masteraprès la feature-branch-Afusion. Vous n'avez pas besoin d'attendre la feature-branch-Afusion pour commencer à travailler feature-branch-B. Pourtant, vous obtiendrez une histoire propre sans arbres compliqués.

geoji
la source
C'était exactement la réponse que je cherchais! Vous m'avez évité le mal de tête de régler ça, merci!
Vance Palacio
Ne pas rebaser les commits déjà publiés ... daolf.com/posts/git-series-part-2
Sebi2020
8

Je pense que cela est tout à fait correct si vous créez la fonctionnalité dans une autre fonctionnalité.

Mais ne le faites pas assez souvent. Je vois un développeur qui a fait cela et une semaine ou deux, il a jeté 10 RP pour les fusionner. C'était complètement épuisant pour les autres membres à examiner et difficile à fusionner aussi. Essayez de ne pas faire d'arbres dans git. Cela aide à bissecter pour trouver des erreurs.

Ladislav Prskavec
la source
7

Un élément clé que git-flow était censé aborder était la capacité de raisonner sur le rôle d'une branche donnée, et ce à quoi elle dérivait et fusionnait.

Idéalement, toutes les branches fusionnent avec la ligne de code à partir de laquelle elles ont été fusionnées. Il s'agit généralement d'une fusion à partir de la ligne principale (dans git-flow, c'est dev). Fonctionnalité: branchez et fusionnez les branches depuis dev, libérez les branches et fusionnez depuis dev (avec une fusion supplémentaire vers master). Branche de correctifs et fusion depuis master (avec cette fusion supplémentaire vers dev).

Chaque ligne de code se ramifie et fusionne avec son parent. Une ligne de code peut extraire du code à partir d'autres lignes de code à tout moment si cela est nécessaire.

Si la branche d'une branche de fonctionnalité est un "Je veux explorer cette façon de résoudre un problème dans cette branche de fonctionnalité" - c'est parfait. Il dérive de la branche de fonctionnalité, valide du code et fusionne dans la branche de fonctionnalité (ou est supprimé).

  1. branche à partir de la fonction
  2. explorer l'idée
  3. fusionner pour présenter

Ce que vous voulez éviter cependant, c'est quelque chose qui ressemble à:

  1. branche à partir de la fonction requise
  2. travailler sur le code
  3. fusionner à partir du développeur une fois la fonctionnalité requise terminée
  4. vérifier la fonctionnalité (et les validations supplémentaires) dans la branche de fonctionnalité
  5. fusionner avec dev

La raison en est que le début et la fin ne correspondent pas - cela rend un peu plus difficile de comprendre ce que c'est et ce que c'était. Pas impossible, mais cela prend juste un peu plus de temps pour que quelqu'un comprenne son rôle.

Cependant, s'il s'agit d'une nouvelle fonctionnalité qui dépend du code qui n'est pas encore trouvé dans dev, le flux doit être:

  1. branche de dev
  2. fusion de la fonction requise
  3. travailler sur le code
  4. fusionner à partir du développeur une fois la fonctionnalité requise terminée
  5. vérifier la fonctionnalité (et les validations supplémentaires) dans la branche de fonctionnalité
  6. fusionner avec dev

Notez que cela commence par une branche de dev et se termine par une fusion vers dev.

Cela dit, la meilleure chose à faire est probablement d'éviter de faire une fusion d'une fonctionnalité à une autre. Branchez la fonctionnalité, effectuez les préliminaires nécessaires ... et attendez.

  1. branche de dev
  2. travailler sur le code
  3. fusionner à partir du développeur une fois la fonctionnalité requise terminée
  4. vérifier la fonctionnalité (et les validations supplémentaires) dans la branche de fonctionnalité
  5. fusionner avec dev

Cela fournit l'ensemble de branches et de code le plus stable.

Quelque chose à considérer pour les travaux futurs serait d'avoir une fonctionnalité pour publier les interfaces nécessaires pour l'interopérabilité avec d'autres fonctionnalités - même si le code d'implémentation n'est pas complet. Cela serait fusionné avec dev, puis la fonctionnalité requise pourrait fonctionner à partir de ces interfaces, tout comme la fonctionnalité future. Cela permettrait probablement à la fonctionnalité future de progresser davantage (codage par rapport aux interfaces, test par rapport aux stubbs qui implémentent les interfaces) que si elle devait attendre que la fonctionnalité requise fusionne pour se développer.


la source
Dans votre troisième série d'étapes, l'inconvénient est que l'étape 1 doit contenir un "commit factice". Dans ma situation, je n'ai rien d'utile à engager jusqu'à ce qu'il required-featuresoit fusionné.
Borek Bernard
Je le signale toujours comme l'un de mes articles préférés sur la ramification: les stratégies de branchement SCM avancées . Bien qu'il se concentre sur un système de contrôle de version centralisé, les idées des rôles qu'il présente correspondent exactement à git-flow.
Et en ce qui concerne la validation factice, c'est pourquoi ce dernier paragraphe est là. Ce qui aurait été utile, c'est une fonctionnalité qui s'est exécutée et complétée comme "fournir des interfaces pour faire des choses". Ensuite, les fonctionnalités requises et les fonctionnalités futures pourraient fonctionner hors de ces interfaces. Alors que la fonctionnalité requise travaillait sur la mise en œuvre des interfaces, la fonctionnalité future pourrait les bloquer et effectuer des tests par rapport à eux - en attendant que la fonctionnalité requise soit fusionnée avec dev.
Vous vous demandez à quel point votre deuxième série d'étapes est mauvaise. Est-ce un problème dans la pratique qu'une branche n'ait pas un "même" début et une fin? Je ne pense pas que cela me dérangerait trop, mais c'est peut-être un facteur de désordre majeur?
Borek Bernard
Il s'agit de décrire clairement à travers la branche, de valider et de fusionner l'historique de la branche qui est la branche parente. Dans git-flow, vous devez suivre le système décrit dans les branches des fonctionnalités de git flow . La branche caractéristique dérive de la branche develop et fusionne pour se développer. Lorsque vous commencez à créer des branches à partir d'autres branches de fonction, il devient moins clair quel est le rôle de cette branche. Je vous encourage à attendre que la fonctionnalité requise soit terminée si vous ne pouvez pas progresser sur le code sans lui maintenant.
1

Une branche de fonctionnalité est normalement considérée comme moins stable que le tronc (develop / master), vous pouvez donc vous soumettre à plus de changements sous-jacents que la normale si vous basez votre travail sur un seul.

De plus, bien que normalement désapprouvée si la branche a été poussée, il n'est pas rare de rebaser des branches de fonctionnalité sur leur branche parente, pour obtenir un historique plus agréable, mais ce serait très compliqué s'il y avait des branches supplémentaires suspendues, donc vous crée essentiellement une nouvelle restriction pour le propriétaire de la branche parent, ainsi que des maux de tête potentiels pour vous-même.

Cela dit, il n'y a pas de règle stricte contre cela. Ce ne sont que des modèles et des meilleures pratiques après tout.

Edit: partie manquante de votre question. La fusion de la branche de fonctionnalité dans la vôtre, qui est basée sur le maître, n'évite vraiment aucun des problèmes mentionnés ci-dessus, et pourrait en fait créer un historique encore plus compliqué.

Donc, si j'étais à votre place et que je pouvais différer le travail jusqu'à ce que la fonction a soit terminée, ou faire autre chose d'abord, je le ferais.

axl
la source