PHP-Scoper

https://github.com/humbug/php-scoper
Admin
PHP-Scoper is a tool designed to move any body of code, including its vendor dependencies, into a...
Tokens:55,697
Snippets:330
Trust Score:8.3
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Directory structure for PSR-0 example

Source: https://github.com/humbug/php-scoper/blob/main/docs/limitations.md

Shows the directory structure used in the PSR-0 partial support example. This structure is used to illustrate the issue where autoloading fails for the root file JsonMapper.php.

```text
src/
  JsonMapper.php
  JsonMapper/
    Exception.php
```

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

### Install PHP-Scoper Locally with Composer Bin Plugin

Source: https://github.com/humbug/php-scoper/blob/main/docs/installation.md

Installs PHP-Scoper as a project-local dependency using bamarni/composer-bin-plugin, then runs the php-scoper binary from vendor/bin.

```bash
$ composer require --dev bamarni/composer-bin-plugin
$ composer bin php-scoper require --dev humbug/php-scoper

$ vendor/bin/php-scoper
```

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

### Install PHP-Scoper Globally with Composer

Source: https://github.com/humbug/php-scoper/blob/main/docs/installation.md

Installs PHP-Scoper globally via Composer.

```bash
$ composer global require humbug/php-scoper
```

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

### Install production dependencies with Composer

Source: https://github.com/humbug/php-scoper/blob/main/README.md

Installs production dependencies only, skipping development dependencies. This saves time during the scoping process by not processing unnecessary files.

```bash
composer install --no-dev --prefer-dist
```

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

### Install PHP-Scoper with Phive

Source: https://github.com/humbug/php-scoper/blob/main/docs/installation.md

Installs PHP-Scoper using Phive, with the --force-accept-unsigned flag to accept unsigned PHARs.

```bash
$ phive install humbug/php-scoper --force-accept-unsigned
```

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

### Example class to be exposed

Source: https://github.com/humbug/php-scoper/blob/main/docs/configuration.md

A simple class in the Acme namespace that will be exposed and prefixed.

```php
<?php

namespace Acme;

class Foo {}
```

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

### Scoped version of the unknown third-party symbol example

Source: https://github.com/humbug/php-scoper/blob/main/docs/further-reading.md

Shows the scoped output of the previous example, where the namespace and function are prefixed with 'ScopingPrefix\'. This is the result of running PHP-Scoper on the input code.

```php
<?php

namespace ScopingPrefix\Acme;

use function ScopingPrefix\wp_list_users;

foreach (wp_list_users() as $user) {
    // ...
}

```

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

### Symfony support: example services.php configuration

Source: https://github.com/humbug/php-scoper/blob/main/docs/further-reading.md

This is a Symfony service configuration file (config/services.php) that demonstrates a common pattern. The string 'App\\' in the load method will not be prefixed automatically, requiring a patcher.

```php
<?php // config/services.php

namespace Symfony\Component\DependencyInjection\Loader\Configurator;

return function(ContainerConfigurator $container): void {
    // default configuration for services in *this* file
    $services = $container->services()
        ->defaults()
            ->autowire()      // Automatically injects dependencies in your services.
            ->autoconfigure() // Automatically registers your services as commands, event subscribers, etc.
    ;

    // makes classes in src/ available to be used as services
    // this creates a service per class whose id is the fully-qualified class name
    $services->load('App\\', '../src/')
        ->exclude('../src/{DependencyInjection,Entity,Kernel.php}');

    // order is important in this file because service definitions
    // always *replace* previous ones; add your own service configuration below
};

```

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

### Composer autoload example for exclusion warning

Source: https://github.com/humbug/php-scoper/blob/main/docs/configuration.md

Example Composer package autoload configuration. Used to illustrate that excluding a sub-namespace like PHPUnit\Framework breaks autoloading, requiring the whole package to be excluded.

```json
{
    "autoload": {
        "psr-4": {
            "PHPUnit\\": "src"
        }
    }
}
```

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

### String prefixing example

Source: https://github.com/humbug/php-scoper/blob/main/docs/limitations.md

Shows how PHP-Scoper prefixes a class name string in a class_exists call, with the before and after code.

```php
class_exists('Acme\Foo');
```

```php
\class_exists('Humbug\Acme\Foo');
```

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

### Callable array and string examples

Source: https://github.com/humbug/php-scoper/blob/main/docs/limitations.md

