PHP Structure Discoverer

https://github.com/spatie/php-structure-discoverer
Admin
Automatically discover classes, interfaces, enums, and traits within your PHP application with...
Tokens:8,189
Snippets:85
Trust Score:10
License:MIT
Update:7 months ago
Show doc for...
Tokens:
Raw
### Install PHP Structure Discoverer

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Instructions for installing the spatie/php-structure-discoverer package using Composer and publishing configuration for Laravel applications.

```bash
composer require spatie/php-structure-discoverer

php artisan vendor:publish --tag="structure-discoverer-config"
```

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

### Discover Classes Implementing an Interface (PHP)

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

This snippet demonstrates how to use the Discover facade to find all classes within a specified directory that implement a particular interface. It leverages the 'in', 'classes', 'implementing', and 'get' methods for targeted discovery. The 'Arrayable' interface is used as an example.

```php
use Spatie\StructureDiscoverer\Discover;

// PostModel::class, Collection::class, ...
Discover::in(__DIR__)->classes()->implementing(Arrayable::class)->get();
```

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

### Install Spatie PHP Structure Discoverer (Bash)

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

This command installs the spatie/php-structure-discoverer package using Composer. It is the standard method for adding the package to a PHP project.

```bash
composer require spatie/php-structure-discoverer
```

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

### Discover Structures in Directories

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Demonstrates how to use the Discover::in() static method to specify directories for scanning PHP structures. It shows examples for scanning a single directory and multiple directories, returning an array of discovered structure names.

```php
use Spatie\StructureDiscoverer\Discover;

// Discover in a single directory
$structures = Discover::in(__DIR__)->get();
// Returns: ['App\Models\User', 'App\Models\Post', 'App\Enums\Status', ...]

// Discover in multiple directories
$structures = Discover::in(
    app_path('Models'),
    app_path('Enums'),
    app_path('Services')
)->get();
// Returns: ['App\Models\User', 'App\Enums\UserStatus', 'App\Services\PaymentService', ...]
```

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

### Discovering PHP structures by directory and type

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

Basic usage of the Discover class to scan directories for specific PHP structures like classes, interfaces, enums, or traits. The get() method returns an array of fully qualified class names (FQCN).

```php
Discover::in(__DIR__)->get();
Discover::in(app_path('models'), app_path('enums'))->get();
Discover::in(__DIR__)->classes()->get();
Discover::in(__DIR__)->interfaces()->get();
Discover::in(__DIR__)->enums()->get();
Discover::in(__DIR__)->traits()->get();
```

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

### Enable Parallel Discovery in PHP

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

This PHP code snippet enables parallel processing for discovering structures. This significantly speeds up the discovery process in applications with many files by utilizing multiple processes. Ensure `amphp/parallel` is installed via composer.

```php
Discover::in(__DIR__)->parallel()->get();
```

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

### Implement a Custom Cache Driver Interface in PHP

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

This PHP code defines the interface for a custom cache driver. Implementing this interface allows you to create your own caching strategies beyond the provided file or Laravel cache drivers. It outlines the required methods for cache management: has, get, put, and forget.

```php
interface DiscoverCacheDriver
{
    public function has(string $id): bool;

    public function get(string $id): array;

    public function put(string $id, array $discovered): void;

    public function forget(string $id): void;
}
```

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

### Discover Only Enums

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Demonstrates filtering for PHP 8.1+ enum definitions using the ->enums() method. It includes an example of using ->full() to retrieve detailed metadata about the enums, such as their backing type and implemented interfaces.

```php
use Spatie\StructureDiscoverer\Discover;

// Find all enums in your application
$enums = Discover::in(app_path('Enums'))
    ->enums()
    ->get();
// Returns: ['App\Enums\OrderStatus', 'App\Enums\PaymentMethod', 'App\Enums\UserRole']

// Get full enum metadata including backing type
$enumsWithMetadata = Discover::in(app_path('Enums'))
    ->enums()
    ->full()
    ->get();
// Returns DiscoveredEnum objects with type (Unit, String, Int), implements, attributes
```

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

### Run Project Tests

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

Executes the test suite for the package using Composer.

```bash
composer test
```

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

### Configure Reflection Parser

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

Enables the faster ReflectionStructureParser for discovery. Requires setting the base path and optional root namespace.

```php
Discover::in(__DIR__)
   ->useReflection(
      basePath: '/path/to/project/root',
      rootNamespace: null
   )
   ->get();

// Laravel example
Discover::in(__DIR__)
   ->useReflection(basePath: base_path())
   ->get();
```

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

