Pest Plugin

https://github.com/pestphp/pest-plugin
Admin
Pest Plugin is a Composer plugin that manages plugin discovery and instantiation for the Pest...
Tokens:14,435
Snippets:111
Trust Score:9.6
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Example: resolving the command provider

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Shows how to instantiate the Manager and iterate over its capabilities to find the CommandProvider, then get its commands (e.g., DumpCommand).

```php
use Pest\Plugin\Manager;

$capabilities = (new Manager())->getCapabilities();

foreach ($capabilities as $capabilityClass => $implClass) {
    // Composer\Plugin\Capability\CommandProvider => Pest\Plugin\PestCommandProvider
    if (is_a($capabilityClass, \Composer\Plugin\Capability\CommandProvider::class, true)) {
        $provider = new $implClass();
        $commands = $provider->getCommands(); // [DumpCommand]
    }
}
```

--------------------------------

### Programmatic activation and plugin dump

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Example showing how to create a Composer instance and call `activate()` followed by `registerPlugins()` to regenerate `vendor/pest-plugins.json`.

```php
use Composer\Factory;
use Composer\IO\NullIO;
use Pest\Plugin\Manager;

$io = new NullIO();
$composer = (new Factory())->createComposer($io);

$manager = new Manager();
$manager->activate($composer, $io);
$manager->registerPlugins(); // regenerates vendor/pest-plugins.json
```

--------------------------------

### Install dependencies with composer install

Source: https://github.com/pestphp/pest-plugin/blob/5.x/CONTRIBUTING.md

Installs the project's dev dependencies after cloning the fork.

```bash
composer install
```

--------------------------------

### Error handling: running without a Composer instance

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/dump-command.md

Shows that calling `run()` without a Composer instance throws a `RuntimeException` with message 'Could not get Composer\Composer instance.' The example catches it and prints a message.

```php
use Pest\Plugin\Commands\DumpCommand;
use Symfony\Component\Console\Input\ArrayInput;
use Symfony\Component\Console\Output\NullOutput;

$command = new DumpCommand();
// note: setComposer() was never called

try {
    $command->run(new ArrayInput([]), new NullOutput);
} catch (\RuntimeException $e) {
    // "Could not get Composer\Composer instance."
    echo "Dump skipped: {$e->getMessage()}\n";
}
```

--------------------------------

### Defensive cleanup with uninstall

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Example showing safe uninstall when the cache file is missing. The `file_exists` guard makes the operation idempotent, so no exception is thrown for a missing file.

```php
use Composer\Factory;
use Composer\IO\NullIO;
use Pest\Plugin\Manager;

$composer = (new Factory())->createComposer(new NullIO());
$manager = new Manager();

// Safe even when vendor/pest-plugins.json was already removed:
try {
    $manager->uninstall($composer, new NullIO());
} catch (\Throwable $e) {
    // never thrown for a missing cache file — the existence check
    // keeps uninstall idempotent
}
```

--------------------------------

### Example: inspecting the subscription

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Shows how to call Manager::getSubscribedEvents() from a build script to check if the 'post-autoload-dump' event is registered. Outputs a message if the event exists.

```php
use Pest\Plugin\Manager;

$events = Manager::getSubscribedEvents();
// ['post-autoload-dump' => 'registerPlugins']

if (isset($events['post-autoload-dump'])) {
    echo "Pest plugin cache regenerates on every autoload dump\n";
}
```

--------------------------------

### Activate and deactivate Manager

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Example lifecycle completeness check: activates the manager, then deactivates it. The deactivate call is a no-op and intentionally keeps the plugin cache file.

```php
use Composer\Factory;
use Composer\IO\NullIO;
use Pest\Plugin\Manager;

$composer = (new Factory())->createComposer(new NullIO());
$io = new NullIO();

$manager = new Manager();
$manager->activate($composer, $io);
$manager->deactivate($composer, $io); // no-op; cache file intentionally kept

```

--------------------------------

### Handling missing or corrupt plugin cache

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/loader.md

