Bonjour à tous !

Le mois de septembre étant terminé, nous voulions profiter de l'occasion pour passer en revue les mises à jour les plus intéressantes que nous avons livrées pour Sensei au cours du mois de septembre. Vous pouvez également essayer Sensei en l'installant directement depuis le JetBrains Marketplace. 

Tags

Nous souhaitions offrir la possibilité d'ajouter des métadonnées personnalisées, que vous pouvez utiliser pour classer et regrouper les recettes. Nous۪ avons maintenant ajouté la possibilité d'ajouter des étiquettes aux recettes.
‍

Nos clients nous ont fait part de leur souhait de voir des indicateurs sur la façon dont les recettes sont utilisées, sans nécessairement révéler trop de choses sur les recettes dans les indicateurs. Les balises constituent une étape vers cet objectif, en fournissant aux équipes des mesures pertinentes pour piloter leurs programmes de qualité. 

‍

Navigateur variable

Lorsque vous créez une recette, il est très utile de comprendre comment sont structurés les éléments du code que vous faites correspondre, afin de faciliter la recherche. À cette fin, nous avons ajouté notre navigateur de variables dans l'éditeur de recettes à plusieurs endroits. Les variables affichées sont relatives à la cible sélectionnée. Cela vous aide à comprendre votre code et à élaborer une bonne recette avec moins d'efforts.
‍

Mise à jour du gestionnaire du livre de cuisine

Nous avons déplacé le gestionnaire de livres de cuisine dans un panneau au sein de l'IDE, plutôt que de faire apparaître une nouvelle fenêtre. Cela rend l'expérience de gestion des livres de cuisine beaucoup plus simple et fluide. Au lieu d'avoir à ouvrir la fenêtre, vous pouvez simplement la développer directement depuis votre barre latérale !

Essayez Sensei dès maintenant ! 

Sensei est disponible gratuitement sur le JetBrains Marketplace. Nous le développons et l'améliorons activement et nous attendons avec impatience de savoir comment vous l'intégrez dans votre processus de développement.

Dans cet article de blog, nous allons :

• Démonstration de la recherche et de la mise en correspondance d'annotations
• Annotations Amen à l'aide de modèles mustache

Sensei permet de faire correspondre les modèles de code problématiques et de les modifier en fonction des implémentations convenues. Dans cet exemple, j'utilise @Disabled sans paramètre comme modèle de code problématique.

Annotation de test désactivé

Les tests désactivés sans raison précise peuvent s'avérer problématiques à long terme, car nous oublions pourquoi nous les avons désactivés.

@Disabled
   void thisTestMethodHasNoDisabledReason(){
    Assertions.fail("This test is disabled and should not run");
    }

Le risque est qu'au fil du temps, la base de code évolue, que le test désactivé ne soit pas mis à jour en fonction de l'objectif du code et qu'il finisse par devenir redondant et non pertinent, voire qu'il ne soit jamais réactivé.

Lors des revues de code, nous soulignons souvent qu'il est judicieux d'ajouter une description explicative en tant que paramètre d'annotation.

@Disabled ("Disabled to demonstrate adding a reason")
    void thisTestMethodHasDisabledReason(){
   Assertions.fail("This test is disabled and should not run");
   }

Une recette Sensei

Nous pouvons écrire une recette pour détecter quand @Disabled est ajouté sans explication et une solution rapide qui nous rappelle d'ajouter la raison réelle expliquant pourquoi nous l'avons désactivé.

Lorsque je pense à ce que je vais faire, je dois le faire :

• correspond à l'annotation Disabled sans aucun paramètre
• modifiez l'annotation Disabled pour qu'elle contienne un paramètre avec le texte du marqueur "TODO : ajoutez une description ici"

Créer une recette d'alerte

J'utilise Alt+Enter pour créer une nouvelle recette.

Ajoutez ensuite le texte descriptif de base dans les informations générales.

En faisant de la règle un avertissement, tout code correspondant est mis en évidence mais n'apparaît pas comme une erreur flagrante.

Trouver l'annotation

Dans l'éditeur de recettes, je modifie la recherche pour qu'elle corresponde à une annotation.

Cela permet de mettre en évidence toutes les annotations dans l'aperçu.

