Ausführen von IntelliJ-Inspektionen via Continuous Integration

Ausführen von IntelliJ-Inspections aus Continuous Integration

IntelliJ IDEA bietet Funktionen, die uns beim Schreiben von Code innerhalb der IDE als Intentions unterstützen. Intentions können im Batch-Modus verwendet werden, um den gesamten Quellcode auf bestimmte Muster zu prüfen, und lassen sich sogar auf die Befehlszeilenanalyse ausweiten oder in Continuous Integration integrieren. Dieser Beitrag behandelt die Standardfunktionen von IntelliJ sowie deren Erweiterung durch benutzerdefinierte Intentions, die mit Sensei erstellt wurden.

‍

IntelliJ-Inspections

Die Inspections-Funktion von IntelliJ steuert die Anzeige vieler Fehler, die während des Codierens dynamisch in der IDE gemeldet werden, z. B.:

• Erkennen abstrakter Klassen, die in Interfaces umgewandelt werden können,
• Identifizieren redundanter Klassenfelder, die lokal sein könnten,
• Warnungen bei der Verwendung veralteter Methoden,
• usw.

Diese Inspections heben übereinstimmenden Code in der IDE als Intention Actions hervor, die häufig über einen zugehörigen QuickFix verfügen.

Die Echtzeit-Hervorhebung in der IDE bei Übereinstimmungen mit einer Inspection hilft uns, unseren Code dynamisch zu verbessern. Nachdem das Problem im Code identifiziert wurde, kann die Verwendung von IntelliJ Intention Actions zur schnellen Korrektur (QuickFix) dazu beitragen, bessere Muster zu verinnerlichen.

Inspections-Profil

Inspections können als Batch-Prozess innerhalb der IDE, über die Befehlszeile oder in einem Continuous-Integration-Prozess ausgeführt werden.

Der Schlüssel zur Arbeit mit IntelliJ-Inspections im Batch-Modus ist die Verwendung eines Inspections-Profils.

IntelliJ verfügt über zwei Standard-Inspections-Profile: eines, das im Projekt gespeichert ist, und eines, das in der IDE gespeichert ist.

Neue Inspections-Profile können erstellt werden, um spezifische Plugins oder Anwendungsfälle zu konfigurieren, z. B.:

• Nur Checkstyle-Echtzeit-Scan ausführen
• Einen bestimmten Satz von Sensei-Regeln ausführen
• HTML-Prüfungen ausführen
  

Die Inspections in einem Profil können in den IntelliJ-Einstellungen aktiviert oder deaktiviert werden. Das Einstellungsmenü ist zudem eine einfache Möglichkeit, die Bandbreite der verfügbaren Inspections kennenzulernen.

Über das „Werkzeug“-Symbol können Sie ein Profil duplizieren und ein neues Profil erstellen, um eine spezifische Gruppe von Regeln zusammenzustellen.

Ausführen eines Inspections-Profils in der IDE

Inspektionsprofile können innerhalb der IDE über das Menü `Analyze \ Inspect Code...` ausgeführt werden.

Die Analysefunktion ermöglicht es Ihnen, den Umfang festzulegen, für den die Inspektion ausgeführt werden soll, z. B. für das gesamte Projekt, unter Ein- oder Ausschluss von Testquellen oder für eine bestimmte Auswahl an Dateien.

Sie können die Inspektionsprofile auch von hier aus verwalten, um ein bestimmtes Profil zu erstellen oder zu konfigurieren.

Ein Klick auf [OK] im Dialog „Specify Inspection Scope“ veranlasst IntelliJ dazu, alle ausgewählten Inspektionen des Profils über den definierten Bereich hinweg auszuführen.

IntelliJ zeigt die Ergebnisse der Inspektionsläufe im Tab `Inspection Results` an.

Das Sensei-Plugin von Secure Code Warrior ermöglicht es Ihnen, eigene Rezepte für den Code-Abgleich zu erstellen. Sensei ist eng in IntelliJ integriert, sodass sich diese benutzerdefinierten Rezepte genauso natürlich verwenden lassen wie die Intention Actions von IntelliJ. Das bedeutet, sie werden als Inspektionen in IntelliJ geladen und können über Inspektionsprofile gruppiert, aktiviert oder deaktiviert werden. Das Erstellen eines benutzerdefinierten Inspektionsprofils und die anschließende Nutzung der Funktion „Analyze Inspect Code“ ist die empfohlene Methode, um Sensei-Rezepte projektweit in einem Durchgang auszuführen.

Ausführen eines Inspektionsprofils über die Befehlszeile

IntelliJ bietet die Möglichkeit, Inspektionen über die Befehlszeile auszuführen, wie von JetBrains dokumentiert:

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

Ich verwende hauptsächlich macOS und kann eine einzelne Instanz von IntelliJ über die Befehlszeile wie folgt starten:

