Reformatage et contrôle de version

Le formatage du code est important. Même l' indentation compte . Et la cohérence est plus importante que les améliorations mineures. Mais les projets ne disposent généralement pas d'un guide de style clair, complet, vérifiable et appliqué dès le premier jour, et des améliorations majeures peuvent arriver n'importe quel jour. Peut-être que vous trouvez ça

SELECT id, name, address
FROM persons JOIN addresses ON persons.id = addresses.person_id;

pourrait être mieux écrit comme / est mieux écrit que

SELECT persons.id,
       persons.name,
       addresses.address
  FROM persons
  JOIN addresses ON persons.id = addresses.person_id;

tout en travaillant sur l'ajout de colonnes à la requête. Il s'agit peut-être de la plus complexe des quatre requêtes de votre code, ou d'une requête triviale parmi des milliers. Peu importe la difficulté de la transition, vous décidez que cela en vaut la peine. Mais comment suivez-vous les changements de code à travers les principaux changements de formatage? Vous pouvez simplement abandonner et dire "c'est le point où nous recommençons", ou vous pouvez reformater toutes les requêtes dans tout l'historique du référentiel.

Si vous utilisez un système de contrôle de version distribué comme Git, vous pouvez revenir au tout premier commit et reformater votre chemin de là à l'état actuel. Mais c'est beaucoup de travail, et tout le monde devrait suspendre le travail (ou être prêt pour la mère de toutes les fusions) pendant qu'il se déroule. Existe-t-il une meilleure façon de changer l'historique qui donne le meilleur de tous les résultats:

• Même style dans toutes les commits
• Travail de fusion minimal

?

Pour clarifier, il ne s'agit pas des meilleures pratiques lors du démarrage du projet, mais plutôt de ce qui devrait être fait lorsqu'une grande refactorisation a été considérée comme une bonne chose ™ mais que vous voulez toujours une histoire traçable? Ne jamais réécrire l'historique est génial si c'est le seul moyen de s'assurer que vos versions fonctionnent toujours de la même manière, mais qu'en est-il des avantages pour les développeurs d'une réécriture propre? Surtout si vous avez des moyens (tests, définitions de syntaxe ou binaire identique après compilation) pour vous assurer que la version réécrite fonctionne exactement de la même manière que l'original?

Effectuez le reformatage en tant que validations distinctes. Cela n'interférera que très peu avec l'historique, et vous devriez pouvoir voir en un coup d'œil quels commits sont juste en train de reformater et qui changent réellement le code. Il pourrait être asymétrique git blameet similaire, mais s'il pointe vers un commit de reformatage uniquement, il est assez simple de rechercher le changement précédent avant cela.

Ne réécrivez pas l'historique VCS: c'est contraire aux principes VCS.

N'essayez pas d'automatiser la correction du formatage: il traite les symptômes, pas le vrai problème (= les développeurs ne suivent pas les normes de codage).

Définissez la norme de codage et les meilleures pratiques de formatage dans un document commun et obtenez l'accord de tous les développeurs.

Vous mentionnez Git, ce qui est génial, car il est distribué. Avec un DVCS, il est très facile d'appliquer les meilleures pratiques via le flux de travail du contrôleur d'accès . Les gatekeepers rejettent les propositions de fusion (= pull request dans Git) qui ne sont pas conformes aux directives communes. Et je veux dire rejeter , en caractères gras, sinon le codeur en infraction ne prendra pas la peine de suivre les règles et continuera de répéter les mêmes erreurs.

Cette technique fonctionne bien pour moi. Les codeurs veulent que leur travail soit fusionné, donc après quelques erreurs au début, ils commencent à suivre les règles.

Selon la fixation de la base de code existante ... Je recommande de le faire progressivement, peut-être module par module, ou comme cela a du sens pour votre projet. Testez soigneusement à chaque étape. Cela peut sembler stupide, mais des erreurs se produisent même avec des changements insignifiants comme le formatage, alors soyez prêt pour quelques petites bosses sur la route.