Ceci fait, je souhaite filtrer sur le type d'annotation.

Je pourrais simplement utiliser Disabled, mais je qualifie complètement la classe avec le package afin qu'elle ne corresponde qu'à l'annotation de JUnit 5. Comme le code source est affiché dans la prévisualisation, je peux facilement copier et coller ce texte à partir du code réel afin d'éviter les fautes de frappe.

Je souhaite ensuite ne faire correspondre que les annotations sans paramètres, et je peux utiliser l'interface graphique pour ce faire.

c'est-à-dire la recherche :

search:
  annotation:
    type: "org.junit.jupiter.api.Disabled"
    without:
       parameters:
          - {}

Créer une action de réécriture rapide

Pour ma correction rapide, j'utiliserai une action de réécriture.

J'utilise la fonctionnalité Show Variables pour afficher les variables de Mustache et prévisualiser leur contenu.

J'ajoute ensuite le code supplémentaire nécessaire à la création du commentaire de marqueur de lieu.

c'est-à-dire QuickFix :

availableFixes:
 - name: "Add a todo comment parameter"
   actions:
   - rewrite:
      to: "{{{ . }}}(\"TODO: add a description here\")"
      target: "self"

Sensei en action

Nous avons créé une courte vidéo montrant le processus de création de recettes en action.

Résumé

Lors de l'élaboration d'un correctif rapide de réécriture, il est plus facile de rechercher l'élément de code que l'on souhaite réécrire, car il s'agit alors de l'entité propre sur laquelle on peut agir.

Dans cet exemple, j'ai utilisé une action de réécriture pour modifier l'annotation. La réécriture est une action à usage général qui peut s'appliquer à n'importe quel élément de code et constitue une bonne option par défaut à explorer.

Le plugin Sensei offre un moyen facile de trouver des modèles de code spécifiques dans votre code source, puis d'appliquer des règles de réécriture pour modifier le code correspondant. Le tout dans l'IDE Intellij, et en temps réel.

‍

‍

Par exemple, vous pourriez créer une règle qui s'applique aux annotations JUnit `@Disabled` qui n'ont pas de raison, Sensei vous indiquerait alors le problème en surlignant le code dans l'IDE.

De plus, lorsque vous `alt+enter`, vous pouvez avoir l'option `Ajouter un paramètre de commentaire à la tâche`.

Si vous sélectionnez cette option, le code sera modifié afin d'ajouter une raison type, que vous pourrez ensuite modifier, et si vous ne le faites pas, elle s'affichera dans votre panneau TODO.

Par exemple, `@Disabled` deviendrait ` @Disabled("TODO : ajoutez une description ici")`

Sensei combine les fonctionnalités d'un scanner de code d'analyse statique avec un moteur de réécriture de code.

Actions d'intention IntelliJ

Sur la base de la description ci-dessus, l'alternative évidente (si vous n'utilisez pas Sensei) est d'utiliser la fonctionnalité IntelliJ Intention Actions.

Sensei diffère des actions d'intention d'IntelliJ car l'objectif de Sensei est de fournir un moyen de créer des outils de mise en correspondance et de réécriture spécifiques à un projet, ou même locaux pour un développeur particulier.

Nous avons essayé de mettre en place une interface graphique qui facilite l'écriture et l'expérimentation des règles de correspondance et de réécriture.

Comment cela peut-il m'aider à m'améliorer personnellement ?

Lorsque j'apprends à utiliser une nouvelle bibliothèque, il me faut du temps pour développer une mémoire musculaire autour des méthodes et du formatage. Je peux donc choisir de créer des recettes personnelles qui

• créer un lien vers la documentation officielle ou les pages de tutoriel
• disposent de modèles types qui sont les plus efficaces
• corriger les mauvaises pratiques de codage
• ajouter du code de base pour faciliter l'utilisation d'une bibliothèque

Je peux utiliser Sensei pour créer des recettes temporaires qui m'incitent à utiliser les pratiques courantes que j'ai choisies et m'aident à créer des habitudes efficaces. Ces recettes sont temporaires, car je peux les supprimer lorsqu'elles ne sont plus adaptées à mes besoins.

Comment peut-il aider mon équipe à s'améliorer ?

De la même manière, nous pouvons aider les équipes à développer une mémoire musculaire autour de normes de codage convenues.

