Comment utiliser VSCode et Moose pour analyser les projets Java ?

VSCode est un outil d'édition étonnant. Grâce à ses extensions, on peut développer en utilisant de nombreux langages de programmation. Cependant, qu'en est-il de l'analyse d'un système logiciel à l'aide de VSCode ? Dans cet article, nous allons vous montrer comment utiliser VSCode avec Moose pour analyser le code Java. Nous utilisons Christopher Fuhrman à titre d'exemple.

Bien que nous puissions effectuer certaines analyses à partir de VSCode, l'utilisation native de l'outil Moose offre une meilleure expérience utilisateur. Néanmoins, nous pensons que cela peut intéresser les personnes qui utilisent uniquement l'outil VSCode.

Téléchargez et installez les outils nécessaires

Pour effectuer l'analyse, nous utiliserons la version insider de VSCode. Actuellement, seule cette version supporte la fonction NoteBook que nous allons utiliser. Donc, dans un premier temps, installez la dernière version insider de VSCode. Nous aurons également besoin d'une image Moose et d'une VM Pharo. Pour ce billet de blog, nous utiliserons une image Moose 8 basée sur Pharo 8.

  • Téléchargez la dernière image Moose 8 pour VSCode et extrayez-la.
  • Téléchargez la VM Pharo correspondante et extrayez-la.

Conseils: Ne pas prendre la version headless (elle n'a pas été testée)

Une fois que vous avez téléchargé VSCode, Moose 8 et la VM Pharo, nous allons installer l'extension dans VSCode.

  • Télécharger l'extension
  • Ouvrir l'initiateur VSCode
  • Ouvrez le dossier dans lequel se trouve le fichier d'extension.
  • Cliquez avec le bouton droit de la souris sur le fichier et exécutez Installer l'extension
  • Fermer le code VSC

Désormais, vous devez lancer VSCode insider avec les paramètres suivants (-enable-proposed-api badetitou.pharo-language-server). Cela permet à VSCode d'utiliser l'API Notebook. Exécutez la commande suivante dans un terminal :

  • code-insiders -enable-proposed-api badetitou.pharo-language-server

Ou dans Windows :

  • code-insiders.cmd -enable-proposed-api badetitou.pharo-language-server

Configurer le VSCode

Nous devons maintenant configurer l'extension Pharo Language Server. Pour ce faire :

  • Allez dans les paramètres du VSCode (Ctrl + ,).
  • Rechercher les paramètres de Pharo
  • Définir le champ Chemin d'accès à l'image avec le chemin d'accès à l'image que vous avez téléchargée
    D:\Users\benoit.verhaeghe\Documents\Pharo\images\LSP4\LSP4.image
  • Définir le champ Chemin d'accès à la VM avec le chemin d'accès à la VM que vous avez téléchargée
    D:\Users\benoit.verhaeghe\Documents\Pharo\vms\80-x64\Pharo.exe
  • Redémarrer VSCode (pour être sûr que la configuration est bien sauvegardée)

Conseils: Si vous utilisez Windows, vous devrez peut-être supprimer tous les caractères d'espace dans le chemin.

Une fois la configuration effectuée, vous pouvez créer un nouveau fichier nommé oo-analyse.moosebook. Il devrait s'ouvrir sous la forme d'un carnet VSCode et d'une image Pharo (vous pouvez réduire l'image Pharo, mais ne le fermez pas).

Mettre en place l'analyse d'un nouveau projet

Afin de configurer l'analyse d'un nouveau projet, plusieurs étapes doivent être prises en compte.

Clonez le projet Java que vous voulez analyser

Tout d'abord, nous allons télécharger le projet GitHub que nous voulons analyser. Pour ce faire, créez un nouveau cellule de code dans VSCode avec le code suivant :
javaProjectFileRef := MooseEasyUtility cloneGitHubRepo : 'https://github.com/bethrobson/Head-First-Design-Patterns'.

Ce morceau de code téléchargera le projet dans notre dossier d'images Pharo. Pour exécuter la cellule, appuyez sur la flèche run à côté de la cellule. En cas de succès, une petite coche apparaît et le chemin vers le projet clone est sorti de la cellule.

Analyser le code Java pour en faire un modèle FAMIX

Comme dans l'article original de Christopher, nous allons maintenant analyser le projet Java et créer un modèle FAMIX. Pour analyser le projet Java, nous utilisons VerveineJ v1.x.x (v1.x.x fonctionne avec Moose 8, alors que v2.x.x est en cours de modification pour fonctionner avec le futur Moose 9).
Contrairement à l'article original du blog, nous allons télécharger VerveineJ v1.0.2 (et non v1.0.1). Elle inclut de belles corrections.

  • Créez une nouvelle cellule de code avec le morceau de code suivant pour télécharger la dernière version de VerveineJ et l'extraire