Demonstrates that `getPlugins()` returns an empty array when the cache file is missing or contains invalid JSON. The example shows both scenarios and confirms no exception is thrown.

```php
use Pest\Plugin\Loader;

// Scenario 1: vendor/pest-plugins.json does not exist yet
// (composer install with the plugin active normally creates it)
$plugins = Loader::getPlugins(MyInterface::class);
if ($plugins === []) {
    error_log('No plugins implementing MyInterface were found (cache missing or invalid JSON).');
}

// Scenario 2: the cache file contains garbage — same safe result:
file_put_contents('vendor/pest-plugins.json', 'this is { not json');
$plugins = Loader::getPlugins(MyInterface::class); // still [], no exception
```

--------------------------------

### Wiring through Composer's capability contract

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/pest-command-provider.md

Demonstrates wiring PestCommandProvider through Composer's capability contract, as Manager does. It retrieves the capability map, checks for the CommandProvider capability, instantiates the provider class, gets the commands, and registers them with a Symfony console application.

```php
use Pest\Plugin\Manager;
use Pest\Plugin\PestCommandProvider;
use Composer\Plugin\Capability\CommandProvider;

$manager = new Manager();
$capabilityMap = $manager->getCapabilities();

if (isset($capabilityMap[CommandProvider::class])) {
    /** @var class-string<PestCommandProvider> $providerClass */
    $providerClass = $capabilityMap[CommandProvider::class];

    $provider = new $providerClass();
    $commands = $provider->getCommands();

    // Register them with a Symfony console application:
    foreach ($commands as $command) {
        $application->add($command);
    }
}
```

--------------------------------

### Catch RuntimeException from DumpCommand

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/errors.md

Catch the RuntimeException thrown by DumpCommand when no Composer instance is set. The message is "Could not get Composer\Composer instance." and the fix is to call setComposer() before run().

```php
use Pest\Plugin\Commands\DumpCommand;
use Symfony\Component\Console\Input\ArrayInput;
use Symfony\Component\Console\Output\NullOutput;

$command = new DumpCommand();

try {
    $command->run(new ArrayInput([]), new NullOutput);
} catch (\RuntimeException $e) {
    // "Could not get Composer\Composer instance."
    // fix: inject a Composer instance first — $command->setComposer($composer);
}
```

--------------------------------

### Generated pest-plugins.json cache file

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/configuration.md

Example content of the generated pest-plugins.json cache file. This file is written to <vendor-dir>/pest-plugins.json by DumpCommand and contains a pretty-printed JSON array of plugin class strings.

```json
[
    "Vendor\\Plugin\\PluginClass",
    "Pest\\Plugins\\OfficialPlugin"
]
```

--------------------------------

### Invoke Manager::registerPlugins() after activation

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Example invoking the flow Composer triggers after every autoload dump. Creates a Composer instance and activates the Manager before calling registerPlugins(), then checks for the generated plugin cache file.

```php
use Composer\Factory;
use Composer\IO\NullIO;
use Pest\Plugin\Manager;

$io = new NullIO();
$composer = (new Factory())->createComposer($io);

$manager = new Manager();
$manager->activate($composer, $io);
$manager->registerPlugins();

if (file_exists('vendor/pest-plugins.json')) {
    echo "Plugin cache written\n";
}

```

--------------------------------

### Reload plugins after cache file change with Loader::reset()

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/loader.md

Example usage of `Loader::reset()` to force a re-read of the cache file after it changes at runtime. The snippet shows calling `getPlugins()` before and after a build step that rewrites `vendor/pest-plugins.json`, with `reset()` in between to clear the static state. Requires the `Pest\Plugin\Loader` class and an interface like `MyInterface::class`.

```php
use Pest\Plugin\Loader;

$before = Loader::getPlugins(MyInterface::class);

// ... a build step rewrites vendor/pest-plugins.json ...

Loader::reset(); // force re-read on next call
$after = Loader::getPlugins(MyInterface::class);
```

--------------------------------

