Laravels neues Ökosystem zur Code-Analyse – surveyor / ranger / roster

Vorstellung der drei Pakete (surveyor, ranger, roster), aus denen sich das von Laravel veröffentlichte Ökosystem für statische Analyse zusammensetzt. Erläutert wird das neue Toolset, das Paket- und Tool-Autoren kennen sollten – von der PHP-Code-Analyse bis zur Paketerkennung.

Dieser Artikel basiert auf den READMEs und dem Quellcode der GitHub-Repositories. Alle drei Pakete befinden sich in einer Beta-Phase vor dem offiziellen Release (Stand: April 2026).

surveyor, ranger und roster sind alle im Beta-Release. Vor der Version 1.0.0 kann sich die API ändern. Wägen Sie den Einsatz in der Produktion sorgfältig ab.

​

Aktueller Release-Stand (April 2026)

Paket	Aktuelles Release	Hinweis
laravel/roster	v0.5.1	in der composer.json von laravel/boost wird ^0.5.0 verlangt; im BoostServiceProvider wird Roster::scan(base_path()) ausgeführt
laravel/ranger	v0.1.12	die composer.json hängt von laravel/surveyor:^0.1.0 ab
laravel/surveyor	v0.1.9	Low-Level-Basis, die von ranger als Analyse-Fundament genutzt wird

​

Überblick

Anfang 2026 hat Laravel drei Pakete rund um Code-Analyse veröffentlicht. Sie lassen sich einzeln nutzen, bilden aber miteinander verbunden ein Code-Analyse-Ökosystem.

Paket	Rolle	Installation
laravel/surveyor	Engine zur statischen PHP-Code-Analyse	composer require laravel/surveyor
laravel/ranger	Introspektion der gesamten Laravel-Anwendung	composer require laravel/ranger
laravel/roster	Erkennung von Paketen des Ökosystems	composer require laravel/roster --dev

Sehen wir uns die Pakete der Reihe nach im Detail an.

---

​

laravel/surveyor – Engine für statische Analyse

laravel/surveyor ist ein Tool zur statischen Analyse, das PHP-Dateien parst und detaillierte Metainformationen zu Klassen, Methoden, Properties, Rückgabetypen usw. in strukturierter Form bereitstellt. Es ist darauf ausgelegt, diese Informationen so zu extrahieren, dass andere Tools und Pakete sie weiterverarbeiten können.

​

Installation

composer require laravel/surveyor

​

Grundlegende Verwendung

​

Eine Datei analysieren

use Laravel\Surveyor\Analyzer\Analyzer;

$analyzer = app(Analyzer::class);

// Analyse per Dateipfad
$result = $analyzer->analyze('/path/to/your/File.php');

// Zugriff auf den analysierten Scope
$scope = $result->analyzed();

// Zugriff auf das Ergebnis der Klasse
$classResult = $result->result();

​

Eine Klasse direkt analysieren

$result = $analyzer->analyzeClass(\App\Models\User::class);
$classResult = $result->result();

​

Informationen im ClassResult

$classResult = $analyzer->analyzeClass(App\Models\User::class)->result();

// Klasseninformationen
$name = $classResult->name();            // 'App\Models\User'
$namespace = $classResult->namespace();  // 'App\Models'
$filePath = $classResult->filePath();

// Vererbungsbeziehungen
$extends = $classResult->extends();
$implements = $classResult->implements();

// Methoden-Informationen
$method = $classResult->getMethod('store');
$returnType = $method->returnType();
$parameters = $method->parameters();
$rules = $method->validationRules(); // auch Validierungsregeln abrufbar

// Property-Informationen
$property = $classResult->getProperty('email');
$type = $property->type;
$visibility = $property->visibility; // 'public', 'protected', 'private'

// Liste öffentlicher Methoden und Properties
$publicMethods = $classResult->publicMethods();
$publicProperties = $classResult->publicProperties();

​

Typsystem

Surveyor bringt ein reichhaltiges Typsystem mit, mit dem sich PHP-Typen strukturiert handhaben lassen.

use Laravel\Surveyor\Types\Type;

// Verschiedene Typen erzeugen
$stringType = Type::string();
$intType = Type::int();
$boolType = Type::bool();
$nullType = Type::null();

