> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Het nieuwe code-analyse-ecosysteem van Laravel — surveyor / ranger / roster

> Een introductie van de drie pakketten (surveyor, ranger en roster) die samen het door Laravel gepubliceerde statische-analyse-ecosysteem vormen. Van PHP-codeanalyse tot pakketdetectie: de nieuwe tools die pakketontwikkelaars en toolauteurs moeten kennen.

<Info>
  Dit artikel is gebaseerd op de README's en broncode van de GitHub-repositories. Alle drie de pakketten zijn bètaversies van vóór de officiële release (stand: april 2026).
</Info>

<Warning>
  surveyor, ranger en roster zijn alle drie **in bètarelease**. De API's kunnen vóór de v1.0.0-release nog veranderen. Wees voorzichtig met het gebruik in productieomgevingen.
</Warning>

## Actuele releasestatus (april 2026)

| Pakket             | Laatste release | Toelichting                                                                                                                                    |
| ------------------ | --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| `laravel/roster`   | `v0.5.1`        | In de `composer.json` van `laravel/boost` wordt `^0.5.0` vereist, en in de `BoostServiceProvider` wordt `Roster::scan(base_path())` uitgevoerd |
| `laravel/ranger`   | `v0.1.12`       | Hangt in `composer.json` af van `laravel/surveyor:^0.1.0`                                                                                      |
| `laravel/surveyor` | `v0.1.9`        | De low-level laag die als analysebasis van `ranger` wordt gebruikt                                                                             |

## Overzicht

Laravel heeft begin 2026 drie pakketten gepubliceerd rond codeanalyse. Ze zijn ook los te gebruiken, maar vormen samen een onderling verbonden **code-analyse-ecosysteem**.

```mermaid theme={null}
graph TD
    A["laravel/roster<br>Pakketdetectie"] --> B["laravel/ranger<br>High-level introspectie"]
    B --> C["laravel/surveyor<br>Low-level statische-analyse-engine"]
    D["Boost<br>Tool voor AI-ontwikkelondersteuning"] --> A
    E["Tool- en pakketontwikkelaars"] --> A
    E --> B
    E --> C
```

| Pakket             | Rol                                    | Installatie                             |
| ------------------ | -------------------------------------- | --------------------------------------- |
| `laravel/surveyor` | Statische-analyse-engine voor PHP-code | `composer require laravel/surveyor`     |
| `laravel/ranger`   | Introspectie van de hele Laravel-app   | `composer require laravel/ranger`       |
| `laravel/roster`   | Detectie van ecosysteempakketten       | `composer require laravel/roster --dev` |

Laten we de details van elk pakket op volgorde bekijken.

***

## laravel/surveyor — de statische-analyse-engine