### activate method signature

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Signature of the `activate` method, a Composer lifecycle hook invoked on every `composer install`/`update`. Stores the Composer instance for later use by `registerPlugins()`.

```php
public function activate(Composer $composer, IOInterface $io): void
```

--------------------------------

### Basic usage of Loader::getPlugins()

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/loader.md

Shows how to retrieve plugins implementing a specific interface and iterate over them. Any interface can be used, such as Pest's plugin contracts or one from your own plugin package.

```php
use Pest\Plugin\Loader;

// Any interface can be used — e.g. one of Pest's plugin contracts or
// an interface shipped by your own plugin package:
$plugins = Loader::getPlugins(AddsCustomBehavior::class);

foreach ($plugins as $plugin) {
    $plugin->customHook();
}
```

--------------------------------

### Basic usage: programmatic dump with real Composer instance

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/dump-command.md

Shows how to instantiate `DumpCommand`, set a Composer instance, and run the command programmatically. The command writes to `vendor/pest-plugins.json` and returns exit code 0.

```php
use Composer\Factory;
use Composer\IO\NullIO;
use Pest\Plugin\Commands\DumpCommand;
use Symfony\Component\Console\Input\ArrayInput;
use Symfony\Component\Console\Output\NullOutput;

$composer = (new Factory())->createComposer(new NullIO());

$command = new DumpCommand();
$command->setComposer($composer);

$exitCode = $command->run(new ArrayInput([]), new NullOutput);
// $exitCode === 0; vendor/pest-plugins.json now contains all
// extra.pest.plugins classes from installed + root packages
```

--------------------------------

### configure() method signature and implementation

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/dump-command.md

Defines the command name and description for the `pest:dump-plugins` command. No arguments or options are defined. This method is protected and invoked by the Symfony console framework.

```php
protected function configure(): void
```

```php
$this->setName('pest:dump-plugins')
    ->setDescription('Dump all installed Pest plugins to the plugin cache.');
```

--------------------------------

### registerPlugins(): void

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Registers the plugin by executing the DumpCommand to write the plugin cache file. This is the event callback for post-autoload-dump.

```APIDOC
## `registerPlugins(): void`

### Description
Registers the plugin by constructing and executing the `DumpCommand` to (re)write the plugin cache file. This is the event callback for `post-autoload-dump`.

### Method
`registerPlugins`

### Signature
```php
public function registerPlugins(): void
```

### Parameters
None.

### Returns
`void`

### Throws
`RuntimeException` if no Composer instance is available (propagates from `DumpCommand::execute()`).

### Example
```php
use Composer\Factory;
use Composer\IO\NullIO;
use Pest\Plugin\Manager;

$io = new NullIO();
$composer = (new Factory())->createComposer($io);

$manager = new Manager();
$manager->activate($composer, $io);
$manager->registerPlugins();

if (file_exists('vendor/pest-plugins.json')) {
    echo "Plugin cache written\n";
}
```
```

--------------------------------

### Basic usage of PestCommandProvider

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/pest-command-provider.md

Shows basic usage of PestCommandProvider: instantiate it, call getCommands() to retrieve the list of commands, and iterate to print each command's name. The comment indicates the returned array contains a DumpCommand instance and the command name is 'pest:dump-plugins'.

```php
use Pest\Plugin\PestCommandProvider;

$provider = new PestCommandProvider();
$commands = $provider->getCommands(); // [Pest\Plugin\Commands\DumpCommand]

foreach ($commands as $command) {
    echo $command->getName() . "\n"; // pest:dump-plugins
}
```

--------------------------------

### getCapabilities()

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Instance method that declares the Composer command-provider capability, mapping CommandProvider to PestCommandProvider, enabling the pest:dump-plugins command.

```APIDOC
## `getCapabilities()`

### Description
Instance method that declares the Composer command-provider capability, mapping the `Composer\Plugin\Capability\CommandProvider` capability to the `Pest\Plugin\PestCommandProvider` class, exposing the `pest:dump-plugins` command.

### Method
`getCapabilities`

### Signature
```php
public function getCapabilities()
```

### Parameters
None.

### Returns
`array<class-string, class-string>` - Mapping of capability class to implementing class. In this case, `[CommandProvider::class => PestCommandProvider::class]`.

### Throws
None.

### Example
```php
use Pest\Plugin\Manager;

