Abdelhamid Ibn Badis University of Mostaganem

Faculty of Exact Sciences and Computer Science

Department of Mathematics and Computer Science

Master ISI 2023/2024

Ingénierie Dirigée par les Modèles (IDM)

Fiche TP N°2

Ce tutoriel vous montre comment créer votre première transformation simple avec ATL, à travers un
exemple basique bien connu : Families2Persons.

Objectifs

Les objectifs de ce tutoriel sont d'effectuer une transformation d'une liste de familles en liste de
personnes.

D'un côté (la source), nous avons une liste de familles. Chaque famille a un nom de famille et contient
un père, une mère et un certain nombre de fils et de filles (0, 1 ou plus), tous portant un prénom.

Nous souhaitons transformer cette liste en une nouvelle liste de personnes (la cible), cela signifie que
chaque membre de la famille sera une personne, sans différencier les parents des enfants, et sans lien
entre les membres d'une même famille (sauf un une partie de leur nom). Au final, il ne faut avoir qu'une
personne avec son nom complet (prénom & nom), masculin ou féminin.
1. Créer un nouveau projet ATL

Pour créer un nouveau projet ATL, vous devez aller dans Fichier > Nouveau > Autre...

Puis sélectionnez ATL > Projet ATL....

Ensuite, cliquez sur le bouton Suivant >. Tapez un nom pour le projet (dites « Families2Persons » pour
notre exemple).
Le projet devrait maintenant apparaître sur votre liste de projets.

2. Les métamodèles

Maintenant que notre projet est prêt à être utilisé, nous pouvons le compléter. Nos premiers fichiers
décrivent la structure d'une famille et d'une personne, déterminant ainsi comment nous souhaitons
les représenter par la suite (similaire à la manière dont une carte représente le monde réel). Ces
fichiers constituent ce que l'on nomme un métamodèle, correspondant à un fichier Ecore.

Pour créer le fichier Ecore, accédez à File > New > Other..., puis sélectionnez Eclipse Modeling
Framework > Ecore Model et cliquez sur Next >

Sélectionnez votre projet Families2Persons dans la liste, saisissez un nom pour le fichier
(Families.ecore par exemple) et cliquez sur Terminer. Un fichier vide est ajouté à votre projet. Répétez
cette tâche pour le métamodèle Persons.ecore.
3. Le code de transformation ATL

Maintenant que nous avons représenté ce que nous avons (Familles, la source) et ce que nous voulons
obtenir (Personnes, la cible), nous pouvons nous concentrer sur le cœur de la transformation : le code
ATL. Ce code va faire correspondre une partie de la source avec une partie de la cible.

Ce que nous voulons dans notre exemple, c'est prendre chaque membre de chaque famille, et le
transformer en une personne. Cela implique de fusionner son prénom et son nom pour avoir un nom
complet, définissant s'il s'agit d'un homme ou d'une femme, et de copier ces informations dans un
objet Personne.

Nous avons d’abord besoin d’un fichier dans lequel mettre ce code. Créez donc un nouveau fichier ATL
en allant dans Fichier > Nouveau > Autre..., puis ATL > Fichier ATL.

Nommez-le "Families2Persons.atl" par exemple, n'oubliez pas de sélectionner votre projet, puis cliquez
sur Terminer.
Si vous êtes invité à ouvrir la perspective ATL, cliquez sur Oui.

Lorsque vous ouvrez le fichier, une erreur est marquée (nous verrons comment la corriger ci-dessous),
et il contient une seule ligne :

module Families2Persons;

Nous ajoutons d'abord deux lignes en haut du fichier, une pour chaque métamodèle, afin que l'éditeur
puisse utiliser l'auto-complétion et la documentation lorsque nous saisissons du code concernant les
deux métamodèles :

-- @path Families=/Families2Persons/Families.ecore
-- @path Persons=/Families2Persons/Persons.ecore

