web-dev-qa-db-fra.com

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

Nous utilisons GitHub Flow dans notre projet et la plupart du temps, nous ouvrons une nouvelle branche de fonctionnalité de master , faisons un peu de travail là, ouvrez un PR, révisez le code et fusionnez dans master .

Cependant, mon travail actuel dépend d'un autre problème en cours de traitement dans 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 master et de fusionner les changements de feature-branch-A (fréquemment).

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

gitgithubgitflow
23
Borek Bernard

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

  1. Créer feature-branch-B de feature-branch-A
  2. Travailler sur feature-branch-B
  3. Si d'autres validations sont ajoutées à feature-branch-A après branchement, rebaser feature-branch-B sur feature-branch-A
  4. Terminer le travail sur feature-branch-B et attendez que feature-branch-A est fusionné dans master.
  5. Après feature-branch-A est fusionné dans master, rebase feature-branch-B sur master
  6. Fusionner feature-branch-B en master

En suivant le workflow ci-dessus, il apparaîtra que vous avez créé une branche à partir de master après feature-branch-A a été fusionné. Vous n'êtes pas obligé d'attendre que feature-branch-A est fusionné pour commencer à travailler sur feature-branch-B. Pourtant, vous obtiendrez une histoire propre sans arbres compliqués.

29
geoji

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 relations publiques 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 à diviser pour trouver des erreurs.

8
Ladislav Prskavec

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 sur 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 de la ligne principale (dans git-flow, c'est dev). Fonctionnalité branche et fusionne les branches depuis dev, libère la branche branches et fusionne 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 codeline peut extraire du code à partir d'autres codelines à 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 d'un 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 fonction, faites 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.

7
user40980

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 reporter le travail jusqu'à ce que la fonction a soit terminée, ou faire autre chose en premier, je le ferais.

1
axl