$capabilities = (new Manager())->getCapabilities();

foreach ($capabilities as $capabilityClass => $implClass) {
    // Composer\Plugin\Capability\CommandProvider => Pest\Plugin\PestCommandProvider
    if (is_a($capabilityClass, \Composer\Plugin\Capability\CommandProvider::class, true)) {
        $provider = new $implClass();
        $commands = $provider->getCommands(); // [DumpCommand]
    }
}
```
```

--------------------------------

### getCapabilities() return array

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Returns the capability mapping that associates CommandProvider::class with PestCommandProvider::class, exposing the 'pest:dump-plugins' command to Composer's CLI.

```php
return [
    CommandProvider::class => PestCommandProvider::class,
];
```

--------------------------------

### Handle Loader::getPlugins() returning empty array

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/errors.md

Handle the silent empty-array return from Loader::getPlugins(). No try/catch is needed because the API cannot throw; guard against empty results and check the cache file to distinguish between no matching plugins and a missing/corrupt cache.

```php
use Pest\Plugin\Loader;

$plugins = Loader::getPlugins(AddsOutput::class);

// no try/catch needed — the API cannot throw; guard empties explicitly:
if ($plugins === []) {
    // either genuinely no matching plugins, or the cache is missing/corrupt.
    // Distinguish by checking the cache file yourself:
    if (! file_exists('vendor/pest-plugins.json')) {
        // run `composer pest:dump-plugins` (or a plain composer install) to rebuild
    }
}
```

--------------------------------

### Private helper getPluginInstances() signature

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/loader.md

Signature of the private static helper `getPluginInstances()` in `src/Loader.php` (lines 58–108). It performs the lazy load: computes the cache path, guards on `self::$loaded`, reads the file, decodes with `JSON_THROW_ON_ERROR`, sorts the class list (official `Pest\Plugins\*` plugins last), instantiates each class via the container, and stores the result in `self::$instances`. Not part of the public API; documented only to explain internals.

```php
private static function getPluginInstances(): array
```

--------------------------------

### Run unit tests with composer test:unit

Source: https://github.com/pestphp/pest-plugin/blob/5.x/CONTRIBUTING.md

Runs unit tests for the project.

```bash
composer test:unit
```

--------------------------------

### getCapabilities() method signature

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Declares the public method getCapabilities() that implements Composer\Plugin\Capable. It returns an array mapping the capability class to the implementing class.

```php
public function getCapabilities()
```

--------------------------------

### registerPlugins() method signature

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Method signature for Manager::registerPlugins(), the event callback for 'post-autoload-dump'. Constructs a DumpCommand, injects the Composer instance captured by activate(), and executes it synchronously, (re)writing the plugin cache file. If activate() was never called, the dump may throw a RuntimeException.

```php
public function registerPlugins(): void

```

--------------------------------

### Run all tests with composer test

Source: https://github.com/pestphp/pest-plugin/blob/5.x/CONTRIBUTING.md

Runs all tests for the project.

```bash
composer test
```

--------------------------------

### Loader::getPlugins

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/loader.md

Documentation for the static method Loader::getPlugins, which returns a list of plugin instances implementing a given interface.