Créer des livres de recettes que nous appliquons lorsque nous trouvons les mêmes commentaires dans les revues de demandes d'extraction. Comme les livres de recettes sont stockés dans le contrôle de version avec le projet, ils sont disponibles pour tout le monde sur le projet. Et nous pouvons les désactiver lorsque nous n'avons plus besoin d'être guidés.

Sensei permet de fournir un retour d'information précoce

Ce que nous avons essayé de construire avec Sensei , c'est un moyen de tirer le retour d'information qui nous aide à nous améliorer, et des rappels d'actions correctives, aussi tôt que possible dans le processus de codage.

Plutôt que d'attendre

• les résultats d'un analyseur statique
• les commentaires d'un examen de code

Au lieu de cela, nous pouvons voir le retour d'information, pour les normes personnalisées que nous voulons mettre en œuvre, au fur et à mesure que nous codons.

Et nous disposons soit de rappels, soit de règles de réécriture, pour nous aider à écrire du code conforme aux normes.

Sensei est flexible

En ce sens, Sensei est un peu un mélange, puisqu'il s'agit de.. :

• partie Analyseur statique
• tuteur de codage
• moteur de réécriture

Sensei est suffisamment flexible pour rendre la tâche de dire "Qu'est-ce que Sensei?" un peu plus difficile.

Sensei comble une lacune dans le flux de travail de la programmation

Nous avons essayé de faire de Sensei la pièce manquante du flux de travail du programmeur qui vous aide à améliorer des éléments spécifiques de votre style de codage, ou de l'utilisation de la bibliothèque, avec laquelle vous et votre équipe travaillez actuellement.

Cette flexibilité signifie qu'il faut un peu plus de temps pour se familiariser avec Sensei qu'avec un outil d'analyse statique ou les intentions intégrées d'IntelliJ. Néanmoins, en prenant le temps d'expérimenter, vous découvrirez une nouvelle façon d'accélérer votre apprentissage dans le cadre de votre processus de développement personnel.

Comment expérimenter ?

Une fois que vous avez téléchargé et installé Sensei depuis le[Intellij Marketplace]

Le moyen le plus simple de mettre Sensei à votre service est d'examiner votre processus de codage et d'y réfléchir :

• Quelle est la documentation que vous recherchez en permanence ?
  -- Vous pourriez ajouter des recettes Sensei qui renvoient à cette documentation.
• Quelles sont les erreurs simples que vous continuez à commettre ?
  -- Vous pourriez codifier temporairement ce mauvais modèle de codage en tant que matcher, et écrire une réécriture rapide qui modifie le code pour qu'il corresponde à ce que vous voulez vraiment écrire.
• Quel code type écrivez-vous pour utiliser une bibliothèque ?
  -- Vous pouvez créer une règle Quick Fix pour écrire le code à votre place.

Puisque Sensei est conçu pour fonctionner en parallèle avec n'importe quel outil d'analyse statique que vous utilisez, si vous constatez que les mêmes violations sont signalées par l'analyse statique, vous pouvez reproduire la condition dans une recette Sensei . Vous pouvez ensuite ajouter une correction rapide pour vous aider à vous entraîner, non seulement à identifier l'erreur, mais aussi à passer rapidement à l'écriture du code correct

Exécuter les inspections IntelliJ à partir de l'intégration continue

IntelliJ IDEA offre des fonctionnalités pour aider à améliorer notre codage, au sein de l'IDE lorsque vous écrivez du code sous forme d'intentions. Les intentions peuvent être utilisées en batch pour inspecter le code à la recherche de modèles à travers la source et même s'étendre à l'analyse en ligne de commande ou être ajoutées à l'intégration continue. Cet article couvre les fonctionnalités d'IntelliJ et l'extension avec des Intentions personnalisées créées dans Sensei.

‍

IntelliJ Inspections

La fonction Inspections d'IntelliJ permet d'afficher la plupart des erreurs qui sont signalées dynamiquement dans l'IDE lors du codage, par exemple.

• détecter les classes abstraites qui peuvent être converties en interfaces,
• l'identification des champs de classe redondants qui peuvent être locaux,
• un avertissement concernant l'utilisation de méthodes obsolètes,
• etc.

