Dois-je garder mes fichiers de projet sous contrôle de version?
Dois-je conserver des fichiers de projet comme Eclipse .project, .classpath, .settings, sous contrôle de version (par exemple Subversion, GitHub, CVS, Mercurial, etc.)?
Vous voulez garder le contrôle de version tous les fichiers de paramètres portables,
sens:
Tout fichier sans chemin absolu.
Qui comprend:
- .projet,
- .classpath ( si aucun chemin absolu n'est utilisé , ce qui est possible avec l'utilisation des variables IDE ou des variables d'environnement utilisateur) )
- paramètres IDE (c'est là que je suis fortement en désaccord avec la réponse "acceptée"). Ces paramètres incluent souvent règles d'analyse de code statique qui sont d'une importance vitale à appliquer de manière cohérente pour tout utilisateur chargeant ce projet dans son espace de travail.
- Les recommandations de paramètres spécifiques à l'EDI doivent être écrites dans un gros fichier README (et également versionné bien sûr).
Règle générale pour moi:
Vous devez pouvoir charger un projet dans un espace de travail et y avoir tout ce dont vous avez besoin pour le configurer correctement dans votre IDE et démarrer en quelques minutes.
Pas de documentation supplémentaire, pages wiki à lire ou pas.
Chargez-le, configurez-le, allez-y.
Fichiers .project et .classpath oui. Cependant, nous ne conservons pas nos paramètres IDE dans le contrôle de version. Il existe certains plugins qui ne font pas un bon travail de persistance des paramètres et nous avons constaté que certains paramètres n'étaient pas très portables d'une machine de développement à Nous avons donc à la place une page Wiki qui met en évidence les étapes nécessaires pour qu'un développeur configure son IDE.
Ce sont ce que je considère comme des fichiers générés, et en tant que tels, je ne les place jamais sous contrôle de version. Ils peuvent être différents d'une machine à l'autre et d'un développeur à l'autre, par exemple lorsque des plugins Eclipse différents sont installés.
À la place, j'utilise un outil de construction (Maven) qui peut générer des versions initiales de ces fichiers lorsque vous effectuez une nouvelle extraction.
Je suis partagé entre deux options ici.
D'une part, je pense que tout le monde devrait être libre d'utiliser l'ensemble d'outils de développement avec lequel ils sont les plus productifs, tant que tous les artefacts source sont stockés dans le contrôle de version et que le script de construction (par exemple ANT ou Maven) garantit la conformité aux normes en en spécifiant exactement le JDK à utiliser, les versions dont les bibliothèques tierces dépendent, l'exécution des vérifications de style (par exemple checkstyle) et l'exécution des tests unitaires, etc.
D'un autre côté, je pense que beaucoup de gens utilisent les mêmes outils (par exemple Eclipse) et souvent il est beaucoup mieux d'avoir des choses standardisées au moment de la conception au lieu de la construction - par exemple, Checkstyle est beaucoup plus utile en tant que plugin Eclipse qu'en tant que plugin une tâche ANT ou Maven - qu'il vaut mieux standardiser sur l'ensemble des outils de développement et un ensemble commun de plugins.
J'ai travaillé sur un projet où tout le monde utilisait exactement le même JDK, la même version de Maven, la même version d'Eclipse, le même ensemble de plugins Eclipse et les mêmes fichiers de configuration (par exemple profils Checkstyle, règles de formatage de code, etc.). Tous ces éléments ont été conservés dans le contrôle de code source - .project, .classpath et tout dans le dossier .settings. Cela a rendu la vie vraiment facile pendant les phases initiales du projet lorsque les gens ajustaient continuellement les dépendances ou le processus de construction. Cela a également énormément aidé lors de l'ajout de nouveaux démarreurs au projet.
Dans l'ensemble, je pense que s'il n'y a pas trop de chances d'une guerre religieuse, vous devez normaliser l'ensemble de base d'outils de développement et de plugins et garantir la conformité des versions dans vos scripts de construction (par exemple en spécifiant explicitement le Java version). Je ne pense pas qu'il y ait beaucoup d'avantages à stocker le JDK et l'installation Eclipse dans le contrôle de source. Tout le reste qui n'est pas un artefact dérivé - y compris vos fichiers de projet, la configuration et les préférences de plugin (en particulier formateur de code et règles de style) - devraient aller dans le contrôle de code source.
P.S. Si vous utilisez Maven, il y a un argument pour dire que les fichiers .project et .classpath sont des artefacts dérivés. Cela n'est vrai que si vous les générez chaque fois que vous effectuez une construction, et si vous n'avez jamais eu à les modifier à la main (ou les avoir modifiés par inadvertance en modifiant certaines préférences) après les avoir générés à partir du POM
Non, car je n'ai que les fichiers de contrôle de version nécessaires à la construction du logiciel. En outre, les développeurs individuels peuvent avoir leurs propres paramètres spécifiques au projet.
Non, je suis un gros Maven utilisateur et j'utilise le plugin Q pour Eclipse qui crée et maintient .project et .classpath mis à jour. Pour d'autres choses telles que les paramètres des plugins, je maintiens généralement un README ou une page Wiki à ce sujet.
De plus, ceux avec qui j'ai travaillé préfèrent d'autres IDE utilisent simplement les plugins Maven pour générer les fichiers nécessaires pour garder leur IDE (et eux-mêmes) heureux.
Tout cela n'est qu'une opinion, je suppose - mais les meilleures pratiques au fil des ans indiquent que les fichiers spécifiques à un IDE ne doivent pas être stockés dans le contrôle de code source, à moins que toute votre organisation ne soit normalisée sur un IDE et vous n'avez jamais l'intention de changer.
Quoi qu'il en soit, vous ne voulez certainement pas que les paramètres utilisateur soient stockés - et .project peut contenir des paramètres qui sont vraiment spécifiques au développeur.
Je recommande d'utiliser quelque chose comme Maven ou Ant comme système de construction standardisé. Tout développeur peut obtenir un chemin de classe configuré dans leur IDE en quelques secondes.
Oui, à l'exception du dossier .settings. La validation des autres fichiers fonctionne bien pour nous. Il y a une question similaire ici .
Bien que je sois généralement d'accord sur l'approche "ne pas générer de fichiers générés", nous avons des problèmes avec cela et devons revenir en arrière.
Remarque: je suis également intéressé par réponse de VonC , en particulier sur le point "obtenir Eclipse en quelques minutes". Mais ce n'est pas décisif pour nous.
Notre contexte est Eclipse + Maven, utilisant le plug-in m2Eclipse. Nous avons un environnement de développement commun, avec des répertoires communs autant que possible. Mais il arrive parfois que quelqu'un essaie un plug-in, ou change de petites choses dans la configuration, ou importe un deuxième espace de travail pour une branche différente ...
Notre problème est que la génération de .project se fait lors de l'importation d'un projet dans Eclipse, mais n'est pas mise à jour dans tous les cas ultérieurement . C'est triste et probablement pas permanent car le plug-in m2Eclipse va s'améliorer, mais c'est vrai en ce moment. Nous finissons donc par avoir différentes configurations. Ce que nous avions aujourd'hui était que: plusieurs natures ont été ajoutées à de nombreux projets sur une machine, qui se sont ensuite comportées de manière très différente :
La seule solution que nous voyons est de versionner le fichier .project (pour éviter les risques, nous ferons de même pour .classpath et .settings). De cette façon, lorsqu'un développeur modifie son pom, les fichiers locaux sont mis à jour à l'aide de m2Eclipse, tous sont validés ensemble et les autres développeurs verront toutes les modifications.
Remarque: dans notre cas, nous utilisons des noms de fichiers relatifs, nous n'avons donc aucun problème à partager ces fichiers.
Donc, pour répondre à votre question, je dis oui, validez ces fichiers.
J'ai aimé aussi:
- Vendeur riche --- (réponse
Oui. Tout sauf construire la sortie.
Il semble que ces fichiers de projet peuvent changer au fil du temps lorsque vous travaillez sur un projet, alors oui, je les place sous contrôle de version.
Nous utilisons IntelliJ IDEA et gardons les versions '.sample' des fichiers de projet (.ipr) et de module (.iml) sous contrôle de version.
La chose un peu plus importante ici est le partage et la réutilisation que le versioning, à mon humble avis. Mais si vous allez partager ces configurations, quel meilleur endroit pour les mettre que le référentiel, juste à côté de tout le reste.
Quelques avantages des fichiers de projet partagés et versionnés:
- Vous pouvez vérifier n'importe quelle balise/branche et commencer à y travailler rapidement
- Permet à un nouveau développeur de configurer plus facilement l'environnement de développement et de se mettre à jour
- Cela adhère mieux à SEC, ce qui est toujours profondément satisfaisant. Avant cela, tous les développeurs devaient configurer ces choses de temps en temps, effectuant essentiellement des travaux répétés. Bien sûr, tout le monde avait ses propres moyens d'éviter de se répéter, mais en regardant l'équipe dans son ensemble, il y avait beaucoup d'efforts en double.
Notez que dans IDEA ces fichiers contiennent des configurations telles que: quels sont les répertoires "source" et "test source"; tout sur les dépendances externes (où sont situés les pots de bibliothèque, ainsi que les sources associées ou javadocs); options de construction, etc. Il s'agit de choses qui ne varient pas d'un développeur à l'autre (je suis en désaccord avec ceci tout à fait fortement). IDEA stocke des paramètres plus personnels IDE ailleurs, ainsi que toutes les configurations de plug-in. (Je ne connais pas bien Eclipse; cela peut ou peut pas tout à fait différent.)
Je suis d'accord avec cette réponse qui dit:
Vous devez pouvoir charger un projet dans un espace de travail et y avoir tout ce dont vous avez besoin pour le configurer correctement dans votre IDE et démarrer en quelques minutes. [...] Chargez-le, installez-le, allez.
Et nous l'avons comme ça, grâce aux fichiers de projet versionnés.