### Publish Laravel Configuration (Bash)

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

This command publishes the configuration file for the spatie/php-structure-discoverer package in a Laravel project. This allows for customization of ignored files, scout directories, and cache settings.

```bash
php artisan vendor:publish --tag="structure-discoverer-config"
```

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

### Retrieve Full Structure Information

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

Demonstrates how to configure the discovery process to return detailed DiscoveredStructure objects instead of simple strings.

```php
Discover::in(__DIR__)->full()->get();
```

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

### Use a Structure Scout with Caching in PHP

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

This code demonstrates how to instantiate and use a structure scout that has caching configured. The first call will perform the discovery and cache the results, while subsequent calls will retrieve data directly from the cache, significantly improving performance.

```php
EnumsStructureScout::create()->get();
```

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

### PHP Structure Discoverer Configuration (PHP)

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

This is the default configuration file for the spatie/php-structure-discoverer package. It defines ignored files, directories to search for structure scouts, and cache driver settings. The configuration can be customized after publishing.

```php
return [
    /*
     *  A list of files that should be ignored during the discovering process.
     */
    'ignored_files' => [

    ],

    /**
     * The directories where the package should search for structure scouts
     */
    'structure_scout_directories' => [
        app_path(),
    ],

    /*
     *  Configure the cache driver for discoverers
     */
    'cache' => [
        'driver' => \Spatie\StructureDiscoverer\Cache\LaravelDiscoverCacheDriver::class,
        'store' => null,
    ]
];
```

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

### Configure Reflection Parser for Structure Discovery

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Switches the discovery engine from the default token parser to PHP's Reflection API. This method is generally faster but may be less robust depending on the codebase structure.

```php
use Spatie\StructureDiscoverer\Discover;

// Use reflection parser (faster but less robust)
$structures = Discover::in(app_path())
    ->useReflection(
        basePath: base_path(),
        rootNamespace: null
    )
    ->classes()
    ->get();

// Laravel default configuration
$structures = Discover::in(app_path())
    ->useReflection(basePath: base_path())
    ->get();
```

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

### Use Inline Caching Without Structure Scouts in PHP

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

This PHP code demonstrates how to apply caching directly within a discovery call without using a separate structure scout class. It specifies an identifier for the cache and provides a file-based cache driver. Note that warming up these inline caches in production is not supported.

```php
Discover::in(__DIR__)
   ->withCache(
      'Some identifier',
      new FileDiscoverCacheDriver('/path/to/temp/directory')
   )
    ->get();
```

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

### Implement Reusable Cached Discovery with StructureScout

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

StructureScout allows for defining reusable and cacheable discovery logic. It supports custom cache drivers and provides methods to check, refresh, or clear cached discovery results.

```php
use Spatie\StructureDiscoverer\Discover;
use Spatie\StructureDiscoverer\StructureScout;
use Spatie\StructureDiscoverer\Cache\DiscoverCacheDriver;
use Spatie\StructureDiscoverer\Cache\FileDiscoverCacheDriver;
use Illuminate\Database\Eloquent\Model;

class ModelsStructureScout extends StructureScout
{
    protected function definition(): Discover
    {
        return Discover::in(app_path('Models'))
            ->classes()
            ->extending(Model::class);
    }

    public function cacheDriver(): DiscoverCacheDriver
    {
        return new FileDiscoverCacheDriver(storage_path('framework/cache'));
    }
}

// Usage
$models = ModelsStructureScout::create()->get();

if (ModelsStructureScout::create()->isCached()) {
    echo "Using cached results";
}

ModelsStructureScout::create()->cache();
ModelsStructureScout::create()->clear();
```

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

### Combining conditions with AND/OR logic

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

Chain multiple conditions to perform AND operations, or use the any() method combined with ConditionBuilder to perform OR operations. This enables complex filtering logic.

```php
Discover::in(__DIR__)->classes()->implementing(Arrayable::class)->get();

Discover::in(__DIR__)->any(
    ConditionBuilder::create()->classes(),
    ConditionBuilder::create()->enums()
)->get();
```

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

### Retrieve full structure metadata with full() in PHP

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Using the full() method returns detailed metadata objects (DiscoveredClass or DiscoveredEnum) instead of simple FQCN strings. This provides access to properties like file path, modifiers, attributes, and inheritance details.

```php
$classes = Discover::in(app_path('Models'))
    ->classes()
    ->full()
    ->get();

foreach ($classes as $class) {
    echo "Name: {$class->name}\n";
    echo "FQCN: {$class->getFcqn()}\n";
}
```

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