Shows callable values that are not scoped by PHP-Scoper. Requires patchers.

```php
['Acme\Foo', 'bar'];
```

```php
'Acme\Foo::bar';
```

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

### Configure finders in scoper.inc.php

Source: https://github.com/humbug/php-scoper/blob/main/docs/configuration.md

Example configuration for the 'finders' setting. Defines which files should be scoped using Symfony Finder instances. Shows how to include source, vendor, and additional paths.

```php
<?php declare(strict_types=1);

// scoper.inc.php

/** @var Symfony\Component\Finder\Finder $finder */
$finder = Isolated\Symfony\Component\Finder\Finder::class;

return [
    'finders' => [
        $finder::create()->files()->in('src'),
        $finder::create()
            ->files()
            ->ignoreVCS(true)
            ->notName('/LICENSE|.*\.md|.*\.dist|Makefile|composer\.json|composer\.lock/')
            ->exclude([
                'doc',
                'test',
                'test_old',
                'tests',
                'Tests',
                'vendor-bin',
            ])
            ->in('vendor'),
        $finder::create()->append([
            'bin/php-scoper',
            'composer.json',
        ])
    ],
];
```

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

### Install php-scoper-wordpress-excludes via Composer

Source: https://github.com/humbug/php-scoper/blob/main/docs/further-reading.md

Run this command to require the sniccowp/php-scoper-wordpress-excludes package, which provides generated lists of WordPress core symbols to exclude.

```shell
composer require sniccowp/php-scoper-wordpress-excludes
```

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

### PSR-0 autoload configuration

Source: https://github.com/humbug/php-scoper/blob/main/docs/limitations.md

Example of a composer.json autoload configuration using PSR-0. This configuration is the input that PHP-Scoper attempts to transform to PSR-4.

```json
{
  "autoload": {
     "psr-0": {"JsonMapper": "src/"}
  }
}
```

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

### Date format constant example

Source: https://github.com/humbug/php-scoper/blob/main/docs/limitations.md

Shows a constant with a date format string that PHP-Scoper might mistake for a class symbol. Requires patchers to handle.

```php
const ISO8601_BASIC = 'Ymd\THis\Z';
```

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

### Update PHP-Scoper with Phive

Source: https://github.com/humbug/php-scoper/blob/main/docs/installation.md

Upgrades an existing PHP-Scoper installation managed by Phive, using the --force-accept-unsigned flag.

```bash
$ phive update humbug/php-scoper --force-accept-unsigned
```

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

### Example of code with unknown third-party symbol (wp_list_users)

Source: https://github.com/humbug/php-scoper/blob/main/docs/further-reading.md

Shows a PHP namespace with a use function statement for wp_list_users, which is an unknown third-party symbol. This is the input code that PHP-Scoper would process.

```php
<?php

namespace Acme;

use function wp_list_users;

foreach (wp_list_users() as $user) {
    // ...
}

```

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

### Native function shadowing example

Source: https://github.com/humbug/php-scoper/blob/main/docs/limitations.md

Shows a namespaced function call without a use statement, which PHP-Scoper prefixes to the global function, potentially breaking code that relies on the namespaced function.

```php
<?php

namespace Foo;

is_array([]);
```

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

### Heredoc content not prefixed

Source: https://github.com/humbug/php-scoper/blob/main/docs/limitations.md

Demonstrates that heredoc content is not prefixed by PHP-Scoper. The example shows a heredoc containing PHP code with a use statement.

```php
<?php

<<<PHP_HEREDOC
<?php

use Acme\Foo;

PHP_HEREDOC;
```

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

### Custom namespaced function_exists() call

Source: https://github.com/humbug/php-scoper/blob/main/docs/limitations.md

Example of a call to function_exists() with a fully-qualified string. PHP-Scoper assumes this is the native PHP function, but if App\function_exists() exists, the call would invoke that instead.

```php
namespace App;

function_exists('NewApp\main');
```

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

### List available Makefile commands

Source: https://github.com/humbug/php-scoper/blob/main/CONTRIBUTING.md

Run `make` or `make help` to print the list of available commands registered in the Makefile, such as fixing coding style or running tests.

```bash
# Print the list of available commands
make
# or
make help
```

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

### Run PHP-Scoper add-prefix from project root

Source: https://github.com/humbug/php-scoper/blob/main/README.md