Ensuite, nous disons à ATL que nous avons des familles et que nous voulons que des personnes sortent
(cela devrait corriger l'erreur) :

create OUT: Persons from IN: Families;

Nous devons maintenant définir quelques helpers :

helper context Families!Member def: isFemale(): Boolean =

if not self.familyMother.oclIsUndefined() then
true
else
if not self.familyDaughter.oclIsUndefined() then
true
else
false
endif
endif;
--------------------------------------------------------------------------------
helper context Families!Member def: familyName: String =
if not self.familyFather.oclIsUndefined() then
self.familyFather.lastName
else
if not self.familyMother.oclIsUndefined() then
self.familyMother.lastName
else
if not self.familySon.oclIsUndefined() then
 self.familySon.lastName
else
self.familyDaughter.lastName
endif
endif
endif;

Ces helpers seront utilisés dans les règles que nous verrons ci-dessous.

Le premier est appelé sur un membre d'une famille (contexte Families!Member), nous donne un
booléen (: Boolean), et nous indique si le membre est une femme ou non, en vérifiant si la référence
familyDaughter ou familyMother est définie ou pas.

Le second fait également appel à un membre d'une famille, nous donne cette fois une chaîne (:String)
et renvoie le nom de famille du membre. Il doit le chercher dans chaque référence à la famille, pour
voir laquelle est définie (famillePère, familleMère, familleFils ou familleFille).

Et enfin, nous ajoutons deux règles créant des personnes masculines et féminines parmi les membres
des familles :

rule Member2Male {
from
s: Families!Member (not s.isFemale())
to
t: Persons!Male (
fullName <- s.firstName + ' ' + s.familyName
)
}

rule Member2Female {
from
s: Families!Member (s.isFemale())
to
t: Persons!Female (
fullName <- s.firstName + ' ' + s.familyName
)
}

Chaque règle sera appelée sur l'objet qui respecte le prédicat de filtre dans la partie from. Par exemple,
la première règle prend chaque membre de chaque famille (de s: Families!Member) qui n'est pas une
femme (en utilisant l'assistant que nous avons décrit ci-dessus, pas s.isFemale()). Et puis il crée une
personne de sexe masculin (à t: Persons!Male) et définit son attribut fullName sur le prénom du
membre suivi de son nom de famille (en utilisant l'assistant familyName que nous avons vu ci-dessus).
Le principe est le même pour la deuxième règle, alors que cette fois-ci elle ne prend en compte que les
membres féminins.

Notez que l'éditeur ATL fournit une coloration syntaxique et une indentation bien meilleures que ce
que vous pouvez voir ci-dessus. D’ailleurs, vous pouvez trouver de l’aide sur ce que nous avons vu ci-
dessus dans le Guide de l’utilisateur, ici et ici.
4. Le fichier modèle des exemples de familles

La transformation est prête à être utilisée, nous avons juste besoin d'un exemple de modèle pour
l'exécuter. Créez d'abord un fichier dans votre projet dans lequel nous mettrons le code du modèle.
Allez dans Fichier > Nouveau > Fichier

nommez-le "sample-Families.xmi" par exemple

et ouvrez-le avec un éditeur de texte. Voici un exemple de code :

<?xml version="1.0" encoding="ISO-8859-1"?>

<xmi:XMI xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns="Families">
<Family lastName="March">
<father firstName="Jim"/>
<mother firstName="Cindy"/>
<sons firstName="Brandon"/>
<daughters firstName="Brenda"/>
</Family>
<Family lastName="Sailor">
<father firstName="Peter"/>
<mother firstName="Jackie"/>
<sons firstName="David"/>
 <sons firstName="Dylan"/>
<daughters firstName="Kelly"/>
</Family>
</xmi:XMI>

5. La configuration de lancement

Nous avons tout ce qu'il faut pour faire la transformation, mais il reste encore une étape avant de la
lancer, du moins la première fois : il faut configurer le lancement.

Lorsque vous êtes dans le fichier ATL (Families2Persons.atl), cliquez sur Exécuter > Exécuter (ou
Ctrl+F11)

Une boîte de dialogue s'ouvre. Plusieurs informations sont déjà renseignées : le module ATL (notre
fichier de transformation, Families2Persons.atl), les métamodèles (Families.ecore et Persons.ecore),
mais il nous reste à compléter la page.

La partie Modèles Source (IN:, conforme to Familles) est le modèle que nous souhaitons transformer,
c'est-à-dire notre sample-Families.xmi ; parcourez l’espace de travail pour l’ajouter.
La partie Modèles cibles (Out :, conforme to Personnes) est le modèle à générer ; parcourez l'espace
de travail pour trouver votre projet et entrez un nom pour le fichier (par exemple "sample-
Persons.xmi").

Une option utile se trouve dans l'onglet Commun de la page : nous pouvons sauvegarder notre
configuration afin qu'ATL puisse la retrouver la prochaine fois que nous voudrons l'exécuter ou si le
projet est exporté. Si vous cochez Fichier partagé et naviguez au sein de votre projet, vous pouvez
enregistrer cette configuration dans un fichier ("Families2Persons.launch" par exemple).
6. Exécuter la transformation

Enfin, nous pouvons exécuter la transformation en cliquant sur Exécuter sur la page de configuration.
Un fichier est alors généré, nommé sample-Persons.xmi, et contenant la liste des membres de votre
famille transformés en personnes.

Voici ce que vous devriez obtenir si vous l'ouvrez avec un éditeur de texte :

<?xml version="1.0" encoding="ISO-8859-1"?>

<xmi:XMI xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns="Persons">
<Male fullName="Jim March"/>
<Male fullName="Brandon March"/>
<Male fullName="Peter Sailor"/>
<Male fullName="David Sailor"/>
<Male fullName="Dylan Sailor"/>
<Female fullName="Cindy March"/>
<Female fullName="Brenda March"/>
<Female fullName="Jackie Sailor"/>
<Female fullName="Kelly Sailor"/>
</xmi:XMI>