### Applying custom discovery conditions

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

Use custom logic to filter structures by passing a closure or a class that extends DiscoverCondition. This allows for fine-grained control over which structures are included.

```php
Discover::in(__DIR__)->custom(fn(DiscoveredStructure $structure) => $structure->namespace === 'App')->get();

class AppDiscoverCondition extends DiscoverCondition {
    public function satisfies(DiscoveredStructure $discoveredData): bool {
        return $structure->namespace === 'App';
    }
};

Discover::in(__DIR__)->custom(new AppDiscoverCondition())->get();
```

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

### Warm Structure Scout Caches in Production (PHP)

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

This PHP code snippet shows how to pre-cache structure scouts for all defined directories. This is typically run during production deployment to ensure that the first access to discovered structures is fast. It requires the path to the directory containing the structure scouts.

```php
StructureScoutManager::cache([__DIR__]);
```

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

### Discover structures by direct interface implementation using implementingWithoutChain()

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Filters for structures that directly implement an interface. Unlike the standard implementing() method, this ignores the inheritance chain.

```php
use Spatie\StructureDiscoverer\Discover;
use App\Contracts\PaymentGateway;

$gateways = Discover::in(app_path('Services/Payment'))
    ->classes()
    ->implementingWithoutChain(PaymentGateway::class)
    ->get();
```

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

### Laravel Configuration for Structure Discoverer

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

This PHP code snippet shows the configuration file for the Spatie Structure Discoverer package within a Laravel application. It allows customization of ignored files, directories to search for StructureScout classes, and cache settings, including the driver and store.

```php
// config/structure-discoverer.php
return [
    // Files to ignore during discovery
    'ignored_files' => [
        app_path('Legacy/OldModel.php'),
        app_path('Deprecated'),
    ],

    // Directories to search for StructureScout classes
    'structure_scout_directories' => [
        app_path(),
        app_path('Domain'),
    ],

    // Cache configuration
    'cache' => [
        'driver' => \Spatie\StructureDiscoverer\Cache\LaravelDiscoverCacheDriver::class,
        'store' => null, // Uses default cache store
        // 'store' => 'redis', // Or specify a specific store
    ],
];
```

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

### Discover Only Traits

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Explains how to use the ->traits() method to filter discovery results, specifically retrieving only trait definitions from the scanned directories.

```php
use Spatie\StructureDiscoverer\Discover;

// Find all traits in your application
$traits = Discover::in(app_path('Traits'))
    ->traits()
    ->get();
// Returns: ['App\Traits\HasUuid', 'App\Traits\Auditable', 'App\Traits\SoftDeletes']
```

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

### Discover Only Interfaces

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Illustrates how to use the ->interfaces() method to filter discovery results, returning only interface definitions found within the specified directories.

```php
use Spatie\StructureDiscoverer\Discover;

// Find all interfaces in the Contracts directory
$interfaces = Discover::in(app_path('Contracts'))
    ->interfaces()
    ->get();
// Returns: ['App\Contracts\PaymentGateway', 'App\Contracts\Notifiable', 'App\Contracts\Exportable']
```

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

### Configure File-Based Caching

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Implements file-based storage for discovered structures. Supports optional serialization and custom file naming for optimized performance.

```php
use Spatie\StructureDiscoverer\Cache\FileDiscoverCacheDriver;

$cache = new FileDiscoverCacheDriver(
    directory: '/tmp/discoverer-cache'
);

$cache = new FileDiscoverCacheDriver(
    directory: storage_path('cache'),
    serialize: false
);

$cache->has('my-cache-id');
$cache->get('my-cache-id');
$cache->put('my-cache-id', $data);
$cache->forget('my-cache-id');
```

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

### Discover Classes Extending a Parent

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Shows how to find classes that extend a specific parent class or implement multiple parent classes using the ->extending() method. This includes indirect inheritance and supports OR conditions for multiple parent types.

```php
use Spatie\StructureDiscoverer\Discover;
use Illuminate\Database\Eloquent\Model;

// Find all Eloquent models
$models = Discover::in(app_path())
    ->classes()
    ->extending(Model::class)
    ->get();
// Returns: ['App\Models\User', 'App\Models\Post', 'App\Models\Comment']
// Includes classes that extend Model indirectly (e.g., User extends Authenticatable extends Model)

// Find classes extending multiple possible parents (OR condition)
$controllers = Discover::in(app_path('Http/Controllers'))
    ->classes()
    ->extending(Controller::class)
    ->get();
```

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