```APIDOC
## `getPlugins(string $interface): array`

### Description
Returns an array of pest plugins to execute. The method filters plugins by the given interface and returns a re-indexed list of plugin instances.

### Method
`Loader::getPlugins` (static method)

### Signature
`public static function getPlugins(string $interface): array`

### Parameters
- **$interface** (string) - Required - Fully-qualified class/interface name used as the `instanceof` filter; only plugins implementing it are returned.

### Returns
`array<int, object>` - a re-indexed (`array_values`) list of plugin instances that are `instanceof $interface`. Order follows the cache file order after sorting; plugins are instantiated once per process.

### Behavior Details
- Missing cache file → `[]` (empty result, no error)
- `file_get_contents()` returning `false` → `[]`
- Malformed JSON → `[]`; decoding uses `json_decode($content, false, 512, JSON_THROW_ON_ERROR)` and the `JsonException` is caught and swallowed
- Instances are sorted with `usort` before instantiation: official Pest plugins (`str_starts_with($plugin, 'Pest\\Plugins\\')`) are pushed *after* third-party plugins; other pairs keep relative order
- Each class is resolved through `Pest\Support\Container::getInstance()->get($class)`
- The result is cached in `Loader::$instances`; subsequent calls in the same process do not re-read the file

### Throws
None. All I/O and JSON failure paths degrade to an empty list.

### Example - Basic Usage
```php
use Pest\Plugin\Loader;

// Any interface can be used — e.g. one of Pest's plugin contracts or
// an interface shipped by your own plugin package:
$plugins = Loader::getPlugins(AddsCustomBehavior::class);

foreach ($plugins as $plugin) {
    $plugin->customHook();
}
```

### Example - Handling Missing or Corrupt Cache
```php
use Pest\Plugin\Loader;

// Scenario 1: vendor/pest-plugins.json does not exist yet
// (composer install with the plugin active normally creates it)
$plugins = Loader::getPlugins(MyInterface::class);
if ($plugins === []) {
    error_log('No plugins implementing MyInterface were found (cache missing or invalid JSON).');
}

// Scenario 2: the cache file contains garbage — same safe result:
file_put_contents('vendor/pest-plugins.json', 'this is { not json');
$plugins = Loader::getPlugins(MyInterface::class); // still [], no exception
```
```

--------------------------------

### CLI invocation: composer pest:dump-plugins

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/dump-command.md

The command is available from the terminal as `composer pest:dump-plugins`.

```bash
composer pest:dump-plugins
```

--------------------------------

### getPlugins() method signature with docblock

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/loader.md

The method signature for `getPlugins(string $interface): array` from `src/Loader.php` lines 30-46. It returns an array of plugin instances that implement the given interface.

```php
/**
 * returns an array of pest plugins to execute.
 *
 * @param  string  $interface  the interface for the hook to execute
 * @return array<int, object> list of plugins
 */
public static function getPlugins(string $interface): array
```

--------------------------------

### activate(Composer $composer, IOInterface $io): void

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Lifecycle hook invoked by Composer when the plugin is activated. Stores the Composer instance for later use by registerPlugins().

```APIDOC
## `activate(Composer $composer, IOInterface $io): void`

### Description
Lifecycle hook invoked by Composer when the plugin is activated (every `composer install`/`update`). Stores the `Composer` instance in `private $composer` for later use by `registerPlugins()`.

### Method
`activate`

### Signature
php
public function activate(Composer $composer, IOInterface $io): void


### Parameters
- `$composer` (Composer\Composer) - Required - The active Composer instance
- `$io` (Composer\IO\IOInterface) - Required - Console IO wrapper (currently unused by this method)

### Returns
`void`

### Throws
none

### Example
php
use Composer\Factory;
use Composer\IO\NullIO;
use Pest\Plugin\Manager;

$io = new NullIO();
$composer = (new Factory())->createComposer($io);

$manager = new Manager();
$manager->activate($composer, $io);
$manager->registerPlugins(); // regenerates vendor/pest-plugins.json

```

--------------------------------

### Lint code with composer lint

Source: https://github.com/pestphp/pest-plugin/blob/5.x/CONTRIBUTING.md

Checks the coding style of the project.

```bash
composer lint
```

--------------------------------

### execute() method signature

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/dump-command.md

The protected method signature for the command execution. It performs the dump operation: resolves Composer, collects plugin classes, and writes them to the cache file.

```php
protected function execute(InputInterface $input, OutputInterface $output): int
```

--------------------------------

### Resolve plugin cache file path

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/loader.md

This snippet shows how the cache file path is resolved: it uses the Composer binary dir (or falls back to <cwd>/vendor/bin) and appends '../pest-plugins.json', resulting in <vendor-dir>/pest-plugins.json.

