Author: fdesbois Date: 2009-11-02 19:17:52 +0100 (Mon, 02 Nov 2009) New Revision: 686 Added: branches/eugene-2.0/eugene/doc/3-v2.0/ branches/eugene-2.0/eugene/doc/3-v2.0/eugene2.0.pdf branches/eugene-2.0/eugene/doc/3-v2.0/sources/ branches/eugene-2.0/eugene/doc/3-v2.0/sources/DiagActivite_EUGene1.0.1_Generation.png branches/eugene-2.0/eugene/doc/3-v2.0/sources/DiagActivite_EUGene2.0_Generation.png branches/eugene-2.0/eugene/doc/3-v2.0/sources/DiagActivite_EUGene2.0_GenerationJava.png branches/eugene-2.0/eugene/doc/3-v2.0/sources/EUGene-generate.vpp branches/eugene-2.0/eugene/doc/3-v2.0/sources/eugene2.0 branches/eugene-2.0/eugene/doc/3-v2.0/sources/eugene_v2.0.zargo Modified: branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/java/ImportsManagerExtension.java branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelClassifierImpl.java Log: - Correction getInterfaces to use GeneratorUtil methods - Suppress throw exception on getImports method - Change old docs folders name and add new doc for eugene 2.0 Added: branches/eugene-2.0/eugene/doc/3-v2.0/eugene2.0.pdf =================================================================== (Binary files differ) Property changes on: branches/eugene-2.0/eugene/doc/3-v2.0/eugene2.0.pdf ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Property changes on: branches/eugene-2.0/eugene/doc/3-v2.0/sources ___________________________________________________________________ Added: svn:ignore + EUGene-generate.vpp~1 Added: branches/eugene-2.0/eugene/doc/3-v2.0/sources/DiagActivite_EUGene1.0.1_Generation.png =================================================================== (Binary files differ) Property changes on: branches/eugene-2.0/eugene/doc/3-v2.0/sources/DiagActivite_EUGene1.0.1_Generation.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Added: branches/eugene-2.0/eugene/doc/3-v2.0/sources/DiagActivite_EUGene2.0_Generation.png =================================================================== (Binary files differ) Property changes on: branches/eugene-2.0/eugene/doc/3-v2.0/sources/DiagActivite_EUGene2.0_Generation.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Added: branches/eugene-2.0/eugene/doc/3-v2.0/sources/DiagActivite_EUGene2.0_GenerationJava.png =================================================================== (Binary files differ) Property changes on: branches/eugene-2.0/eugene/doc/3-v2.0/sources/DiagActivite_EUGene2.0_GenerationJava.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Added: branches/eugene-2.0/eugene/doc/3-v2.0/sources/EUGene-generate.vpp =================================================================== (Binary files differ) Property changes on: branches/eugene-2.0/eugene/doc/3-v2.0/sources/EUGene-generate.vpp ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Added: branches/eugene-2.0/eugene/doc/3-v2.0/sources/eugene2.0 =================================================================== --- branches/eugene-2.0/eugene/doc/3-v2.0/sources/eugene2.0 (rev 0) +++ branches/eugene-2.0/eugene/doc/3-v2.0/sources/eugene2.0 2009-11-02 18:17:52 UTC (rev 686) @@ -0,0 +1,246 @@ +========== +EUGene 2.0 +========== + +:Date: 2009-11-02 +:Author: fdesbois (fdesbois@codelutin.com) + +.. contents:: Contenu + +Contexte de départ +------------------ + +L'évolution majeure d'EUGene de la 1.0.1 à la 2.0.0 concerne une simplification de la génération de fichiers Java. Pour ce faire, plusieurs évolutions sont à prendre en compte : + +- Modification du processus de génération (modification du point de lecture dans le processus) +- Permettre une transformation Model To Model +- Création d'une template de génération simple et sans intelligence (sans interprétation du modèle) pour génération uniquement Java + +La version 2.0 modifie donc le processus sur trois niveaux différents : Lecture, Transformation et Génération. + +Contraintes de non régression +----------------------------- + +- La config du plugin maven ne doit quasimment pas changer : Les transformations seront considérés comme des templates de générations +- L'ObjectModel ne doit pas prendre en compte des spécificités Java (pas d'importsManager, pas d'attributs "synchronized", ...), le comportement doit rester identique. +- Les templates de génération existantes doivent fonctionner toujours de la même manière : même résultat à la génération + + +Modification du processus de génération +--------------------------------------- + +Version 1.0.1 +~~~~~~~~~~~~~ + +Dans la version 1.0.1, les possibilités de fichiers en entrée du processus sont assez limités. Il est possible d'utiliser différents goal du maven-eugene-plugin pour pouvoir avoir en entrée +d'autres fichiers que ceux spécifiques à un des modèles supportés par EUGene (StateModel, ObjectModel, ...). Les goals existants sont : zargo2xmi, xmi2objectmodel et xmi2statemodel. Sur le diagramme ci-dessous est représenté une génération à partir de fichiers **.zargo** pour obtenir des fichiers **.java**. En beige sont représentés les points d'extension possible dans le processus de génération. Ces derniers sont très limités : + +- **ObjectModel** : Modele représentant les données extraites à partir des fichiers sources (le modèle étend la classe << *Model* >>) + +- **Generator** : Template de génération qui interprète le modèle pour effectuer une génération de fichiers en sorties, ici java. (la template étend la classe << *Generator* >>) + + +.. figure:: DiagActivite_EUGene1.0.1_Generation.png + + Processus de génération v1.0.1 + +Version 2.0 +~~~~~~~~~~~ + +Deux nouveautés : + +- Possibilité d'étendre le point de lecture en début de processus : Cela permettra ainsi d'avoir n'importe quel type de fichier en entrée, du moment qu'un Reader existe pour les interpréter et rendre un Model. + +- Possibilité de transformer un modèle pour spécifier un langage (ex Java) ou tout autre transformation : Un Transformer est alors considéré comme un Generator pour simplifier le processus. + +Ces deux nouveautés forment les nouveaux points d'extension du processus, à noter également la possibilité d'inclure dans le processus la transformation de n'importe quel modèle en un autre modèle. + +.. figure:: DiagActivite_EUGene2.0_Generation.png + + Processus de génération v2.0 + +Génération spécifique à Java +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Voici le cas spécifique à la génération Java. Nous voulons en entrée lire des fichiers Objectmodel (utilisation d'un ObjectModelReader), puis transformer ce modèle complet (avec notions UML) en un nouveau ObjectModel simple uniquement dédié à la génération Java (utilisation d'un ObjectModelTransformerToJava associé à la template JavaGenerator). + +.. figure:: DiagActivite_EUGene2.0_GenerationJava.png + + Processus de génération v2.0 pour Java + +Le développeur se chargera d'intepréter le modèle d'entrée (lu par l'ObjectModelReader) pour le transformer en ObjectModel Java : extension de l'ObjectModelTransformerToJava. Ce transformer sera une sorte d'équivalent à un template de génération qui étend Generator. + +Liste des Evolutions +-------------------- + +1 - `Evol #112`_ : Ajout d'un point d'entrée dans le processus de génération : ModelReader + +2 - `Evol #114`_ : Ajout d'extensions à l'ObjectModel + +3 - `Evol #115`_ : Remplissage de l'ObjectModel directement a partir du code pour génération Java : JavaBuilder + +4 - `Evol #113`_ : Possibilité de faire du Model To Model : Transformer + +5 - `Evol #116`_ : Modification hiérarchie des Generator pour prise en charge des Transformer + +6 - `Evol #117`_ : Création d'une template de génération sans intelligence pour Java : JavaGenerator + +7 - `Evol #107`_ : Remplacer les attributs (static, abstract, visibility, ...) par une liste de "modifier" + + +.. _Evol #112: http://nuiton.org/issues/show/112 +.. _Evol #114: http://nuiton.org/issues/show/114 +.. _Evol #113: http://nuiton.org/issues/show/113 +.. _Evol #115: http://nuiton.org/issues/show/115 +.. _Evol #116: http://nuiton.org/issues/show/116 +.. _Evol #117: http://nuiton.org/issues/show/117 +.. _Evol #107: http://nuiton.org/issues/show/107 + +Evolution #112 : ModelReader +---------------------------- + +Besoin/Contexte +~~~~~~~~~~~~~~~ + +Mise en place +~~~~~~~~~~~~~ + +Conversion existant +~~~~~~~~~~~~~~~~~~~ + +Extension +~~~~~~~~~ + + +Evolution #114 : Extensions ObjectModel +--------------------------------------- + +Besoin/Contexte +~~~~~~~~~~~~~~~ + +La génération Java nécessite une manipulation simple pour l'ajout des imports qui seront rajoutés en début de fichier. Il existe dans la 1.0.1, la classe ImportsManager qui remplit cette tâche : +Elle permet de lui ajouter différents imports à effectuer sous forme de String ou de Class. Ces imports sont ensuite récupérer suivant un nom de package. +Pour simplifier la génération Java, il suffirait d'ajouter les ImportsManager (un par classifier) directement dans l'ObjectModel racine. Cependant, pour ne pas ajouter de notion spécifique à Java, +cet ajout sera considéré comme une extension à l'ObjectModel. + +Mise en place +~~~~~~~~~~~~~ + +Une *Map<String, Object> extensions* est ajoutée dans l'ObjectModel racine. Une méthode addExtension est disponible dans ObjectModelImpl pour ajouter une nouvelle extension au modèle. La méthode +getExtension(String reference, Class extensionClass) permettra de récupérer l'extension souhaité (avec son type) et sera disponible dans l'interface ObjectModel. + + +Cas des ImportsManager +~~~~~~~~~~~~~~~~~~~~~~ + +Pour les ImportsManager, il est nécessaire d'avoir une Map<String, ImportsManager>, la clé étant le nom complet (full qualified name) d'un classifier, et la valeur l'ImportsManager associé à ce classifier. +Pour simplifier l'utilisation des ImportsManager (et éviter les problèmes de cast sur l'extension), une classe ImportsManagerExtension est créé comprenant la map des managers et des méthodes accesseurs : + +- **ImportsManager getManager(ObjectModelClassifier classifier)** : Permet de récupérer (ou créer s'il n'existe pas) l'ImportsManager lié à un classifier. Méthode utilisée pour les transformations du modèle (ObjectModelTransformer, JavaBuilder) + +- **List<String> getImports(ObjectModelClassifier classifier)** : Permet de récupérer tous les imports liés à un classifier. Méthode utilisée pour la génération (ObjectModelGenerator, JavaGenerator) + +L'ImportsManagerExtension forme donc l'extension spécifique aux imports ajouté à l'ObjectModel:: + + // Utilisation dans Transformer ou Builder + ImportsManagerExtension managers = model.getExtension(ImportsManagerExtension.OBJECTMODEL_EXTENSION, ImportsManagerExtension.class); + ImportsManager maClassManager = managers.getImportsManager(maClass); + maClassManager.addImport("java.util.List"); + + // Utilisation dans Generator + ImportsManagerExtension managers = model.getExtension(ImportsManagerExtension.OBJECTMODEL_EXTENSION, ImportsManagerExtension.class); + managers.getImports(maClass); + + +Extension +~~~~~~~~~ + +Il est désormais possible d'utiliser les extensions comme moyen d'enrichir l'ObjectModel lors des transformations et des générations. + +Evolution #115 : JavaBuilder +---------------------------- + +Besoin/Contexte +~~~~~~~~~~~~~~~ + +Il est intéressant de pouvoir, dans certains cas, remplir un ObjectModel vide pour générer directement du Java. L'utilisation se fait directement à partir du code d'une autre application qui souhaite utiliser l'ObjectModel pour générer directement du Java. Cependant la version 1.0.1 ne permet pas de faire cela car les interfaces des classes de l'ObjectModel ne comprennent pas de setter. Il est donc +nécessaire de créer une nouvelle classe permettant de remplir un ObjectModel vide tout en ayant une finesse d'interprétation spécifique à Java (gestion des imports, doublon sur les méthodes, ...). +De plus le JavaBuilder servira aux transformations pour de la génération Java. + +Mise en place +~~~~~~~~~~~~~ + +Création d'une classe JavaBuilder qui initialise à l'instanciation un ObjectModel vide (A noter que le nom du modèle est indispensable à la génération). Le JavaBuilder propose un panel de méthodes permettant : + +- Ajout de classes/interfaces au modèle +- Ajout d'une superclass +- Ajout d'interface à une classe +- Ajout de méthodes à une classe/interface +- Ajout du corps des méthodes +- Ajout de paramètres à une méthode +- Ajout d'exception à une méthode +- Ajout d'attributs à une classe/interface +- ... + +Ces méthodes comprendront une gestion automatique des imports (types des paramètres/attributs, retour des méthodes, exceptions, ...). + +Evolution #113 : Transformer +---------------------------- + +Besoin/Contexte +~~~~~~~~~~~~~~~ + +L'écriture des templates de génération actuelles (v1.0.1) peuvent être fastidieuses et difficiles à maintenir. Il est donc préférable d'utiliser une tranformation du modèle ObjectModel source (provenant d'un diagramme UML) en un ObjectModel représentant basiquement le Java qui sera généré. + +Mise en place +~~~~~~~~~~~~~ + +Un Transformer est considéré comme un Generator pour être intégré plus facilement dans le processus de génération (templates). Cependant il possède un modèle en entrée et un en sortie, donc pas de sortie fichiers. Pour ce faire, il est obligatoirement associé à un Generator. Ainsi un Transformer prendra en entrée un modèle, le transformera en un nouveau (potentiellement de type différent) et utilisera le generator de sortie pour générer ce nouveau modèle. Il est donc nécessaire d'instancier un Transformer en lui fournissant son Generator de sortie. Le modèle de sortie doit donc être obligatoirement compatible avec ce Generator de sortie. + +Conversion existant +~~~~~~~~~~~~~~~~~~~ + +Extension +~~~~~~~~~ + + +Evolution #116 : Generator +-------------------------- + +Besoin/Contexte +~~~~~~~~~~~~~~~ + +Mise en place +~~~~~~~~~~~~~ + +Extension +~~~~~~~~~ + + +Evolution #117 : JavaGenerator +------------------------------ + +Besoin/Contexte +~~~~~~~~~~~~~~~ + +Mise en place +~~~~~~~~~~~~~ + + +Evolution #107 : ObjectModelModifier +------------------------------------ + +Besoin/Contexte +~~~~~~~~~~~~~~~ + +Mise en place +~~~~~~~~~~~~~ + +Conversion existant +~~~~~~~~~~~~~~~~~~~ + +Extension +~~~~~~~~~ + + + Added: branches/eugene-2.0/eugene/doc/3-v2.0/sources/eugene_v2.0.zargo =================================================================== (Binary files differ) Property changes on: branches/eugene-2.0/eugene/doc/3-v2.0/sources/eugene_v2.0.zargo ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Modified: branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/java/ImportsManagerExtension.java =================================================================== --- branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/java/ImportsManagerExtension.java 2009-11-02 18:17:45 UTC (rev 685) +++ branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/java/ImportsManagerExtension.java 2009-11-02 18:17:52 UTC (rev 686) @@ -65,13 +65,9 @@ * Get imports for a classifier. The ImportsManager must be defined in the model. * @param classifier reference for the imports * @return a List of String which contains all imports for the classifier - * @throws IllegalArgumentException when classifier is not associated with an existing ImportsManager */ public List<String> getImports(ObjectModelClassifier classifier) throws IllegalArgumentException { - ImportsManager manager = this.managers.get(classifier.getQualifiedName()); - if (manager == null) { - throw new IllegalArgumentException("No importsManager defined for '" + classifier.getQualifiedName() + "'"); - } + ImportsManager manager = getManager(classifier); return manager.getImports(classifier.getPackageName()); } } Modified: branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelClassifierImpl.java =================================================================== --- branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelClassifierImpl.java 2009-11-02 18:17:45 UTC (rev 685) +++ branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/models/object/xml/ObjectModelClassifierImpl.java 2009-11-02 18:17:52 UTC (rev 686) @@ -26,6 +26,7 @@ import java.util.List; import java.util.Map; +import org.nuiton.eugene.GeneratorUtil; import org.nuiton.eugene.models.object.ObjectModelAttribute; import org.nuiton.eugene.models.object.ObjectModelClassifier; import org.nuiton.eugene.models.object.ObjectModelDependency; @@ -137,11 +138,11 @@ ObjectModelInterfaceImpl interfacez = (ObjectModelInterfaceImpl)objectModelImpl.getInterface(ref.getName()); if (interfacez == null) { + // TODO avoid multiple creation -> put new object in cache (or extension) interfacez = new ObjectModelInterfaceImpl(); String fqn = ref.getName(); - int index = fqn.indexOf("."); - String packageName = fqn.substring(0, index); - String name = fqn.substring(index+1); + String packageName = GeneratorUtil.getParentPackageName(fqn); + String name = GeneratorUtil.getClassNameFromQualifiedName(fqn); interfacez.setName(name); interfacez.setPackage(packageName); interfacez.postInit(); // to create qualifiedName