// Union-Typ (z. B. string|null)
$unionType = Type::union(Type::string(), Type::null());

// Typprüfung
use Laravel\Surveyor\Types\StringType;

if (Type::is($returnType, StringType::class)) {
    // Verarbeitung für String-Typen
}

​

Cache-Konfiguration

Analyseergebnisse lassen sich cachen, um die Performance wiederholter Läufe zu verbessern.

use Laravel\Surveyor\Analyzer\AnalyzedCache;

// Disk-Cache aktivieren
AnalyzedCache::enableDiskCache(storage_path('surveyor-cache'));

// Cache leeren
AnalyzedCache::clear();

Die Konfiguration ist auch über Umgebungsvariablen möglich.

SURVEYOR_CACHE_ENABLED=true
SURVEYOR_CACHE_DIR=/path/to/cache

​

Analyse von Eloquent-Modellen

Surveyor versucht, eine Verbindung zur Datenbank aufzubauen, um Eloquent-Modelle gesondert zu analysieren. Auch Modell-Relationen, Attribute, Accessoren und Casts werden erkannt.

$result = $analyzer->analyzeClass(App\Models\User::class)->result();

// Datenbankattribute werden automatisch erkannt
$emailProperty = $result->getProperty('email');

// Relationsmethoden erkennen
$method = $result->getMethod('posts');
if ($method->isModelRelation()) {
    // Diese Methode ist eine Relation
}

Da Surveyor bei der Analyse von Eloquent-Modellen versucht, sich mit der Datenbank zu verbinden, handelt es sich nicht um eine rein statische Analyse. Performance und Speicherverbrauch werden aktuell verbessert; Beiträge sind willkommen.

---

​

laravel/ranger – High-Level-Introspektion

laravel/ranger ist eine High-Level-Bibliothek, die surveyor kapselt, eine Laravel-Anwendung als Ganzes durchläuft und Informationen zu Routen, Modellen, Enums, Broadcast-Events, Umgebungsvariablen, Inertia-Komponenten u. a. sammelt.

​

Installation

composer require laravel/ranger

​

Grundlegende Verwendung

Sie beschreiben in Callback-Form, was passieren soll, wenn eine Komponente entdeckt wird.

use Laravel\Ranger\Ranger;
use Laravel\Ranger\Components;
use Illuminate\Support\Collection;

$ranger = app(Ranger::class);

// Wird für jede gefundene Route aufgerufen
$ranger->onRoute(function (Components\Route $route) {
    echo $route->uri();
});

// Wird für jedes gefundene Modell aufgerufen
$ranger->onModel(function (Components\Model $model) {
    foreach ($model->getAttributes() as $name => $type) {
        // Verarbeitung von Attributnamen und Typ
    }
});

// Wird für jedes gefundene Enum aufgerufen
$ranger->onEnum(function (Components\Enum $enum) {
    //
});

// Wird für jedes gefundene Broadcast-Event aufgerufen
$ranger->onBroadcastEvent(function (Components\BroadcastEvent $event) {
    //
});

// Wird einmal aufgerufen, nachdem alle Routen gesammelt wurden
$ranger->onRoutes(function (Collection $routes) {
    //
});

// Wird einmal aufgerufen, nachdem alle Modelle gesammelt wurden
$ranger->onModels(function (Collection $models) {
    //
});

// Läuft die gesamte Anwendung durch und ruft die Callbacks aus
$ranger->walk();

​

Von Ranger gesammelte Komponenten

Collector	Beschreibung
Routes	alle registrierten Routen (URI, Parameter, HTTP-Methode, Controller, Validierungsregeln, Response)
Models	Eloquent-Modelle inkl. Attributen, Typen und Relationen
Enums	PHP-Backed-Enums (Enums mit Integer- oder String-Werten) und deren Cases/Werte
BroadcastEvents	Events, die ShouldBroadcast implementieren, samt Payload
BroadcastChannels	registrierte Broadcast-Channels
EnvironmentVariables	in der .env-Datei definierte Umgebungsvariablen
Inertia Shared Data	global geteilte Inertia.js-Props
Inertia Components	Inertia.js-Page-Komponenten und die erwarteten Props

---

​

laravel/roster – Tool zur Paketerkennung