Scopes the current working directory to `./build` using default options. The `--output-dir` option changes the output location, `--prefix` sets a specific prefix string, and `--force` overwrites existing output without confirmation. Only PHP files and PHP scripts are prefixed; other files are copied unchanged.

```bash
bin/php-scoper add-prefix
```

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

### Download and Verify PHP-Scoper PHAR from GitHub

Source: https://github.com/humbug/php-scoper/blob/main/docs/installation.md

Downloads the PHP-Scoper PHAR from GitHub releases, verifies its GPG signature, and makes it executable. Adjust the URL for the latest release.

```shell
# Do adjust the URL based on the latest release
wget -O box.phar "https://github.com/humbug/php-scoper/releases/download/0.18.4/php-scoper.phar"
wget -O box.phar.asc "https://github.com/humbug/php-scoper/releases/download/0.18.4/php-scoper.phar.asc"

# Check that the signature matches
gpg --verify php-scoper.phar.asc php-scoper.phar

# Check the issuer (the ID can also be found from the previous command)
gpg --keyserver hkps://keys.openpgp.org --recv-keys 74A754C9778AA03AA451D1C1A000F927D67184EE

rm php-scoper.phar.asc
chmod +x php-scoper.phar
```

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

### Complete scoper.inc.php configuration reference

Source: https://github.com/humbug/php-scoper/blob/main/docs/configuration.md

Complete configuration reference for scoper.inc.php. Shows all available keys with their types and default values. Use as a template when creating a custom configuration file.

```php
<?php declare(strict_types=1);

// scoper.inc.php

/** @var Symfony\Component\Finder\Finder $finder */
$finder = Isolated\Symfony\Component\Finder\Finder::class;

return [
    'prefix' => null,           // string|null
    'php-version' => null,      // string|null
    'output-dir' => null,       // string|null
    'finders' => [],            // list<Finder>
    'patchers' => [],           // list<callable(string $filePath, string $prefix, string $contents): string>

    'exclude-files' => [],      // list<string>
    'exclude-namespaces' => [], // list<string|regex>
    'exclude-constants' => [],  // list<string|regex>
    'exclude-classes' => [],    // list<string|regex>
    'exclude-functions' => [],  // list<string|regex>

    'expose-global-constants' => true,   // bool
    'expose-global-classes' => true,     // bool
    'expose-global-functions' => true,   // bool

    'expose-namespaces' => [], // list<string|regex>
    'expose-constants' => [],  // list<string|regex>
    'expose-classes' => [],    // list<string|regex>
    'expose-functions' => [],  // list<string|regex>
];
```

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

### Original constant declaration with namespace

Source: https://github.com/humbug/php-scoper/blob/main/docs/configuration.md

Shows the original PHP file with a constant FOO in the Acme namespace before scoping.

```php
<?php

namespace Acme;

const FOO = 'X';

```

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

### Run PHP-Scoper add-prefix

Source: https://github.com/humbug/php-scoper/blob/main/README.md

Prefixes all relevant namespaces in code found in the current working directory. The prefixed files are placed in a `build` folder, which can then be used to build a PHAR. After prefixing, if relying on Composer for auto-loading, dumping the autoloader again is required.

```bash
php-scoper add-prefix
```

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

### Add paths via command line

Source: https://github.com/humbug/php-scoper/blob/main/docs/configuration.md

Command to add paths manually when running php-scoper add-prefix. These paths are appended to the paths found by the finders.

```bash
php-scoper add-prefix file1.php bin/file2.php
```

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

### PHP-Scoper configuration for exposing symbols

Source: https://github.com/humbug/php-scoper/blob/main/docs/configuration.md

Configuration array for exposing namespaces, classes, functions, and constants. Note that excluded symbols take precedence over exposed ones, and exposing a namespace also exposes its sub-namespaces.

```php
<?php declare(strict_types=1);

// scoper.inc.php

return [
    'expose-global-constants' => false,
    'expose-global-classes' => false,
    'expose-global-functions' => false,

    'expose-namespaces' => ['PHPUnit\Framework', '/regex/'],
    'expose-classes' => ['PHPUnit\Configuration', '/regex/'],
    'expose-functions' => ['PHPUnit\execute_tests', '/regex/'],
    'expose-constants' => ['PHPUnit\VERSION', '/regex/'],
];
```

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

### PHP specification file structure for integration tests