open -na "IntelliJ IDEA CE.app"

Um die Ausführung zu vereinfachen, füge ich dies einem Shell-Skript hinzu.

vi /usr/local/bin/idea

Der Inhalt des Skripts stammt aus der offiziellen Dokumentation von IntelliJ.

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

Anschließend habe ich die Datei ausführbar gemacht, um den Inspektionsprozess über die Befehlszeile zu vereinfachen.

chmod 755 /usr/local/bin/idea

Die offizielle IntelliJ-Dokumentation beschreibt die allgemeine Form des Inspektionsbefehls wie folgt:

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

In der Praxis verwende ich die vollständigen Pfade und benötige keine weiteren Optionen:

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

Dies führt alle Inspektionen aus, die ich dem `senseiprofile` hinzugefügt habe, und speichert die Ergebnisse im Ordner `scan-results`.

Inspektionsergebnisse anzeigen

Wir können diese Ergebnisse, wie wir später sehen werden, direkt aus der Continuous Integration heraus melden.

Wir können sie auch direkt in IntelliJ über die Funktion `Analyse \ View Offline Inspection Results…` betrachten.

Dadurch werden die Ergebnisse in den Tab `Inspection Results` geladen.

Dies ist offiziell auf der JetBrains-Website dokumentiert:

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

Dies kann während eines Code-Reviews nützlich sein, falls die Befehlszeilenausführung in einen Continuous-Integration-Prozess integriert wurde und die Reviewer den vollständigen Quellkontext eines der Inspektionsergebnisse prüfen möchten.

Inspektionsprofile in der Continuous Integration

Wenn wir die Befehlszeilen-Inspektion in die Continuous Integration einbinden, möchten wir idealerweise, dass ein Bericht automatisch generiert wird. Hierfür stehen uns verschiedene Optionen zur Verfügung.

TeamCity bietet eine integrierte Unterstützung für Inspektionsprofile in der Continuous Integration.

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

Das Jenkins Warnings NG-Plugin unterstützt die Befehlszeilenausgabe von IntelliJ-Inspektionen als eines der Berichtsformate.

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

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

Es gibt Community-Projekte wie `idea CLI Inspector`, die den Einsatz von Inspektionsprofilen in anderen CI-Tools unterstützen, z. B.:

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

Die Zukunft von Inspektionsprofilen in CI-Prozessen sieht durch die Einführung des JetBrains Qodana-Projekts noch vielversprechender aus. Qodana ist eine Headless-Version von IntelliJ mit offiziellen GitHub Actions und Docker-Images.

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

Qodana befindet sich derzeit in der Beta-Phase, wird jedoch vom Sensei-Team genau beobachtet, damit es zu einer offiziell unterstützten Plattform für die Ausführung von Sensei-Regeln im Rahmen der Continuous Integration wird.

Zusammenfassung

Intention Actions ermöglichen es uns, Codierungsmuster zu festigen und Fehler direkt in der IDE schnell zu beheben, sobald sie beim Programmieren auftreten.

Mit Inspection Profiles können wir diese in Profilen zusammenfassen, die als „Code analysieren und prüfen“-Aktion im Batch-Modus ausgeführt werden können. Dies ist hilfreich, wenn wir auf ein Muster stoßen und sicherstellen möchten, dass wir es an keiner anderen Stelle im Code übersehen haben.

Inspection Profiles können über die Befehlszeile ausgeführt und sogar in Continuous-Integration-Prozesse integriert werden, um ein „Vertrauen, aber prüfen“-Modell zu unterstützen und versehentliche Abweichungen abzufangen.

All dies ist eine integrierte IntelliJ-Funktionalität, und JetBrains verbessert seine Continuous-Integration-Prozesse kontinuierlich durch die Einführung von Qodana.

Sensei-Rezepte werden in IntelliJ geladen, um als native Intention Actions zu fungieren. Sie können in Inspection Profiles zusammengefasst werden, um Batch-Prüfungen via „Inspect Code“ sowie die durch die offizielle JetBrains-Befehlszeilenfunktion unterstützte Continuous Integration zu ermöglichen.

---

Sie können Sensei direkt in IntelliJ installieren: Gehen Sie dazu auf „Einstellungen > Plugins“ (Mac) bzw. „Einstellungen > Plugins“ (Windows) und suchen Sie einfach nach „sensei secure code“.

Wenn Sie ein Projekt in IntelliJ über die Befehlszeile ausführen möchten, finden Sie das in diesem Beitrag verwendete Projekt im Repository `sensei-blog-examples` im GitHub-Account von Secure Code Warrior. Eine kleine Übung für Sie: Erstellen Sie ein Profil, das ausschließlich die Sensei-Regeln ausführt. Probieren Sie es aus:

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

Erfahren Sie mehr über Sensei