[laravel/surveyor](https://github.com/laravel/surveyor) is een statische-analysetool die PHP-bestanden parseert en gedetailleerde metadata over klassen, methoden, properties, returntypes en meer aanlevert in gestructureerde vorm. Het is gespecialiseerd in het extraheren van informatie in een vorm die andere tools en pakketten kunnen gebruiken.

### Installatie

```bash theme={null}
composer require laravel/surveyor
```

### Basisgebruik

#### Een bestand analyseren

```php theme={null}
use Laravel\Surveyor\Analyzer\Analyzer;

$analyzer = app(Analyzer::class);

// Analyseren op bestandspad
$result = $analyzer->analyze('/path/to/your/File.php');

// Toegang tot de geanalyseerde scope
$scope = $result->analyzed();

// Toegang tot het klasseresultaat
$classResult = $result->result();
```

#### Een klasse rechtstreeks analyseren

```php theme={null}
$result = $analyzer->analyzeClass(\App\Models\User::class);
$classResult = $result->result();
```

### Informatie die je uit een ClassResult haalt

```php theme={null}
$classResult = $analyzer->analyzeClass(App\Models\User::class)->result();

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

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

// Methode-informatie
$method = $classResult->getMethod('store');
$returnType = $method->returnType();
$parameters = $method->parameters();
$rules = $method->validationRules(); // ook validatieregels op te vragen

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

// Lijst van publieke methoden en properties
$publicMethods = $classResult->publicMethods();
$publicProperties = $classResult->publicProperties();
```

### Het typesysteem

Surveyor heeft een uitgebreid typesysteem waarmee je PHP-types gestructureerd kunt behandelen.

```php theme={null}
use Laravel\Surveyor\Types\Type;

// Verschillende types aanmaken
$stringType = Type::string();
$intType = Type::int();
$boolType = Type::bool();
$nullType = Type::null();

// Uniontypes (zoals string|null)
$unionType = Type::union(Type::string(), Type::null());

// Typecontrole
use Laravel\Surveyor\Types\StringType;

if (Type::is($returnType, StringType::class)) {
    // Verwerking van het stringtype
}
```

### Cacheconfiguratie

Je kunt analyseresultaten cachen om de prestaties bij herhaalde uitvoering te verbeteren.

```php theme={null}
use Laravel\Surveyor\Analyzer\AnalyzedCache;

// Diskcache inschakelen
AnalyzedCache::enableDiskCache(storage_path('surveyor-cache'));

// De cache wissen
AnalyzedCache::clear();
```

Configureren kan ook via omgevingsvariabelen.

```env theme={null}
SURVEYOR_CACHE_ENABLED=true
SURVEYOR_CACHE_DIR=/path/to/cache
```

### Analyse van Eloquent-modellen

Surveyor probeert verbinding te maken met de database en analyseert Eloquent-modellen speciaal. Ook relaties, attributen, accessors en casts van modellen worden gedetecteerd.

```php theme={null}
$result = $analyzer->analyzeClass(App\Models\User::class)->result();

// Databaseattributen worden automatisch gedetecteerd
$emailProperty = $result->getProperty('email');

// Bepalen of een methode een relatie is
$method = $result->getMethod('posts');
if ($method->isModelRelation()) {
    // Deze methode is een relatie
}
```

<Info>
  Omdat Surveyor bij het analyseren van Eloquent-modellen verbinding met de database probeert te maken, is het geen volledig statische analyse. Verder worden de prestaties en het geheugengebruik momenteel verbeterd; bijdragen zijn welkom.
</Info>

***

## laravel/ranger — high-level introspectie

[laravel/ranger](https://github.com/laravel/ranger) is een high-level bibliotheek die surveyor omhult en de hele Laravel-applicatie doorloopt om informatie te verzamelen over routes, modellen, enums, broadcast-events, omgevingsvariabelen, Inertia-componenten en meer.

### Installatie

```bash theme={null}
composer require laravel/ranger
```

### Basisgebruik

Je beschrijft in callbackvorm wat er moet gebeuren wanneer elk component wordt gevonden.

```php theme={null}
use Laravel\Ranger\Ranger;
use Laravel\Ranger\Components;
use Illuminate\Support\Collection;

$ranger = app(Ranger::class);

// Wordt aangeroepen telkens wanneer een route wordt gevonden
$ranger->onRoute(function (Components\Route $route) {
    echo $route->uri();
});

// Wordt aangeroepen telkens wanneer een model wordt gevonden
$ranger->onModel(function (Components\Model $model) {
    foreach ($model->getAttributes() as $name => $type) {
        // Verwerking van de attribuutnaam en het type
    }
});

// Wordt aangeroepen telkens wanneer een enum wordt gevonden
$ranger->onEnum(function (Components\Enum $enum) {
    //
});

// Wordt aangeroepen telkens wanneer een broadcast-event wordt gevonden
$ranger->onBroadcastEvent(function (Components\BroadcastEvent $event) {
    //
});

// Wordt één keer aangeroepen nadat alle routes zijn verzameld
$ranger->onRoutes(function (Collection $routes) {
    //
});

// Wordt één keer aangeroepen nadat alle modellen zijn verzameld
$ranger->onModels(function (Collection $models) {
    //
});

// De hele applicatie doorlopen en de callbacks afvuren
$ranger->walk();
```

### De componenten die Ranger verzamelt

| Collector                | Beschrijving                                                                                         |
| ------------------------ | ---------------------------------------------------------------------------------------------------- |
| **Routes**               | Alle geregistreerde routes (URI, parameters, HTTP-methoden, controllers, validatieregels, responses) |
| **Models**               | Eloquent-modellen met attributen, types en relaties                                                  |
| **Enums**                | Backed enums van PHP (enums met integer- of stringwaarden) met cases en waarden                      |
| **BroadcastEvents**      | Events die `ShouldBroadcast` implementeren, met payload                                              |
| **BroadcastChannels**    | Geregistreerde broadcastkanalen                                                                      |
| **EnvironmentVariables** | Omgevingsvariabelen gedefinieerd in het `.env`-bestand                                               |
| **Inertia Shared Data**  | Globaal gedeelde Inertia.js-props                                                                    |
| **Inertia Components**   | Inertia.js-paginacomponenten met de verwachte props                                                  |

***

## laravel/roster — pakketdetectietool

[laravel/roster](https://github.com/laravel/roster) is een tool die detecteert welke pakketten uit het Laravel-ecosysteem in een project zijn geïnstalleerd. Pakketontwikkelaars en toolauteurs kunnen zo eenvoudig informatie ophalen als "gebruikt dit project Inertia?" of "welke versie van Livewire?".

### Installatie

```bash theme={null}
composer require laravel/roster --dev
```

### Basisgebruik

```php theme={null}
use Laravel\Roster\Roster;
use Laravel\Roster\Packages;

// Een directory scannen en de Roster ophalen
$roster = Roster::scan($directory);

// Lijst van geïnstalleerde pakketten
$roster->packages();

// Alleen productiepakketten
$roster->packages()->production();

// Alleen dev-pakketten
$roster->packages()->dev();

// Controleren op de aanwezigheid van een specifiek pakket
$roster->uses(Packages::INERTIA);        // bool
$roster->uses(Packages::LIVEWIRE);       // bool

// Controleren met een versievoorwaarde
$roster->usesVersion(Packages::INERTIA, '2.0.0', '>=');   // Inertia 2.0.0 of hoger?
$roster->usesVersion(Packages::LIVEWIRE, '3.0.0', '>=');  // Livewire 3.0.0 of hoger?

// Detectie van de JavaScript-pakketbeheerder
$packageManager = $roster->nodePackageManager(); // 'npm', 'yarn', 'bun', enz.
```

***

## Praktische use-cases

### Tool voor het genereren van AI-richtlijnen (Boost)

[Laravel Boost](https://github.com/laravel/boost) gebruikt roster om de geïnstalleerde pakketconfiguratie in kaart te brengen en past daarmee het genereren van richtlijnen en skills voor AI-agents (zoals GitHub Copilot en Claude) automatisch aan. Op basis van informatie als "gebruikt dit project Inertia?" en "is Livewire aanwezig?" worden de juiste richtlijnbestanden geselecteerd en aan de AI-agent aangeboden.

```mermaid theme={null}
sequenceDiagram
    participant Boost as Laravel Boost
    participant Roster as laravel/roster
    participant AI as AI-agent
    Boost->>Roster: Roster::scan(base_path())
    Roster->>Boost: packages() [Inertia, Livewire, Pint...]
    Boost->>Boost: Richtlijnen per pakket selecteren
    Boost->>AI: Inertia-richtlijnen, Livewire-richtlijnen...
```

### Een pakketcompatibiliteitschecker bouwen

Ontwikkel je een pakket dat zijn gedrag aanpast aan de pakketten die in het project van de gebruiker zijn geïnstalleerd, dan is roster bijzonder nuttig.

```php theme={null}
use Laravel\Roster\Roster;
use Laravel\Roster\Packages;

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

if ($roster->uses(Packages::INERTIA)) {
    // Verwerking voor Inertia
    if ($roster->usesVersion(Packages::INERTIA, '2.0.0', '>=')) {
        // Verwerking voor Inertia v2 en hoger
    }
}

if ($roster->uses(Packages::LIVEWIRE)) {
    // Verwerking voor Livewire
}

// Het installatiecommando aanpassen aan de JavaScript-pakketbeheerder
$pm = $roster->nodePackageManager();
echo "Run: {$pm} install your-package";
```

### Automatisch applicatiedocumentatie genereren

Met ranger kun je tools bouwen die de routes, modellen en enums van een Laravel-app automatisch verzamelen en er documentatie van genereren.

```php theme={null}
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(),
        // ook validatieregels en responsetypes van de route op te vragen
    ];
});

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

$ranger->walk();

// In $docs is de structuurinformatie van de hele app verzameld
```

***

## Conclusie

surveyor, ranger en roster leveren een nieuw fundament voor **programmatische codeanalyse** binnen het Laravel-ecosysteem.

```mermaid theme={null}
graph LR
    A["surveyor<br>Parseert PHP-bestanden<br>Extraheert klassen, methoden en types"] --> B["ranger<br>Doorloopt de hele Laravel-app<br>Verzamelt routes, modellen en enums"]
    B --> C["roster<br>Detecteert geïnstalleerde pakketten<br>Controleert versies en soorten"]
```

Deze pakketten zijn vooral bedoeld voor pakketontwikkelaars en toolauteurs, niet voor rechtstreeks gebruik door eindgebruikers. Ze worden echter ook actief gebruikt binnen officiële Laravel-tools zoals Laravel Boost, en verdere uitbreiding van het ecosysteem is te verwachten.

<Columns cols={3}>
  <Card title="laravel/surveyor" icon="github" href="https://github.com/laravel/surveyor">
    Statische-analyse-engine voor PHP-code
  </Card>

  <Card title="laravel/ranger" icon="github" href="https://github.com/laravel/ranger">
    High-level introspectiebibliotheek
  </Card>

  <Card title="laravel/roster" icon="github" href="https://github.com/laravel/roster">
    Pakketdetectietool
  </Card>
</Columns>


## Related topics

- [Versiecompatibiliteit van packages beheren](/nl/advanced/package-versioning.md)
- [laravel/agent-skills — de officiële Laravel-collectie van AI-agentskills](/nl/blog/agent-skills-introduction.md)
- [Laravel-updates van april 2026](/nl/blog/changelog/202604.md)
- [Statische analyse van packages (PHPStan / Larastan)](/nl/advanced/package-static-analysis.md)
- [Blog](/nl/blog/index.md)