Source: https://github.com/humbug/php-scoper/blob/main/CONTRIBUTING.md

Defines the structure of a specification file used by the integration test suite. The file returns an array with a 'meta' section for default configuration and a list of specifications, each containing a 'payload' with the original PHP code and the expected scoped output separated by '----'.

```php
<?php declare(strict_types=1);

return [
    'meta' => [
        'title' => 'Title of the specification: this is used to quickly identify what is tested/covered by this file',
        
        // Default configuration values for this file
        'prefix' => 'Humbug',
        'expose-global-constants' => false,
        'expose-global-classes' => false,
        'expose-global-functions' => false,
        'expose-namespaces' => [],
        'expose-constants' => [],
        'expose-classes' => [],
        'expose-functions' => [],
        'exclude-namespaces' => [],
        'exclude-constants' => [],
        'exclude-classes' => [],
        'exclude-functions' => [],
        'expected-recorded-classes' => [],
        'expected-recorded-functions' => [],
    ],

    // List of specifications
    [
        'spec' => <<<'SPEC'
            This is a multiline spec description.
            It can also be a simple string when more readable.
            SPEC
        ,
        
        // Each configuration setting defined in "meta" can be overridden
        // here for this specification
        'expose-global-constants' => true,
        
        // Content of the specification: this should be the content of a plain
        // PHP file as you can notice by the presence of the opening `<?php`
        // tag. You can also see the `----` delimiter: this is what separate
        // the first part which is the content of the original PHP code and
        // the second part which is the scoped content
        'payload' => <<<'PHP'
            <?php declare(strict_types=1);
            
            namespace Acme;
            
            class Foo {}
            
            ----
            <?php declare (strict_types=1);
            
            namespace Humbug\Acme;
            
            class Foo
            {
            }
            
            PHP
    ],
    
    // When a specification has no configuration setting that requires to be
    // overridden, the format can be simplified to: 
    'Simple spec description' => <<<'PHP'
        <?php declare(strict_types=1);
        
        namespace Acme;
        
        class Foo {}
        
        ----
        <?php declare (strict_types=1);
        
        namespace Humbug\Acme;
        
        class Foo
        {
        }
        
    PHP,
];
```

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

### Heredoc with dynamic content

Source: https://github.com/humbug/php-scoper/blob/main/docs/limitations.md

Shows a more complex heredoc with interpolated variables and class references that are hard to scope. Requires patchers.

```php
<?php

<<<EOF
<?php

{$namespaceLine}

// This file has been auto-generated by the Symfony Dependency Injection Component for internal use.

if (\\class_exists(\\Container{$hash}\\{$options['class']}::class, false)) {
    // no-op
} elseif (!include __DIR__.'/Container{$hash}/{$options['class']}.php') {
    touch(__DIR__.'/Container{$hash}.legacy');
    return;
}

if (!\\class_exists({$options['class']}::class, false)) {
    \\class_alias(\\Container{$hash}\\{$options['class']}::class, {$options['class']}::class, false);
}

return new \\Container{$hash}\\{$options['class']}(array(
    'container.build_hash' => '$hash',
    'container.build_id' => '$id',
    'container.build_time' => $time,
), __DIR__.\\DIRECTORY_SEPARATOR.'Container{$hash}');

EOF;
```

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

### Dump Composer autoloader in build directory

Source: https://github.com/humbug/php-scoper/blob/main/README.md

Dumps the Composer autoloader in the `build` directory with a classmap-authoritative configuration. This step is required after scoping if relying on Composer for auto-loading.

```bash
composer dump-autoload --working-dir build --classmap-authoritative
```

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

### Excluded function usage remains unchanged

Source: https://github.com/humbug/php-scoper/blob/main/docs/configuration.md

Shows that a `use function` statement for an excluded function is left unchanged, not prefixed.

```php
use function trigger_deprecation; // Will not be turned into Prefix\trigger_deprecation
```

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

### Scoped constant using define()

Source: https://github.com/humbug/php-scoper/blob/main/docs/configuration.md

Shows the scoped version where the constant is defined using define() with the Humbug prefix and the constant name is not namespaced.

```php
<?php

namespace Humbug\Acme;

\define('FOO', 'X');

```

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

### Inspect a single file with php-scoper

Source: https://github.com/humbug/php-scoper/blob/main/README.md