### Combine conditions with exact() in PHP

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

The exact() method allows for explicit AND logic when combining multiple discovery conditions. This is useful for creating complex filtering queries where multiple criteria must be met simultaneously.

```php
use Spatie\StructureDiscoverer\Discover;
use Spatie\StructureDiscoverer\Support\Conditions\ConditionBuilder;

$structures = Discover::in(app_path())
    ->any(
        ConditionBuilder::create()->exact(
            ConditionBuilder::create()->classes(),
            ConditionBuilder::create()->implementing(Arrayable::class)
        ),
        ConditionBuilder::create()->exact(
            ConditionBuilder::create()->enums(),
            ConditionBuilder::create()->implementing(Stringable::class)
        )
    )
    ->get();
```

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

### Combine conditions with OR logic using any()

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Groups multiple conditions together, returning structures that satisfy at least one of the provided conditions. Utilizes the ConditionBuilder for complex queries.

```php
use Spatie\StructureDiscoverer\Discover;
use Spatie\StructureDiscoverer\Support\Conditions\ConditionBuilder;

$classesAndEnums = Discover::in(app_path())
    ->any(
        ConditionBuilder::create()->classes(),
        ConditionBuilder::create()->enums()
    )
    ->get();
```

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

### Enable parallel processing with parallel() in PHP

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

The parallel() method utilizes the amphp/parallel library to scan files concurrently. This significantly reduces discovery time in large codebases by distributing the workload across multiple processes.

```php
$structures = Discover::in(app_path())
    ->classes()
    ->parallel(filesPerJob: 100)
    ->get();
```

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

### Configure Parallel Discovery File Scan Limit in PHP

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

This PHP code allows you to specify the number of files each parallel process will scan during structure discovery. By default, each process scans 50 files. Adjusting this value can optimize performance based on your application's file structure and system resources.

```php
Discover::in(__DIR__)->parallel(100)->get();
```

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

### Manage Caches via Laravel Artisan Commands

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Provides CLI commands to warm up or clear all registered StructureScout caches, typically used during deployment processes.

```bash
# Warm all StructureScout caches (run during deployment)
php artisan structure-scouts:cache

# Clear all StructureScout caches
php artisan structure-scouts:clear
```

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

### Add a Structure Scout Manually in PHP

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

This PHP code shows how to manually register a structure scout class with the `StructureScoutManager`. This is particularly useful for packages that cannot assume where user-defined structure scouts are located. It takes the fully qualified class name of the scout as an argument.

```php
StructureScoutManager::add(SettingsStructureScout::class);
```

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

### Discover structures by interface implementation using implementing()

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Finds classes, interfaces, or enums that implement a specific interface. This method traverses the inheritance chain to find matches.

```php
use Spatie\StructureDiscoverer\Discover;
use Illuminate\Contracts\Support\Arrayable;

$arrayables = Discover::in(app_path())
    ->implementing(Arrayable::class)
    ->get();
```

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

### Cache Structure Scouts using Artisan Command (Laravel)

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

This bash command is used within a Laravel application to warm up all structure scout caches. It's typically executed during deployment to ensure fast access to discovered structures. This command scans directories configured for structure scouts.

```bash
php artisan structure-scouts:cache
```

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

### Define a Caching Structure Scout in PHP

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

This code defines a custom structure scout that utilizes caching. It specifies the discovery definition and configures a file-based cache driver with a specified directory. This is useful for optimizing repeated discovery operations.

```php
class EnumsStructureScout extends StructureScout
{
    protected function definition(): Discover|DiscoverConditionFactory
    {
        return Discover::in(__DIR__)->enums();
    }

    public function cacheDriver(): DiscoverCacheDriver
    {
        return new FileDiscoverCacheDriver('/path/to/temp/directory');
    }
}
```

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

### Manage Multiple Scouts with StructureScoutManager

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Provides a centralized way to trigger cache and clear operations across multiple StructureScout instances simultaneously.

```php
use Spatie\StructureDiscoverer\Support\StructureScoutManager;

$cachedScouts = StructureScoutManager::cache([
    app_path(),
    app_path('Domain'),
]);

$clearedScouts = StructureScoutManager::clear([
    app_path(),
]);

StructureScoutManager::add(\Package\Scouts\SettingsStructureScout::class);
```

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

### Discover classes by direct inheritance using extendingWithoutChain()

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Filters for classes that directly extend a specified parent class. This method ignores the inheritance chain, returning only immediate children.