laravel/roster ist ein Tool, das erkennt, welche Pakete des Laravel-Ökosystems in einem Projekt installiert sind. Paket- und Tool-Autoren können damit einfach Informationen wie „Nutzt dieses Projekt Inertia?” oder „Welche Livewire-Version?” abrufen.

​

Installation

composer require laravel/roster --dev

​

Grundlegende Verwendung

use Laravel\Roster\Roster;
use Laravel\Roster\Packages;

// Ein Verzeichnis scannen und Roster erhalten
$roster = Roster::scan($directory);

// Liste der installierten Pakete
$roster->packages();

// Nur Produktivpakete
$roster->packages()->production();

// Nur Entwicklungspakete
$roster->packages()->dev();

// Prüfen, ob ein bestimmtes Paket vorhanden ist
$roster->uses(Packages::INERTIA);        // bool
$roster->uses(Packages::LIVEWIRE);       // bool

// Mit Versionsbedingung prüfen
$roster->usesVersion(Packages::INERTIA, '2.0.0', '>=');   // Ist Inertia >= 2.0.0?
$roster->usesVersion(Packages::LIVEWIRE, '3.0.0', '>=');  // Ist Livewire >= 3.0.0?

// JavaScript-Paketmanager erkennen
$packageManager = $roster->nodePackageManager(); // 'npm', 'yarn', 'bun' o. Ä.

---

​

Reale Anwendungsfälle

​

Tool zur Generierung von KI-Guidelines (Boost)

Laravel Boost nutzt roster, um die installierte Paketkonstellation zu erfassen und die Generierung von Guidelines und Skills für KI-Agenten (GitHub Copilot, Claude usw.) automatisch anzupassen. Auf Basis von Informationen wie „Nutzt dieses Projekt Inertia?” oder „Ist Livewire installiert?” werden passende Guideline-Dateien ausgewählt und dem KI-Agenten bereitgestellt.

​

Einen Kompatibilitätsprüfer für Pakete bauen

Wenn Sie ein Paket entwickeln, dessen Verhalten von den im Nutzerprojekt installierten Paketen abhängt, ist roster äußerst hilfreich.

use Laravel\Roster\Roster;
use Laravel\Roster\Packages;

$roster = Roster::scan(base_path());

if ($roster->uses(Packages::INERTIA)) {
    // Verarbeitung für Inertia
    if ($roster->usesVersion(Packages::INERTIA, '2.0.0', '>=')) {
        // Verarbeitung für Inertia v2 oder höher
    }
}

if ($roster->uses(Packages::LIVEWIRE)) {
    // Verarbeitung für Livewire
}

// Installationsbefehl je nach JavaScript-Paketmanager anpassen
$pm = $roster->nodePackageManager();
echo "Run: {$pm} install your-package";

​

Automatische Generierung von Anwendungsdokumentation

Mit ranger lässt sich ein Tool bauen, das Routen, Modelle und Enums einer Laravel-Anwendung automatisch einsammelt und daraus Dokumentation erzeugt.

use Laravel\Ranger\Ranger;
use Laravel\Ranger\Components;

$ranger = app(Ranger::class);
$docs = [];

$ranger->onRoute(function (Components\Route $route) use (&$docs) {
    $docs['routes'][] = [
        'uri' => $route->uri(),
        // auch Validierungsregeln und Response-Typen der Route abrufbar
    ];
});

$ranger->onModel(function (Components\Model $model) use (&$docs) {
    $docs['models'][] = [
        'attributes' => $model->getAttributes(),
    ];
});

$ranger->walk();

// In $docs sind nun die Strukturinformationen der gesamten Anwendung gesammelt

---

​

Fazit

surveyor, ranger und roster bilden im Laravel-Ökosystem eine neue Grundlage für programmatische Code-Analyse.

Diese Pakete richten sich primär an Paket- und Tool-Autoren; Endnutzer verwenden sie nicht direkt. Sie werden jedoch aktiv innerhalb offizieller Laravel-Tools wie Laravel Boost genutzt, sodass ein weiterer Ausbau des Ökosystems zu erwarten ist.

laravel/surveyor

Engine für statische PHP-Code-Analyse

laravel/ranger

High-Level-Introspektions-Bibliothek

laravel/roster

Tool zur Paketerkennung