Use this command to inspect the scoping result for a single file without running the full scoping process. Useful when debugging patchers or verifying the output for a specific file.

```shell
php-scoper inspect path/to/my-file.php
```

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

### Configure scoper.inc.php to exclude WordPress core symbols

Source: https://github.com/humbug/php-scoper/blob/main/docs/further-reading.md

This PHP configuration file loads the generated JSON files for WordPress constants, classes, and functions and returns them as exclude-* options for php-scoper.

```php
// scoper.inc.php

function getWpExcludedSymbols(string $fileName): array
{
    $filePath = __DIR__.'/vendor/sniccowp/php-scoper-wordpress-excludes/generated/'.$fileName;

    return json_decode(
        file_get_contents($filePath),
        true,
    );
}

$wpConstants = getWpExcludedSymbols('exclude-wordpress-constants.json');
$wpClasses = getWpExcludedSymbols('exclude-wordpress-classes.json');
$wpFunctions = getWpExcludedSymbols('exclude-wordpress-functions.json');


return [
  'exclude-constants' => $wpConstants,
  'exclude-classes' => $wpClasses,
  'exclude-functions' => $wpFunctions,
  // ...
];
```

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

### Problem and solution for class names in strings

Source: https://github.com/humbug/php-scoper/blob/main/docs/configuration.md

Shows the problem of class names in strings that are not fixed statically. The second block patches the string by prefixing with the current namespace. Use to understand why patchers are needed.

```php
$type = 'Foo'; // determined at runtime
$class = 'Humbug\\Format\\Type\\' . $type;
```

```php
$type = 'Foo'; // determined at runtime
$scopedPrefix = array_shift(explode('\\', __NAMESPACE__));
$class = $scopedPrefix . '\\Humbug\\Format\\Type\\' . $type;
```

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

### Using use statement to avoid shadowing

Source: https://github.com/humbug/php-scoper/blob/main/docs/limitations.md

Shows adding a use function statement to remove ambiguity and prevent PHP-Scoper from prefixing the function call.

```php
<?php

namespace Foo;

use function Foo\is_array;

is_array([]);
```

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

### Generated scoper-autoload.php with class_exists trigger

Source: https://github.com/humbug/php-scoper/blob/main/docs/configuration.md

The autoload file that triggers the class_alias via class_exists.

```php
<?php

// scoper-autoload.php @generated by PhpScoper

$loader = require_once __DIR__.'/autoload.php';

class_exists('Humbug\\Acme\\Foo');   // Triggers the auto-loading of
                                     // `Humbug\Acme\Foo` **AFTER** the
                                     // Composer autoload is registered

return $loader;
```

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

### Symfony support: patcher configuration (scoper.inc.php)

Source: https://github.com/humbug/php-scoper/blob/main/docs/further-reading.md

This configuration file uses the provided Symfony patcher to handle service configuration files. It is used to prefix the 'App\\' string in the services.php file.

```php
<?php // scoper.inc.php

$symfonyPatcher = (require __DIR__.'/vendor/humbug/php-scoper/res/create-symfony-php-services-patcher.php')('config/services.php');

return [
    'patchers' => [$symfonyPatcher],
    // ...
];

```

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

### Pull PHP-Scoper Docker Image

Source: https://github.com/humbug/php-scoper/blob/main/docs/installation.md

Pulls the official Docker image for PHP-Scoper from Docker Hub.

```shell
docker pull humbugphp/php-scoper
```

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

### Scoped function definition with namespace prefix

Source: https://github.com/humbug/php-scoper/blob/main/docs/configuration.md

The scoped version of the function with a namespace prefix.

```php
<?php

namespace PhpScoperPrefix;

if (!function_exists('PhpScoperPrefix\dd')) {
    function dd($args) {...}
}
```

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

### Original function definition before scoping

Source: https://github.com/humbug/php-scoper/blob/main/docs/configuration.md

A global function dd defined with a guard to avoid redeclaration.

```php
<?php

// No namespace: this is the global namespace

if (!function_exists('dd')) {
    function dd($args) {...}
}
```

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

### Patcher function in scoper.inc.php

Source: https://github.com/humbug/php-scoper/blob/main/docs/configuration.md

Defines a patcher in scoper.inc.php that replaces the problematic string. The patcher receives the file path, prefix, and content, and uses a regex to update the class string.