Ces inspections mettent en évidence le code qui correspond dans l'IDE à des actions d'intention qui ont souvent un correctif rapide associé.

La mise en évidence en temps réel par l'IDE lorsque le code correspond à une inspection peut nous aider à améliorer notre codage de manière dynamique. Après avoir identifié le problème dans le code, l'utilisation des actions d'intention d'IntelliJ pour corriger rapidement le code peut renforcer les meilleurs modèles.

Profil d'inspection

Les inspections peuvent être exécutées par lots à partir de l'IDE, de la ligne de commande ou dans le cadre d'un processus d'intégration continue.

La clé pour travailler avec les inspections IntelliJ en tant que lot est l'utilisation d'un profil d'inspection.

IntelliJ a deux profils d'inspection par défaut : un stocké dans le projet, et un stocké dans l'IDE.

De nouveaux profils d'inspection peuvent être créés pour configurer des plugins ou des cas d'utilisation spécifiques.

• Exécutez uniquement l'analyse en temps réel de Checkstyle
• Exécutez un ensemble spécifique de règles Sensei
• Exécuter les contrôles HTML
  

Les inspections d'un profil peuvent être activées ou désactivées à partir des préférences d'IntelliJ. La boîte de dialogue Préférences est également un moyen facile de connaître la gamme d'inspections disponibles.

L'icône "outil" vous permet de dupliquer un profil et d'en créer un nouveau pour collecter un ensemble spécifique de règles.

Exécuter un profil d'inspection dans l'IDE

Les profils d'inspection peuvent être exécutés à partir de l'IDE en utilisant le menu `Analyze \ Inspect Code...`.

La fonctionnalité d'analyse vous permet de contrôler le champ d'application de l'inspection, par exemple l'ensemble du projet, y compris ou non les sources de test, ou un ensemble spécifique de fichiers. 

Vous pouvez également gérer les profils d'inspection à partir d'ici pour créer ou configurer un profil particulier.

En cliquant sur [OK] dans la boîte de dialogue "Specify Inspection Scope", IntelliJ lancera toutes les inspections sélectionnées dans le profil dans le périmètre défini.

IntelliJ va rapporter les résultats de l'exécution des inspections dans l'onglet `Inspection Results`.

Le plugin Sensei de Secure Code Warrior vous permet de créer des recettes de correspondance de code personnalisées. Sensei s'intègre étroitement à IntelliJ pour rendre ces recettes personnalisées aussi naturelles à utiliser que les actions d'intention d'IntelliJ. Cela signifie qu'elles sont chargées dans IntelliJ en tant qu'inspections et qu'elles peuvent être regroupées, activées et désactivées à l'aide de profils d'inspection. La création d'un profil d'inspection personnalisé et l'utilisation de la fonctionnalité Analyze Inspect Code est la méthode recommandée pour exécuter les recettes Sensei en masse dans un projet.

Exécution d'un profil d'inspection à partir de la ligne de commande

IntelliJ a la capacité d'exécuter des inspections à partir de la ligne de commande comme documenté par JetBrains :

- https://www.jetbrains.com/help/idea/working-with-the-ide-features-from-command-line.html

J'utilise principalement macOS, et je peux exécuter une seule instance d'IntelliJ à partir de la ligne de commande avec :

open -na "IntelliJ IDEA CE.app"

Pour faciliter l'exécution, je l'ajoute à un script de commande shell.

vi /usr/local/bin/idea

Le contenu du script provient de la documentation officielle fournie par IntelliJ.

#!/bin/sh
open -na "IntelliJ IDEA CE.app" --args "$@"

Je l'ai ensuite rendu exécutable afin de simplifier le processus d'inspection en ligne de commande.

chmod 755 /usr/local/bin/idea

La documentation officielle d'intellij décrit la forme générale de la commande d'inspection comme suit :

idea inspect <project> <inspection-profile> <output></output></inspection-profile></project>
[<options>]</options>

Dans la pratique, je qualifie pleinement les chemins et je n'ai besoin d'aucune option :

idea inspect /Users/user/GitHub/sensei-blog-examples /Users/user/GitHub/sensei-blog-examples/.idea/inspectionProfiles/senseiprofile.xml /Users/user/GitHub/sensei-blog-examples/scan-results