```php
sprintf(
    '%s/../pest-plugins.json',
    $GLOBALS['_composer_bin_dir'] ?? getcwd() . '/vendor/bin',
)
```

--------------------------------

### getSubscribedEvents() method signature

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Declares the static method getSubscribedEvents() that implements Composer\EventDispatcher\EventSubscriberInterface. It returns an array mapping the 'post-autoload-dump' event to 'registerPlugins'.

```php
public static function getSubscribedEvents()
```

--------------------------------

### Declare plugin classes in composer.json

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/configuration.md

Declares plugin classes in a package's composer.json under the extra.pest.plugins key. This is the only user-facing configuration switch for registering Pest plugins. The key is required to register plugins and defaults to an empty array when absent.

```json
{
    "name": "yourvendor/your-plugin",
    "extra": {
        "pest": {
            "plugins": [
                "Vendor\\Plugin\\PluginClass"
            ]
        }
    }
}
```

--------------------------------

### Manager class declaration (no constructor)

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Shows the class declaration with no explicit constructor, indicating it is instantiated with zero arguments by Composer via extra.class.

```php
// none declared — the class has no constructor, so no arguments
final class Manager implements Capable, EventSubscriberInterface, PluginInterface { ... }
```

--------------------------------

### uninstall(Composer $composer, IOInterface $io): void

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Lifecycle hook invoked by Composer when the package is uninstalled. Deletes the cache file at vendor-dir/pest-plugins.json if it exists.

```APIDOC
## `uninstall(Composer $composer, IOInterface $io): void`

### Description
Lifecycle hook invoked by Composer when the package is uninstalled. Resolves the configured vendor directory via `$composer->getConfig()->get('vendor-dir')` and deletes the cache file at `<vendor-dir>/pest-plugins.json` — but only if it exists (`file_exists` guard, so a missing file is not an error).

### Method
`uninstall`

### Signature
php
public function uninstall(Composer $composer, IOInterface $io): void


### Parameters
- `$composer` (Composer\Composer) - Required - The active Composer instance; its `vendor-dir` config determines the cache location
- `$io` (Composer\IO\IOInterface) - Required - Console IO wrapper (unused)

### Returns
`void`

### Throws
none

### Example
php
use Composer\Factory;
use Composer\IO\NullIO;
use Pest\Plugin\Manager;

$composer = (new Factory())->createComposer(new NullIO());
$manager = new Manager();

// Safe even when vendor/pest-plugins.json was already removed:
try {
    $manager->uninstall($composer, new NullIO());
} catch (\Throwable $e) {
    // never thrown for a missing cache file — the existence check
    // keeps uninstall idempotent
}

```

--------------------------------

### Loader::reset(): void

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/loader.md

Clears the static loading state, forcing the next getPlugins() call to re-read and re-parse the cache file. Useful when the cache file changes at runtime.

```APIDOC
## `reset(): void`

### Description
Clears the static loading state: sets `Loader::$loaded = false` and `Loader::$instances = []`. The next `getPlugins()` call re-reads and re-parses the cache file.

### Method
`reset` (static method)

### Signature
```php
public static function reset(): void
```

### Parameters
None.

### Returns
`void`

### Throws
None.

### Example
```php
use Pest\Plugin\Loader;

$before = Loader::getPlugins(MyInterface::class);

// ... a build step rewrites vendor/pest-plugins.json ...

Loader::reset(); // force re-read on next call
$after = Loader::getPlugins(MyInterface::class);
```
```

--------------------------------

### getCommands() method signature

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/pest-command-provider.md

Declares the getCommands() method that returns an array of DumpCommand instances. The docblock indicates the return type as array<int, DumpCommand>.

```php
/**
 * @return array<int, DumpCommand>
 */
public function getCommands(): array
```

--------------------------------

### getSubscribedEvents() return array

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Returns the static event map that associates the Composer event 'post-autoload-dump' with the callback method 'registerPlugins'.