```php
use Spatie\StructureDiscoverer\Discover;
use App\Models\BaseModel;

$directExtenders = Discover::in(app_path('Models'))
    ->classes()
    ->extendingWithoutChain(BaseModel::class)
    ->get();
```

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

### Enable inline caching with withCache() in PHP

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

The withCache() method enables persistent caching of discovery results. It requires a cache driver, such as FileDiscoverCacheDriver, to store results and improve performance on subsequent calls.

```php
use Spatie\StructureDiscoverer\Discover;
use Spatie\StructureDiscoverer\Cache\FileDiscoverCacheDriver;

$structures = Discover::in(app_path('Models'))
    ->classes()
    ->withCache(
        'eloquent-models',
        new FileDiscoverCacheDriver('/tmp/discoverer-cache')
    )
    ->get();
```

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

### Discover structures by PHP attributes using withAttribute()

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Filters structures based on applied PHP 8 attributes. It is useful for finding specific components like commands or event listeners.

```php
use Spatie\StructureDiscoverer\Discover;
use App\Attributes\AsCommand;

$commands = Discover::in(app_path('Console/Commands'))
    ->classes()
    ->withAttribute(AsCommand::class)
    ->get();
```

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

### Configure Laravel Cache Integration

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Integrates with Laravel's native cache system to store discovered structures, allowing for distributed caching via drivers like Redis.

```php
use Spatie\StructureDiscoverer\Cache\LaravelDiscoverCacheDriver;

$cache = new LaravelDiscoverCacheDriver(
    prefix: 'my-app',
    store: 'redis'
);

// Configuration in config/structure-discoverer.php
return [
    'cache' => [
        'driver' => LaravelDiscoverCacheDriver::class,
        'store' => 'redis',
    ],
];
```

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

### Discover Only Classes

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Shows how to filter discovered structures to include only class definitions using the ->classes() method. It also demonstrates combining this filter with custom criteria and the ->full() option to retrieve detailed DiscoveredClass objects.

```php
use Spatie\StructureDiscoverer\Discover;

// Find all classes in the Models directory
$classes = Discover::in(app_path('Models'))
    ->classes()
    ->get();
// Returns: ['App\Models\User', 'App\Models\Post', 'App\Models\Comment']

// Combine with other conditions
$abstractClasses = Discover::in(__DIR__)
    ->classes()
    ->custom(fn($structure) => $structure->isAbstract)
    ->full()
    ->get();
// Returns DiscoveredClass objects for all abstract classes
```

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

### Disable Chain Resolution for Implementing in PHP

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

This PHP code demonstrates how to disable the automatic resolution of implemented interface chains during discovery. When disabled, only direct implementations of the specified interface will be found, not those inherited through intermediate implementing classes.

```php
Discover::in(__DIR__)->implementingWithoutChain(Request::class)
```

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

### Sort discovery results with sortBy() in PHP

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

The sortBy() method allows ordering discovered structures based on various file system attributes such as name, size, or modification time, leveraging Symfony Finder's sorting capabilities.

```php
use Spatie\StructureDiscoverer\Discover;
use Spatie\StructureDiscoverer\Enums\Sort;

$sorted = Discover::in(app_path())
    ->classes()
    ->sortBy(Sort::Name)
    ->get();

$recentlyModified = Discover::in(app_path())
    ->classes()
    ->sortBy(Sort::ModifiedTime, reverse: true)
    ->get();
```

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

### Filtering discovered structures

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

Apply filters to narrow down results based on specific criteria such as name, parent class, interface implementation, or attributes. These methods can be chained to refine the discovery process.

```php
Discover::in(__DIR__)->named('MyAwesomeClass')->get();
Discover::in(__DIR__)->extending(Model::class)->get();
Discover::in(__DIR__)->implementing(Arrayable::class)->get();
Discover::in(__DIR__)->withAttribute(Cast::class)->get();
```

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

### Define Discovered Structures

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

Data structures representing discovered PHP entities. These classes store metadata such as namespaces, inheritance chains, and attributes.

