PyUt1.1 Python UML Tool version 1.1 Rapport de projet Cédric

PyUt1.1
Python UML Tool version 1.1
Rapport de projet
Cédric Dutoit
EI6, eivd
17 juillet 2002
PyUt 1.1
Table des matières
1 Informations générales
3
2 Rappel du cahier des charges
2.1 Etat au début du projet . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Responsabilités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3 Fonctionalités à implémenter . . . . . . . . . . . . . . . . . . . . . . . .
4
4
4
4
3 Déroulement du développement
5
4 Etat final du projet
4.1 Correction des bugs de PyUt 1.0 . . . . . . . . . . . . . . . . .
4.2 Amélioration de l’édition de classes : Ajout de commentaires .
4.3 Ajout de l’édition du diagramme des cas d’utilisation (use-case
4.4 Internationalisation . . . . . . . . . . . . . . . . . . . . . . . .
4.5 Arbre de projet . . . . . . . . . . . . . . . . . . . . . . . . . .
4.6 Reverse-engineering et génération de code . . . . . . . . . . .
4.7 Notes UML . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.8 XMI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.9 Tests automatisés . . . . . . . . . . . . . . . . . . . . . . . . .
4.10 Aide contextuelle . . . . . . . . . . . . . . . . . . . . . . . . .
4.11 Localisation des sources . . . . . . . . . . . . . . . . . . . . .
5 Tests
5.1 Tests
5.1.1
5.1.2
5.1.3
5.1.4
5.2 Tests
unitaires . . . . . . . . . . . . .
Fonctionnement . . . . . . . .
Philosophie des tests unitaires
Programmes nécessaires . . .
Ecrire de nouveaux tests . . .
utilisateurs . . . . . . . . . . .
Rapport de projet
2 / 12
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. . . .
. . . .
view)
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6
6
6
6
6
6
6
7
7
7
7
8
.
.
.
.
.
.
9
9
9
9
9
10
10
C.Dutoit, EI6
PyUt 1.1
Résumé
PyUt est un petit éditeur UML graphique qui permet la génération, l’impression et l’export de diagrammes de classes et use-cases sous différents formats. Ce document présente
le rapport final du projet PyUt 1.1 qui est la suite directe du projet PyUt 1.0.
1
Informations générales
PyUt 1.1 fait suite au projet PyUt 1.0 développé comme projet de groupe durant le
cinquième semestre de notre formation d’ingénieurs informaticien à l’école d’ingénieurs
d’Yverdon (Suisse). Le projet PyUt 1.1 est également développé à l’EIVD durant le
sixième et dernier semestre de notre formation.
Nom du projet PyUt - Python UML Tool
Site de référence http://pyut.sf.net
Sources du projet Disponible par CVS (cf 4.11 page 8)
Professeur responsable T. Gagnebin <[email protected]>
Membres du groupe
–
–
–
–
–
–
Laurent Burgbacher <[email protected]>
Nicolas Dubois <[email protected]>
Cédric Dutoit <[email protected]>
Nabil Hamadi <[email protected]>
Dève Roux <[email protected]>
Philippe Waelti <[email protected]>
Rapport de projet
3 / 12
C.Dutoit, EI6
PyUt 1.1
2
Rappel du cahier des charges
2.1
Etat au début du projet
PyUt 1.0 offre les fonctionalités suivantes :
– Edition de diagrammes de classes UML 1.3
– Enregistrement et chargement dans des formats de fichier propriétaire XML compressé et XML non compressé (*.put)
– Support de plugins pour l’enregistrement et le chargement de diagrammes de
classes
– Aide standard et tutorial (exemple)
– Documentation développeur grâce à pyDoc, outil de génération de documentation
dynamique semblable à JavaDOC.
2.2
Responsabilités
Chef de groupe, Site web Cédric Dutoit
Chef de groupe remplaçant, CVS, Configuration, Releases : Dève Roux
Documentation, Qualité : Philippe Waelti
Tests : Laurent Burgbacher
Internationalisation : Nicolas Dubois
Feedback : Nabil Hamadi
2.3
Fonctionalités à implémenter
Pour le projet PyUt 1.1, nous souhaitons réaliser les tâches suivantes :
–
–
–
–
–
–
–
–
–
–
Correction des bugs de PyUt 1.0
Amélioration de l’édition de classes : Ajout de commentaires
Ajout de l’édition du diagramme des cas d’utilisation (use-case view)
Internationalisation : possibilité de choisir la langue du logiciel parmis l’anglais et
le français, avec extension possible pour d’autres langages
Ajout de la possibilité d’ouvrir plusieurs fichiers en même temps (arbre de projet)
Ajout de Roundtrip (génération de code et reverse engineering) pour les langages
Python et Java. Ajout de la génération de code C++
Ajout des notes UML dans le diagramme de classes
Ajout de tests automatisés du logiciel
Ajout d’une aide contextuelle (infobulles)
Ajout de l’import/export XMI, qui est un format standard d’échange de données
UML, reconnu entre autre par Rational Rose
Rapport de projet
4 / 12
C.Dutoit, EI6
PyUt 1.1
3
Déroulement du développement
Dans une ambiance agréable, les développeurs ont su collaborer tout au long de ce
projet, ainsi qu’assumer leurs rôles respectifs.
Le développement de ce projet s’est déroulé dans des conditions parfaitement idylliques,
conformément aux planification temporelles prévues en début de projet. Celui-ci s’est
déroulé en plusieurs phases, soit une phase d’étude et d’analyse (très rapide, car il y
avait peu de besoin) pour l’établissement du cahier des charges. Chaque développeur
s’est alors attelé à corriger les bugs de la version précédente de PyUt. Une première
deadline a clôturé la correction des bugs et a marqué le début de la phase suivante, soit
le développement des nouvelles fonctionalités.
Durant cette phase, L.Burgbacher a continué à travailler sur les liens entre les classes,
qui ne s’affichaient pas comme attendu.
Notons encore l’utilité du système CVS (Logiciel de contrôle et suivi de versions) lorsque
N.Dubois a du s’occuper d’implémenter l’internationalisation de PyUt. En effet, il devait travailler sur la majorité des fichiers sources sur lesquels les autres développeurs
travaillaient, sans pour autant corrompre ces fichiers. Avec le système CVS, nous avons
pu déclarer que N.Dubois travaillait sur une nouvelle branche du projet et que ses modifications étaient compartimentées et mémorisées, en vue d’une fusion (merge) plus
tard avec la branche de développement principale de PyUt(devel 1 0).
Cette phase de développement s’est arrêtée début juin pour permettre une phase de
tests d’une séance de cours (2 périodes), suivie par L.Burgbacher, responsable des tests.
(Voir rapport de test, section 5)
Les trois séances suivantes ont été consacrées à la correction des bugs et au développement
de la documentation, ainsi qu’à la création de la distribution finale de PyUt.
D.Roux, responsable des releases a alors crée toutes les distributions de PyUt1.1 :
distribution .exe auto-installable pour Windows, distribution .tar.gz multi-plateforme
(sources) et distribution Linux en .RPM.
La session suivante a été consacrée à la préparation de la présentation à la classe, puis
la dernière session à la présentation proprement dite. La dernière semaine, PyUt1.1 a
également été présenté à nos successeurs, soit aux étudiants de deuxième année, section
logiciel.
Travailler à plusieurs sur un projet tel que PyUt est extrêmement gratifiant. La motivation des membres par rapport au projet amène tous les jours des satisfactions. Par
exemple, un jour alors que nous venons de charger depuis le CVS la dernière version
de PyUt, nous constatons qu’une nouvelle fonctionalité s’est ajoutée et est directement employable pour nos laboratoires, pour d’autres cours. Parfois, un collaborateur
particulièrement motivé travaille tout un week-end sur le projet et le transforme radicalement vers un idéal. Les éléments se montent progressivement comme se monte un
chateau de carte, pour construire une unité utile et stable : PyUt1.1 !
Rapport de projet
5 / 12
C.Dutoit, EI6
PyUt 1.1
4
Etat final du projet
Tous les points du cahier des charges ont été remplis, exception faite de l’exportation
XMI. Cette tâche est terminée à 70%; la raison en est donnée à la section 4.8 page
suivante
4.1
Correction des bugs de PyUt 1.0
Tous les bugs détectés et marqués comme capitaux lors de PyUt 1.0 ont été corrigés.
Certains bugs détectés par la suite ont été également corrigés. Le bug essentiel corrigé étaient les liens entre les classes qui ne se chargeaient/sauvaient/affichaient pas
correctement.
4.2
Amélioration de l’édition de classes : Ajout de commentaires
Les commentaires de classes ont étés ajoutés et sont disponible à l’édition d’une classe.
4.3
Ajout de l’édition du diagramme des cas d’utilisation (use-case view)
Les acteurs et les systèmes ont été intégrés dans Pyut. Seul défaut actuel (en est-ce
vraiment un), la possibilité de mixer le diagramme de classe et le use-case view.
4.4
Internationalisation
La Possibilité de choisir la langue du logiciel parmis l’anglais et le français a été rendue
posible grâce à l’outils standard GNU gettext, outil prévu pour l’internationalisation
(i18n). Il est possible d’ajouter rapidement d’autres langues à PyUt . (Voir la section
i18n dans la documentation développeurs)
4.5
Arbre de projet
L’arbre de projet a été codé et intégré dans PyUt et permet d’ouvrir plusieurs fichiers
en même temps, un seul diagramme par fichier.
4.6
Reverse-engineering et génération de code
– La génération de code Python fonctionne, avec support de commentaires standards
pydoc.
Rapport de projet
6 / 12
C.Dutoit, EI6
PyUt 1.1
– Le reverse-engineering Python fonctionne pour plusieurs fichiers. Le programme
lit les fichiers et demande de sélectionner les classes à analyser puis génère les
diagrammes de classe UML. L’héritage est reconnu, mais le reverse-engineering
d’agrégation et de composition n’est pas réalisé, car il engendre trop de problèmes
politiques (Par exemple, faut-il afficher une agrégation pour l’agrégation d’une
classe réalisée seulement dans une procédure?)
– La génération de code C++ fonctionne avec génération de fichiers .h et .cpp dans
des dossiers distincts, et avec support du système de documentation standard
doxygen. (support = génération des tags de commentaires pour les en-têtes de
procédure, de classe, ...)
– La génération de code Java fonctionne avec support du système de documentation
automatique JAVADOC.
– Le reverse engineering Java fonctionne pour un seul fichier à la fois. L’implémentation d’interface et l’héritage sont implémentés, en plus du reverse engineering
des éléments standards : méthodes, données-membres, classes, ...
4.7
Notes UML
Les notes UML ont été ajoutées dans PyUt et permettent de documenter les classes
présentes dans le diagramme de classe, comme tout autre élément graphique.
4.8
XMI
Ajout de l’import/export XMI : l’importation fonctionne pour des fichiers XMI simples,
et l’exportation ne fonctionne pas actuellement, mais il manque peu de chose pour
qu’elle fonctionne. XMI est un format de fichier complexe qui demande beaucoup de
lignes de code par classe sauvée et pour cette raison, l’exportation ne fonctionne pas.
La moindre ligne de code XML oubliée entraı̂ne une lecture impossible, ou refusée d’un
lecteur XMI. (Par exemple, le lecteur XMI de Rational Rose). Nous espérons que cette
fonctionalité sera développée pour la prochaine version de PyUt.
4.9
Tests automatisés
Une série de tests automatisés par canevas de test ont été mis en place et sont disponibles dans le dossier src/tests. Lancer testall.py ou chaque fichier indépendamment.
Les tests s’exécutent et retournent le résultat de test à l’écran.
4.10
Aide contextuelle
Une aide contextuelle s’affiche lorsque l’utilisateur reste avec la souris sur un élément
graphique de PyUt , comme un bouton de commande (sous le menu).
Rapport de projet
7 / 12
C.Dutoit, EI6
PyUt 1.1
4.11
Localisation des sources
Les sources du projet sont disponibles sur le site WEB de pyut (http://pyut.sf.net),
sur Sourceforge(http://www.sf.net/projects/pyut) ou par CVS.
CVS est un logiciel de gestion de versions de documentation puissant, beaucoup utilisé
dans le monde libre et par des entreprises de développements conséquentes (ELCA).
L’accès aux sources par CVS 1 se fait par les lignes de commandes suivantes, en console
de type unix (Unix, Linux, Cygwin) :
cvs -d :pserver:[email protected]:/cvsroot/pyut login
cvs -z3 -d :pserver:[email protected]:/cvsroot/pyut co pyut
Si CVS demande un mot de passe, entrer un mot de passe vide (return). Pour obtenir la documentation, effectuer les mêmes commandes en remplaçant co pyut par
co pyutDoc.
1. http://www.cvshome.org
Rapport de projet
8 / 12
C.Dutoit, EI6
PyUt 1.1
5
Tests
Deux sortes de tests ont été réalisés sur PyUt : des tests unitaires et des tests utilisateurs.
5.1
5.1.1
Tests unitaires
Fonctionnement
Les tests unitaires sont automatisés. Ils sont réalisés avec le module Python standard
unittest. Ces tests sont pratiques une fois réalisés, car ils peuvent être lancés très facilement, et leur résultat est immédiat et binaire : réussi ou échoué. unittest est dérivé du
canevas de tests JUnit 2 qui est le canevas de référence, écrit en Java. Pour plus d’informations, voir le document “Unit : Canevas de tests” 3 réalisé par Laurent Burgbacher
serviteur dans le cadre d’un projet personnel.
En pratique, peu de tests unitaires ont été réalisés, du fait qu’ils sont relativement
mal adaptés à des projets axés sur l’interface graphique. Comme PyUt fait très peu de
choses en dehors de la gestion d’objets graphiques, les seuls tests unitaires concernent
les classes :
– Singleton
– FlyweightString
– PyutPreferences
Ces derniers sont disponibles dans le répertoire src/tests. L’exécution du fichier
TestAll.py lance tous les tests et affiche un petit rapport.
5.1.2
Philosophie des tests unitaires
Le but des tests unitaires est de vérifier en tout temps l’état du programme développé
de manière rapide et automatique. Ainsi, on lancera les tests le plus souvent possible,
de manière à repérer au plus vite la modification qui aura fait échouer un des tests.
Il est bon de commencer le développement d’un module en écrivant tout d’abord ses
tests. Ainsi, le développeur devra fixer l’interface du module avant de le développer, et
saura en tout temps quelles sont les parties qui ne respectent pas encore les tests.
5.1.3
Programmes nécessaires
unittest est un module standard Python, donc tout ce qu’il faut se résume à une
distribution Python.
2. http://www.junit.org
3. http://www.alawa.ch/eivd/unit/unit report.pdf
Rapport de projet
9 / 12
C.Dutoit, EI6
PyUt 1.1
5.1.4
Ecrire de nouveaux tests
S’il vous venait l’envie (excellente) de créer de nouveaux tests, un fichier template.py
fourni un modèle, toujours dans le répertoire src/tests. Le fichier TestAll.py crée
une suite de tests en chargeant tous les fichiers nommés TestXXX.py (où XXX est le nom
de la classe que vous testez) et en les exécutant.
5.2
Tests utilisateurs
Le mercredi 12 juin 2002 a été consacré aux tests. Chaque développeur a utilisé PyUt
dans le but de trouver des erreurs, et un système de “bug reports” a été mis en place
de la manière suivante :
– Détection d’un bug
– Annonce du bug au responsable tests
– Réponse positive
– Création d’un rapport de bug selon le fichier modèle (src/bugs/template.txt)
dans un nouveau fichier
– Ajout du fichier au CVS
– Catalogage du bug par le responsable tests et assignation à un développeur
– Réponse négative
– Le bug a déjà été déclaré, un rapport de bug existe, suite de la recherche
Le mercredi suivant a commencé par la correction des bugs les plus importants. Chaque
bug corrigé est consigné dans le rapport correspondant et vérifié par le responsable tests.
Les rapports sont disponible dans src/bugs.
Rapport de projet
10 / 12
C.Dutoit, EI6
PyUt 1.1
6
Ouvertures
Voici les éléments à implémenter dans PyUt pour les versions ultérieures :
–
–
–
–
–
–
–
–
–
–
–
–
7
Ajout d’édition d’autres diagrammes UML
Possibilité d’enregistrer plusieurs diagrammes par fichier
Support de plus de langages (reverse-engineering et génération de code)
Compatibilité et support d’autres logiciels (XMI)
Ajouter des préférences dans les préférences existantes
Réaliser une bounding box pour l’exportation Bitmap, pour n’exporter que ce qui
est utile
Améliorer les plugins, proposer des templates pour la génération de code (dans
lesquels on peut mettre les conventions de codage, par exemple)
Supporter plus de langages : C#, Visual Basic, ADA, SQL, ...
Améliorer la méthode de travail dans PyUt : Ajout de racourcis clavier, ajout
de création rapide de méthodes de classes en entrant un texte du style ”int methode(param1:type, param2:type)”
Permettre la réalisation de liens qui se ’crochent’ sur des liens
Elargir le champ d’horizon des plugins, proposer un tutorial pour la création
de plugins et stimuler les étudiants de l’EIVD ou le monde de l’Open-Source à
développer des plugins (comme projet de semestre, par exemple)
Améliorer la structure de base des données pour mieux apréhender la complexité
future du développement de PyUt. (=Refactoring)
Références
–
–
–
–
–
Site de Sourceforge : http://www.sourceforge.net
CVS (Concurrent Versions System) : http://www.cvshome.org
Python : http://www.python.org
wxPython : http://www.wxpython.org
Site du projet : http://pyut.sf.net
Rapport de projet
11 / 12
C.Dutoit, EI6
PyUt 1.1
8
Conclusion
Dans le cadre du premier projet de groupe, nous avons réalisé le logiciel PyUt1.0, éditeur
de classes UML codé en Python. Ce projet y fait suite et sous le numéro de version 1.1,
ce projet implémente des fonctionalités supplémentaires, comme le Roundtrip Java et
Python ainsi que la génération C++.
D’autres fonctionalités ajoutées lors de ce projet ont été l’intégration d’un arbre de
projet, la possibilité d’importer les données à partir du format XMI, reconnu dans
Rational Rose.
Ce projet a connu un vif succès puisque la première version, PyUt1.0, a été téléchargée
plus de 5000 fois. La version Alpha de PyUt1.1 a été téléchargée plus de 360 fois sans
que nous ayons fait aucune publicité (compteurs du 9 juillet 2002).
Ce projet intéressant et utile mérite d’être poursuivi, par exemple lors des travaux de
groupe ou de semestre de nos successeurs à l’EIVD.
Nous tenons à remercier ici l’EIVD pour son support et pour nous avoir permis de
développer ce projet une année durant notre formation, comme projet de groupe.
Rapport de projet
12 / 12
C.Dutoit, EI6