La réponse à votre question est: "Vous ne le faites pas." Je ne connais aucun outil SCM actuel qui puisse suivre les changements de logique à partir du code formaté d'une manière, par le biais d'un changement de formatage majeur et par le biais de modifications supplémentaires après que le code est formaté de la nouvelle manière. Et, vous le savez, perdre l'historique sur un morceau de code n'est pas bon.

Par conséquent, je vais contredire un peu votre première phrase. Formatage du code n'a pas d' importance que beaucoup. C'est joli, mais ce n'est pas pour ça que nous sommes ici. Je comprends aussi bien que quiconque que le dumping dans le vieux code de variante K&R étrange et infernal de quelqu'un avec les retraits à deux espaces est nul (1), mais ... le formatage n'est en fait pas un obstacle à la compréhension de ce qui se passe, sauf si c'est quelque chose d' exceptionnellement pathologique. Et dans ce cas, vous allez quand même avoir des problèmes pour changer le code et ne devriez pas le déranger.

Par conséquent, cela ne vaut pas la peine d'apporter des modifications au code établi STRICTEMENT pour le reformater. Changer les noms des variables, rompre les longues fonctions, tout ce bon truc de refactoring qui change le contenu, oui, mais pas juste un reformatage.

1) - J'ai déjà possédé la visionneuse du presse-papiers de Windows pendant un certain temps. Le tout était un, 150k, module C. J'ai trouvé un endroit où différentes personnes avaient utilisé, je pense, cinq styles d'accolades différents à moins de trente lignes les uns des autres. Mais cette partie des choses a fonctionné. J'ai transporté une impression de ce morceau de code pendant dix ans, mais je ne l'ai pas poussé parce que cette histoire importait, et que le code était dans au moins trois arbres sources (Windows 3.x, NT, future 95) qui vivaient tous dans différents bâtiments.

Mais comment suivez-vous les changements de code à travers les principaux changements de formatage?

Les modifications de formatage sont des modifications de code; traitez-les comme vous le feriez pour toute autre modification de votre code. Quiconque a travaillé sur un projet important aura probablement vu des bogues et d'autres problèmes qui ont été créés lorsque quelqu'un a décidé de "simplement" reformater du code.

Mais c'est beaucoup de travail, et tout le monde devrait suspendre le travail (ou être prêt pour la mère de toutes les fusions) pendant qu'il se déroule.

Pourquoi devez-vous tout reformater en même temps? Surtout si le reformatage ne change pas la signification du code, vous devriez pouvoir reformater les fichiers individuellement et les archiver au fur et à mesure. Mieux, faites en sorte que tout le monde dans votre équipe se mette d'accord sur un style (sinon ça ne sert à rien de reformater de toute façon) et demandez-leur de s'occuper du reformatage dans le cadre de leur autre travail. Après un certain temps, vous aurez couvert la majeure partie du code sans perturber le reste du projet.

Il y a deux approches viables que j'ai vues pour cela.

1. Reformater le code sur commit-hook

Bien qu'il soit initialement épuisant de modifier le code après l'avoir soumis, si votre procédure de reformatage (par exemple astyle ) ne blesse pas le code, c'est une opération sûre. Au fil du temps, toute l'équipe appréciera que tout le code finira par se ressembler. De toute évidence, le fait d'avoir des tests unitaires / automatisés complets garantira que rien ne s'est cassé.

2. Reformatage unique de tout le code

D'après mon expérience, cela est plus dangereux et rend le suivi des problèmes à travers le big-bang difficile, mais c'est possible. L'exécution de tous les tests par la suite est essentielle. Pour le style de codage, la majorité des différences tournent autour de l'utilisation des espaces blancs - indentation ou sauts de ligne. On devrait pouvoir dire à un outil de fusion décent d'ignorer toutes les différences d'espaces, donc cela vous aidera avec les fusions.