client :=ZnClient nouveau. client signalProgress : faux ; url : https://github.com/moosetechnology/VerveineJ/archive/v1.0.2.zip ; téléchargerTo :FileLocatorimageDirectory. client isSuccess ifTrue : [ ZipArchive nouveau readFrom : (FileLocatorimageDirectory/ v1.0.2.zip') asFileReferencepathString ; extractAllTo :FileLocatorimageDirectory."Comme les permissions ne sont pas préservées avec ZipArchive#extractAllTo :""Cette ligne n'est pas requise dans le système Windows"LibCrunCommand : chmod u+x, (FileLocatorimageDirectory/ 'VerveineJ-1.0.1/verveinej.sh') asFileReferencepathString ] ifFalse : [ Erreursignal : "Le téléchargement a échoué. ]
  • Ensuite, nous demanderons MooseEasyFamixMaker pour analyser le projet Java en utilisant VerveineJ et créer un .mse pour nous. Encore une fois, dans une autre cellule, exécutez le bout de code suivant.
magicien := MooseEasyFamixMaker
générerMSETo : Tmp/HFDP.mse asFileReference
l'analyse syntaxique : 'tmp/MooseEasyRepos/bethrobson__Head-First-Design-Patterns' (en anglais) asFileReference
avec : (FileLocator imageDirectory / 'VerveineJ-1.0.2/verveinej.bat') asFileReference.
magicien générerMSE.

.mse est un format de fichier utilisé par Moosetechnology pour représenter son modèle et son méta-modèle. D'autres formats existent.

Charger le modèle

La dernière étape consiste à charger le modèle dans l'image Moose (celle que nous contrôlons à l'aide du VSCode). Dans une nouvelle cellule, exécutez :

mseFileRef := Tmp/HFDP.mse asFileReference. "Généré par FamixMaker"
mseStream := mseFileRef readStream.
mseStream
ifNotNil : [
mooseModel := MooseModel importFromMSEStream : mseStream.
mooseModel rootFolder :
'tmp/MooseEasyRepos/bethrobson__Head-First-Design-Patterns'.
mseStream fermer. ]
siNil : [self erreur :
Impossible de charger le fichier MSE dans Moose : ' , mseFileRef asString ].
mseStream.
mooseModel installer

La sortie de la cellule devrait être un élanModèle #HFDP(30946).
Félicitations ! Vous avez tout mis en place. Il est maintenant temps d'analyser le projet :rocket :

Analyse

Pour visualiser les paquets Java en utilisant PlantUML. Nous installons d'abord le connecteur PlantUML de Pharo (PlantUMLPharoGizmo). Pour ce faire, il suffit de créer une nouvelle cellule de code avec le script d'installation et de l'exécuter.

"Installer PlantUMLPharo"
version := "maître".
Metacello nouveau
dépôt : github://fuhrmanator/PlantUMLPharoGizmo : , version, '/src' ;
ligne de base : PUGizmo ;
charge.

Ensuite, vous pouvez visualiser les classes d'un paquet en exécutant un script Pharo.

attribut := vrai.
méthode := faux.
Héritage := vrai.
agrégation := vrai.
createCheckBox := faux.

préférence := set namespaceSeparator : : ". , Chaîne de caractères cr
  , cacher les membres vides , Chaîne de caractères cr , échelle 1 , Chaîne de caractères cr
  , direction de gauche à droite , Chaîne de caractères cr.

articles := mooseModel allModelClasses sélectionner : [:chacun | chacun Nom de l'élan beginsWith : headfirst::designpatterns::combining::decorator' ].


pUMLSource := PUGizmo
  plantUMLSourceForMooseJavaClasses : articles
  avecPréférence : préférence
  avec des relations :
   {attribut.
   méthode.
   héritage.
   agrégation.
   créerCheckBox}.

plantKey := pUMLSource asPlantUMLKey.
serverUrl := https://www.plantuml.com/plantuml/img/, plantKey.  
imageMorph := (ZnEasy getPng : serverUrl asUrl).

Dans l'exemple ci-dessus, comme dans l'article de blog original, nous nous concentrons sur le paquet : headfirst::designpatterns::combining::decorator et nous montrons les classes attributs, héritages, et agrégation. L'exécution du code donne l'image suivante comme sortie de la cellule VSCode.

Effectuer une analyse Moose à l'aide de Pharo

Il est également possible d'exécuter du code Pharo classique. Nous pouvons demander la liste des classes qui implémentent plus d'une interface.

"Interroger toutes les classes qui ont plus de deux superclasses directes du FAMIX"
classesImplémentantMoreThanOneInterface := mooseModel allModelClasses 
 sélectionner : [ :chaque |
  chacun directSuperclasses taille > 2 ].
Chaîne de caractères streamContents : [ :flux | classesImplémentationMoreThanOneInterface faire : [:classe | flux << classe nom ] séparés : [flux << ', ' ] ]

Visualisation avec Roassal

Enfin, on peut utiliser Roassal2 (ou Roassal3 dans Pharo 9) pour créer une visualisation personnalisée. Il est possible d'utiliser des visualisations prédéfinies provenant de Moose, telles que la carte d'imbrication des systèmes :

voir := RTView nouveau.
FAMIXSystemNestingMap nouveau
  Voir les espaces de noms : (mooseModel tous les espaces de noms sélectionner : [ :chacun | chacun allClasses toutSatisfait : [ :c | c isStub pas ] ])
  mise en valeur : {}
  onRaw : vue.
voir

Ou toute autre visualisation de Roassal !

Ressources

Plus ...

Retour haut de page