```php
class DiscoveredClass extends DiscoveredStructure
{
    public function __construct(
        string $name,
        string $file,
        string $namespace,
        public bool $isFinal,
        public bool $isAbstract,
        public bool $isReadonly,
        public ?string $extends,
        public array $implements,
        public array $attributes,
        public ?array $extendsChain = null,
        public ?array $implementsChain = null,
    ) {
    }
}

class DiscoveredInterface extends DiscoveredStructure
{
    public function __construct(
        string $name,
        string $file,
        string $namespace,
        public array $extends,
        public array $attributes,
        public ?array $extendsChain = null,
    ) {
    }
}

class DiscoveredEnum extends DiscoveredStructure
{
    public function __construct(
        public string $name,
        public string $namespace,
        public string $file,
        public DiscoveredEnumType $type,
        public array $implements,
        public array $attributes,
        public ?array $implementsChain = null,
    ) {
    }
}

class DiscoveredTrait extends DiscoveredStructure
{
    public function __construct(
        public string $name,
        public string $namespace,
        public string $file,
    ) {
    }
}
```

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

### Filter structures by name using named()

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Limits the discovery results to structures matching specific class or interface names. Supports single or multiple name arguments.

```php
use Spatie\StructureDiscoverer\Discover;

$structures = Discover::in(app_path())
    ->named('UserService', 'OrderService', 'PaymentService')
    ->get();
```

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

### Sorting discovered structures

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

Sort the resulting list of structures using the sortBy method and the Sort enum. Various sorting criteria are available, including name, size, type, and timestamps.

```php
use Spatie\StructureDiscoverer\Enums\Sort;

Discover::in(__DIR__)->sortBy(Sort::Name)->get();

Discover::in(__DIR__)->sortBy(Sort::Size);
Discover::in(__DIR__)->sortBy(Sort::Type);
Discover::in(__DIR__)->sortBy(Sort::Extension);
Discover::in(__DIR__)->sortBy(Sort::ChangedTime);
Discover::in(__DIR__)->sortBy(Sort::ModifiedTime);
Discover::in(__DIR__)->sortBy(Sort::AccessedTime);
Discover::in(__DIR__)->sortBy(Sort::CaseInsensitiveName);
```

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

### Clear Structure Scout Caches in Production (PHP)

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

This PHP code snippet demonstrates how to clear all cached structure scout data for specified directories. This is useful when structure definitions have changed and the cache needs to be invalidated. It requires the path to the directory containing the structure scouts.

```php
StructureScoutManager::clear([__DIR__]);
```

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

### Completely Disable Chain Resolution in PHP

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

This PHP code completely disables the resolution of class inheritance and interface implementation chains during discovery. This can improve performance by simplifying the discovery process, but it means that only direct relationships will be considered.

```php
Discover::in(__DIR__)->withoutChains()->extending(Request::class)->get();
```

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

### Disable Chain Resolution for Extending in PHP

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

This PHP code shows how to disable the automatic resolution of extended class chains during discovery. When this is disabled, only direct extensions of the specified class will be found, not those inherited through intermediate classes.

```php
Discover::in(__DIR__)->extendingWithoutChain(Request::class)
```

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

### Apply custom filtering logic using custom()

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Allows for advanced filtering using a closure or a custom DiscoverCondition class. This provides full control over the filtering criteria based on the DiscoveredStructure object.

```php
use Spatie\StructureDiscoverer\Discover;
use Spatie\StructureDiscoverer\Data\DiscoveredStructure;

$appStructures = Discover::in(app_path())
    ->custom(fn(DiscoveredStructure $structure) => str_starts_with($structure->namespace, 'App\\Services'))
    ->get();
```

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

### Exclude Files from Discovery

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

Allows developers to filter out specific files from the discovery process to improve performance or avoid unwanted structures.

```php
use Spatie\StructureDiscoverer\Discover;

// Ignore specific files
$structures = Discover::in(app_path())
    ->ignoreFiles(
        app_path('Models/LegacyUser.php'),
        app_path('Services/DeprecatedService.php')
    )
    ->classes()
    ->get();
```

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

### Clear Structure Scout Caches using Artisan Command (Laravel)

Source: https://github.com/spatie/php-structure-discoverer/blob/main/README.md

This bash command is used within a Laravel application to clear all cached structure scout data. It's useful when structure definitions have changed and the cache needs to be invalidated. This command removes cached data for structure scouts.

```bash
php artisan structure-scouts:clear
```

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

### Disable inheritance chain resolution with withoutChains() in PHP

Source: https://context7.com/spatie/php-structure-discoverer/llms.txt

The withoutChains() method disables automatic inheritance resolution. This improves performance by only identifying direct matches rather than recursively checking the entire inheritance tree.

```php
$structures = Discover::in(app_path())
    ->withoutChains()
    ->classes()
    ->extending(Model::class)
    ->get();
```
Tokens:
Raw