```php
<?php declare(strict_types=1);

// scoper.inc.php

return [
    'patchers' => [
        static function (string $filePath, string $prefix, string $content): string {
            //
            // PHP-Parser patch conditions for file targets
            //
            if ($filePath === '/path/to/offending/file') {
                return preg_replace(
                    "%\$class = 'Humbug\\\\Format\\\\Type\\\\' . \$type;%",
                    '\$class = \'' . $prefix . '\\\\Humbug\\\\Format\\\\Type\\\\\' . \$type;',
                    $content
                );
            }

            return $content;
        },
    ],
];
```

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

### Laravel support: scoper.inc.php configuration to exclude console view files

Source: https://github.com/humbug/php-scoper/blob/main/docs/further-reading.md

This configuration file for PHP-Scoper excludes Laravel's console view files and applies a patcher to fix the view component factory. It is used to handle Laravel views that are not supported out of the box.

```php
// scoper.inc.php
<?php declare(strict_types=1);

/** @var Symfony\Component\Finder\Finder $finder */
$finder = Isolated\Symfony\Component\Finder\Finder::class;

$consoleViewFiles = array_map(
    static fn (SplFileInfo $fileInfo) => $fileInfo->getPathname(),
    iterator_to_array(
        $finder::create()
            ->in('vendor/laravel/framework/src/Illuminate/Console/resources/views')
            ->files(),
        false,
    ),
);

return [
    'exclude-files' => [
        ...$consoleViewFiles,
    ],
    'patchers' => [
        static function (string $filePath, string $prefix, string $contents): string {
            if (!str_ends_with($filePath, 'vendor/laravel/framework/src/Illuminate/Console/View/Components/Factory.php')) {
                return $contents;
            }

            return str_replace(
                '$component = \'\\\\Illuminate\\\\Console\\\\View\\\\Components\\\\\' . ucfirst($method);',
                '$component = \'\\\\'.$prefix.'\\\\Illuminate\\\\Console\\\\View\\\\Components\\\\\' . ucfirst($method);',
                $contents,
            );
        },
    ],
];

```

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

### Transformed PSR-4 configuration

Source: https://github.com/humbug/php-scoper/blob/main/docs/limitations.md

The resulting configuration after PHP-Scoper transforms the PSR-0 autoload to PSR-4. This works for classes under src/JsonMapper/ but not for JsonMapper.php.

```json
{
  "autoload": {
     "psr-4": {"PhpScoperPrefix\\JsonMapper": "src/"}
  }
}
```

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

### Prefixed code with class alias

Source: https://github.com/humbug/php-scoper/blob/main/docs/configuration.md

The scoped version of the class with a class_alias to the original name.

```php
<?php

namespace Humbug\Acme;

class Foo {}

\class_alias('Humbug\\Acme\\Foo', 'Acme\\Foo', \false);
```

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

### Excluded function declaration is scoped

Source: https://github.com/humbug/php-scoper/blob/main/docs/configuration.md

Shows that function declarations of excluded functions are still scoped by adding the namespace to avoid breaking autoloading. The second block shows the resulting scoped declaration.

```php
// global namespace!

if (!function_exists('trigger_deprecation')) {
    function trigger_deprecation() {}
}
```

```php
namespace Prefix;

if (!function_exists('Prefix\trigger_deprecation')) {
    function trigger_deprecation() {}
}
```

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

### Exclude symbols in scoper.inc.php

Source: https://github.com/humbug/php-scoper/blob/main/docs/configuration.md

Configuration to exclude namespaces, classes, functions, and constants from scoping. Exclusion leaves symbols untouched, enriching the internal symbol list.

```php
<?php declare(strict_types=1);

// scoper.inc.php

return [
    'exclude-namespaces' => [ 'WP', '/regex/' ],
    'exclude-classes' => ['Stringeable', '/regex/'],
    'exclude-functions' => ['str_contains', '/regex/'],
    'exclude-constants' => ['PHP_EOL', '/regex/'],
];
```

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

### Alias function in scoper-autoload.php

Source: https://github.com/humbug/php-scoper/blob/main/docs/configuration.md

The alias function that forwards calls to the prefixed function.

```php
<?php

// scoper-autoload.php @generated by PhpScoper

$loader = require_once __DIR__.'/autoload.php';

if (!function_exists('dd')) {
    function dd() {
        return \PhpScoperPrefix\dd(...func_get_args());
    }
}

return $loader;
```
Tokens:
Raw