Ceci exécute toutes les inspections que j'ai ajoutées au `senseiprofile` et rapporte les résultats dans le dossier `scan-results`.

Visualisation des résultats de l'inspection

Nous pouvons rapporter ces résultats à partir de l'intégration continue, comme nous le verrons plus loin.

Nous pouvons également les visualiser dans IntelliJ lui-même en utilisant la fonction "Analyse \Voir les résultats de l'inspection hors ligne...\N".

Les résultats sont alors chargés dans l'onglet "Résultats de l'inspection".

Ceci est officiellement documenté sur le site de JetBrains :

- https://www.jetbrains.com/help/idea/command-line-code-inspector.html#inspection-results

Cela peut être utilisé au cours d'un processus d'examen du code si l'exécution de la ligne de commande a été incorporée dans un processus d'intégration continue et que les examinateurs souhaitent vérifier le contexte source complet de l'une des entrées du résultat de l'inspection.

Profils d'inspection dans l'intégration continue

Lorsque l'on ajoute l'inspection en ligne de commande à l'intégration continue, on souhaite idéalement qu'un rapport soit généré automatiquement et plusieurs options s'offrent à nous.

TeamCity offre une prise en charge immédiate des profils d'inspection dans l'intégration continue.

- https://www.jetbrains.com/help/teamcity/inspections.html

Le plugin Jenkins Warnings NG supporte la sortie de la ligne de commande d'IntelliJ Inspections comme l'un des formats de rapport.

- https://github.com/jenkinsci/warnings-ng-plugin

- https://github.com/jenkinsci/warnings-ng-plugin/blob/master/SUPPORTED-FORMATS.md

Des projets communautaires comme `idea CLI Inspector` existent pour supporter l'utilisation des profils d'inspection dans d'autres outils de CI, c'est-à-dire

- https://github.com/bentolor/idea-cli-inspector

L'avenir des profils d'inspection dans un processus de CI semble encore plus prometteur avec l'introduction du projet Qodana de JetBrains. Le projet Qodana est une version headless d'IntelliJ avec des actions Github officielles et des images Docker.

- https://github.com/JetBrains/Qodana

Qodana est actuellement en version bêta, mais l'équipe de Sensei la surveille afin qu'elle devienne une plateforme officiellement prise en charge pour l'exécution des règles Sensei dans le cadre de l'intégration continue.

Résumé

Les actions d'intention nous permettent de renforcer les modèles de codage et de les corriger rapidement dans l'IDE lorsque nous commettons des erreurs pendant le codage.

Les profils d'inspection nous permettent de les rassembler en profils qui peuvent être exécutés par lots en tant qu'action d'analyse et d'inspection du code. Cela peut s'avérer utile si nous rencontrons un modèle et que nous voulons vérifier si nous ne l'avons pas oublié ailleurs dans notre code.

Les profils d'inspection peuvent être exécutés à partir de la ligne de commande et même incorporés dans les processus d'intégration continue, ce qui permet d'appliquer le modèle "faire confiance, mais vérifier" et de détecter tout dérapage accidentel.

Tout ce qui précède est intégré dans les fonctionnalités d'IntelliJ et JetBrains améliore son processus d'intégration continue avec l'introduction de Qodana.

Sensei Les recettes sont chargées dans IntelliJ pour agir en tant qu'actions d'intention natives et être rassemblées dans des profils d'inspection pour prendre en charge la vérification par lots via Inspect Code et le support d'intégration continue fourni par la fonctionnalité officielle d'exécution en ligne de commande de JetBrains.

---

Vous pouvez installer Sensei à partir d'IntelliJ en utilisant "Preferences \ Plugins" (Mac) ou "Settings \ Plugins" (Windows) puis en recherchant simplement "sensei secure code".

Si vous voulez essayer d'exécuter un projet dans IntelliJ à partir de la ligne de commande, le projet utilisé dans ce billet peut être trouvé dans le dépôt `sensei-blog-examples` dans le compte GitHub Secure Code Warrior . Un exercice pour le lecteur est de créer un profil qui exécutera seulement les règles Sensei . Essayez-le :

https://github.com/securecodewarrior/sensei-blog-examples

En savoir plus sur Sensei