```php
return [
    'post-autoload-dump' => 'registerPlugins',
];
```

--------------------------------

### Loader::reset() method signature

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/loader.md

Signature of the public static method `reset()` in `src/Loader.php` (lines 47–53). It clears the static loading state by setting `Loader::$loaded = false` and `Loader::$instances = []`, so the next `getPlugins()` call re-reads and re-parses the cache file. Takes no parameters, returns `void`, and throws nothing.

```php
public static function reset(): void
```

--------------------------------

### Check types with composer test:types

Source: https://github.com/pestphp/pest-plugin/blob/5.x/CONTRIBUTING.md

Checks types in the codebase.

```bash
composer test:types
```

--------------------------------

### getSubscribedEvents()

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Static method that returns the event subscriptions for the plugin, mapping the 'post-autoload-dump' Composer event to the 'registerPlugins' callback.

```APIDOC
## `getSubscribedEvents()`

### Description
Static method that returns the event subscriptions for the plugin, mapping Composer's 'post-autoload-dump' event to the 'registerPlugins' callback on this class.

### Method
`getSubscribedEvents`

### Signature
```php
public static function getSubscribedEvents()
```

### Parameters
None.

### Returns
`array<string, string>` - Mapping of event name to callback method. In this case, `['post-autoload-dump' => 'registerPlugins']`.

### Throws
None.

### Example
```php
use Pest\Plugin\Manager;

$events = Manager::getSubscribedEvents();
// ['post-autoload-dump' => 'registerPlugins']

if (isset($events['post-autoload-dump'])) {
    echo "Pest plugin cache regenerates on every autoload dump\n";
}
```
```

--------------------------------

### PLUGIN_CACHE_FILE constant

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Defines the filename of the plugin cache file, written into the Composer vendor directory. Referenced by DumpCommand and Manager::uninstall().

```php
public const PLUGIN_CACHE_FILE = 'pest-plugins.json';
```

--------------------------------

### uninstall method signature

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Signature of the `uninstall` method, a Composer lifecycle hook invoked when the package is uninstalled. Deletes the cache file at `<vendor-dir>/pest-plugins.json` if it exists.

```php
public function uninstall(Composer $composer, IOInterface $io): void
```

--------------------------------

### Register plugin class via extra.class

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/configuration.md

Registers the plugin class that Composer instantiates for pestphp/pest-plugin itself. Uses the Composer-standard extra.class mechanism to activate the package.

```json
"extra": {
    "class": "Pest\\Plugin\\Manager"
}
```

--------------------------------

### deactivate(Composer $composer, IOInterface $io): void

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Lifecycle hook invoked by Composer when the plugin is deactivated. The body is empty; no cleanup is performed at deactivation time.

```APIDOC
## `deactivate(Composer $composer, IOInterface $io): void`

### Description
Lifecycle hook invoked by Composer when the plugin is deactivated. The body is empty; no cleanup is performed at deactivation time.

### Method
`deactivate`

### Signature
```php
public function deactivate(Composer $composer, IOInterface $io): void {}
```

### Parameters
- `$composer` (`Composer\Composer`) - Required - The active Composer instance (unused)
- `$io` (`Composer\IO\IOInterface`) - Required - Console IO wrapper (unused)

### Returns
`void`

### Throws
None.

### Example
```php
use Composer\Factory;
use Composer\IO\NullIO;
use Pest\Plugin\Manager;

$composer = (new Factory())->createComposer(new NullIO());
$io = new NullIO();

$manager = new Manager();
$manager->activate($composer, $io);
$manager->deactivate($composer, $io); // no-op; cache file intentionally kept
```
```

--------------------------------

### deactivate() method signature

Source: https://github.com/pestphp/pest-plugin/blob/5.x/_autodocs/api-reference/manager.md

Method signature for Manager::deactivate(), a lifecycle hook invoked by Composer on deactivation. The body is empty, so no cleanup is performed at deactivation time.

```php
public function deactivate(Composer $composer, IOInterface $io): void {}

```
Tokens:
Raw