dependabot-composer 0.111.24 → 0.111.25

data/helpers/vendor/composer/spdx-licenses/src/SpdxLicenses.php

@@ -0,0 +1,343 @@
+<?php
+
+/*
+ * This file is part of composer/spdx-licenses.
+ *
+ * (c) Composer <https://github.com/composer>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace Composer\Spdx;
+
+class SpdxLicenses
+{
+    /** @var string */
+    const LICENSES_FILE = 'spdx-licenses.json';
+
+    /** @var string */
+    const EXCEPTIONS_FILE = 'spdx-exceptions.json';
+
+    /**
+     * Contains all the licenses.
+     *
+     * The array is indexed by license identifiers, which contain
+     * a numerically indexed array with license details.
+     *
+     *  [ lowercased license identifier =>
+     *      [ 0 => identifier (string), 1 => full name (string), 2 => osi certified (bool), 3 => deprecated (bool) ]
+     *    , ...
+     *  ]
+     *
+     * @var array
+     */
+    private $licenses;
+
+    /**
+     * @var string
+     */
+    private $licensesExpression;
+
+    /**
+     * Contains all the license exceptions.
+     *
+     * The array is indexed by license exception identifiers, which contain
+     * a numerically indexed array with license exception details.
+     *
+     *  [ lowercased exception identifier =>
+     *      [ 0 => exception identifier (string), 1 => full name (string) ]
+     *    , ...
+     *  ]
+     *
+     * @var array
+     */
+    private $exceptions;
+
+    /**
+     * @var string
+     */
+    private $exceptionsExpression;
+
+    public function __construct()
+    {
+        $this->loadLicenses();
+        $this->loadExceptions();
+    }
+
+    /**
+     * Returns license metadata by license identifier.
+     *
+     * This function adds a link to the full license text to the license metadata.
+     * The array returned is in the form of:
+     *
+     *  [ 0 => full name (string), 1 => osi certified, 2 => link to license text (string), 3 => deprecation status (bool) ]
+     *
+     * @param string $identifier
+     *
+     * @return array|null
+     */
+    public function getLicenseByIdentifier($identifier)
+    {
+        $key = strtolower($identifier);
+
+        if (!isset($this->licenses[$key])) {
+            return;
+        }
+
+        list($identifier, $name, $isOsiApproved, $isDeprecatedLicenseId) = $this->licenses[$key];
+
+        return array(
+            $name,
+            $isOsiApproved,
+            'https://spdx.org/licenses/' . $identifier . '.html#licenseText',
+            $isDeprecatedLicenseId,
+        );
+    }
+
+    /**
+     * Returns all licenses information, keyed by the lowercased license identifier.
+     *
+     * @return array[] Each item is [ 0 => identifier (string), 1 => full name (string), 2 => osi certified (bool), 3 => deprecated (bool) ]
+     */
+    public function getLicenses()
+    {
+        return $this->licenses;
+    }
+
+    /**
+     * Returns license exception metadata by license exception identifier.
+     *
+     * This function adds a link to the full license exception text to the license exception metadata.
+     * The array returned is in the form of:
+     *
+     *  [ 0 => full name (string), 1 => link to license text (string) ]
+     *
+     * @param string $identifier
+     *
+     * @return array|null
+     */
+    public function getExceptionByIdentifier($identifier)
+    {
+        $key = strtolower($identifier);
+
+        if (!isset($this->exceptions[$key])) {
+            return;
+        }
+
+        list($identifier, $name) = $this->exceptions[$key];
+
+        return array(
+            $name,
+            'https://spdx.org/licenses/' . $identifier . '.html#licenseExceptionText',
+        );
+    }
+
+    /**
+     * Returns the short identifier of a license (or license exception) by full name.
+     *
+     * @param string $name
+     *
+     * @return string|null
+     */
+    public function getIdentifierByName($name)
+    {
+        foreach ($this->licenses as $licenseData) {
+            if ($licenseData[1] === $name) {
+                return $licenseData[0];
+            }
+        }
+
+        foreach ($this->exceptions as $licenseData) {
+            if ($licenseData[1] === $name) {
+                return $licenseData[0];
+            }
+        }
+    }
+
+    /**
+     * Returns the OSI Approved status for a license by identifier.
+     *
+     * @param string $identifier
+     *
+     * @return bool
+     */
+    public function isOsiApprovedByIdentifier($identifier)
+    {
+        return $this->licenses[strtolower($identifier)][2];
+    }
+
+    /**
+     * Returns the deprecation status for a license by identifier.
+     *
+     * @param string $identifier
+     *
+     * @return bool
+     */
+    public function isDeprecatedByIdentifier($identifier)
+    {
+        return $this->licenses[strtolower($identifier)][3];
+    }
+
+    /**
+     * @param array|string $license
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return bool
+     */
+    public function validate($license)
+    {
+        if (is_array($license)) {
+            $count = count($license);
+            if ($count !== count(array_filter($license, 'is_string'))) {
+                throw new \InvalidArgumentException('Array of strings expected.');
+            }
+            $license = $count > 1  ? '(' . implode(' OR ', $license) . ')' : (string) reset($license);
+        }
+
+        if (!is_string($license)) {
+            throw new \InvalidArgumentException(sprintf(
+                'Array or String expected, %s given.',
+                gettype($license)
+            ));
+        }
+
+        return $this->isValidLicenseString($license);
+    }
+
+    /**
+     * @return string
+     */
+    public static function getResourcesDir()
+    {
+        return dirname(__DIR__) . '/res';
+    }
+
+    private function loadLicenses()
+    {
+        if (null !== $this->licenses) {
+            return;
+        }
+
+        $json = file_get_contents(self::getResourcesDir() . '/' . self::LICENSES_FILE);
+        $this->licenses = array();
+
+        foreach (json_decode($json, true) as $identifier => $license) {
+            $this->licenses[strtolower($identifier)] = array($identifier, $license[0], $license[1], $license[2]);
+        }
+    }
+
+    private function loadExceptions()
+    {
+        if (null !== $this->exceptions) {
+            return;
+        }
+
+        $json = file_get_contents(self::getResourcesDir() . '/' . self::EXCEPTIONS_FILE);
+        $this->exceptions = array();
+
+        foreach (json_decode($json, true) as $identifier => $exception) {
+            $this->exceptions[strtolower($identifier)] = array($identifier, $exception[0]);
+        }
+    }
+
+    /**
+     * @return string
+     */
+    private function getLicensesExpression()
+    {
+        if (null === $this->licensesExpression) {
+            $licenses = array_map('preg_quote', array_keys($this->licenses));
+            rsort($licenses);
+            $licenses = implode('|', $licenses);
+            $this->licensesExpression = $licenses;
+        }
+
+        return $this->licensesExpression;
+    }
+
+    /**
+     * @return string
+     */
+    private function getExceptionsExpression()
+    {
+        if (null === $this->exceptionsExpression) {
+            $exceptions = array_map('preg_quote', array_keys($this->exceptions));
+            rsort($exceptions);
+            $exceptions = implode('|', $exceptions);
+            $this->exceptionsExpression = $exceptions;
+        }
+
+        return $this->exceptionsExpression;
+    }
+
+    /**
+     * @param string $license
+     *
+     * @throws \RuntimeException
+     *
+     * @return bool
+     */
+    private function isValidLicenseString($license)
+    {
+        if (isset($this->licenses[strtolower($license)])) {
+            return true;
+        }
+
+        $licenses = $this->getLicensesExpression();
+        $exceptions = $this->getExceptionsExpression();
+
+        $regex = <<<REGEX
+{
+(?(DEFINE)
+    # idstring: 1*( ALPHA / DIGIT / - / . )
+    (?<idstring>[\pL\pN.-]{1,})
+
+    # license-id: taken from list
+    (?<licenseid>${licenses})
+
+    # license-exception-id: taken from list
+    (?<licenseexceptionid>${exceptions})
+
+    # license-ref: [DocumentRef-1*(idstring):]LicenseRef-1*(idstring)
+    (?<licenseref>(?:DocumentRef-(?&idstring):)?LicenseRef-(?&idstring))
+
+    # simple-expresssion: license-id / license-id+ / license-ref
+    (?<simple_expression>(?&licenseid)\+? | (?&licenseid) | (?&licenseref))
+
+    # compound-expression: 1*(
+    #   simple-expression /
+    #   simple-expression WITH license-exception-id /
+    #   compound-expression AND compound-expression /
+    #   compound-expression OR compound-expression
+    # ) / ( compound-expression ) )
+    (?<compound_head>
+        (?&simple_expression) ( \s+ WITH \s+ (?&licenseexceptionid))?
+            | \( \s* (?&compound_expression) \s* \)
+    )
+    (?<compound_expression>
+        (?&compound_head) (?: \s+ (?:AND|OR) \s+ (?&compound_expression))?
+    )
+
+    # license-expression: 1*1(simple-expression / compound-expression)
+    (?<license_expression>(?&compound_expression) | (?&simple_expression))
+) # end of define
+
+^(NONE | NOASSERTION | (?&license_expression))$
+}xi
+REGEX;
+
+        $match = preg_match($regex, $license);
+
+        if (0 === $match) {
+            return false;
+        }
+
+        if (false === $match) {
+            throw new \RuntimeException('Regex failed to compile/run.');
+        }
+
+        return true;
+    }
+}

data/helpers/vendor/composer/xdebug-handler/CHANGELOG.md

@@ -0,0 +1,55 @@
+## [Unreleased]
+
+## [1.3.2] - 2019-28-01
+  * Fixed: exit call being blocked by uopz extension, resulting in application code running twice.
+
+## [1.3.1] - 2018-11-29
+  * Fixed: fail restart if `passthru` has been disabled in `disable_functions`.
+  * Fixed: fail restart if an ini file cannot be opened, otherwise settings will be missing.
+
+## [1.3.0] - 2018-08-31
+  * Added: `setPersistent` method to use environment variables for the restart.
+  * Fixed: improved debugging by writing output to stderr.
+  * Fixed: no restart when `php_ini_scanned_files` is not functional and is needed.
+
+## [1.2.1] - 2018-08-23
+  * Fixed: fatal error with apc, when using `apc.mmap_file_mask`.
+
+## [1.2.0] - 2018-08-16
+  * Added: debug information using `XDEBUG_HANDLER_DEBUG`.
+  * Added: fluent interface for setters.
+  * Added: `PhpConfig` helper class for calling PHP sub-processes.
+  * Added: `PHPRC` original value to restart stettings, for use in a restarted process.
+  * Changed: internal procedure to disable ini-scanning, using `-n` command-line option.
+  * Fixed: replaced `escapeshellarg` usage to avoid locale problems.
+  * Fixed: improved color-option handling to respect double-dash delimiter.
+  * Fixed: color-option handling regression from main script changes.
+  * Fixed: improved handling when checking main script.
+  * Fixed: handling for standard input, that never actually did anything.
+  * Fixed: fatal error when ctype extension is not available.
+
+## [1.1.0] - 2018-04-11
+  * Added: `getRestartSettings` method for calling PHP processes in a restarted process.
+  * Added: API definition and @internal class annotations.
+  * Added: protected `requiresRestart` method for extending classes.
+  * Added: `setMainScript` method for applications that change the working directory.
+  * Changed: private `tmpIni` variable to protected for extending classes.
+  * Fixed: environment variables not available in $_SERVER when restored in the restart.
+  * Fixed: relative path problems caused by Phar::interceptFileFuncs.
+  * Fixed: incorrect handling when script file cannot be found.
+
+## [1.0.0] - 2018-03-08
+  * Added: PSR3 logging for optional status output.
+  * Added: existing ini settings are merged to catch command-line overrides.
+  * Added: code, tests and other artefacts to decouple from Composer.
+  * Break: the following class was renamed:
+    - `Composer\XdebugHandler` -> `Composer\XdebugHandler\XdebugHandler`
+
+[Unreleased]: https://github.com/composer/xdebug-handler/compare/1.3.2...HEAD
+[1.3.2]: https://github.com/composer/xdebug-handler/compare/1.3.1...1.3.2
+[1.3.1]: https://github.com/composer/xdebug-handler/compare/1.3.0...1.3.1
+[1.3.0]: https://github.com/composer/xdebug-handler/compare/1.2.1...1.3.0
+[1.2.1]: https://github.com/composer/xdebug-handler/compare/1.2.0...1.2.1
+[1.2.0]: https://github.com/composer/xdebug-handler/compare/1.1.0...1.2.0
+[1.1.0]: https://github.com/composer/xdebug-handler/compare/1.0.0...1.1.0
+[1.0.0]: https://github.com/composer/xdebug-handler/compare/d66f0d15cb57...1.0.0

data/helpers/vendor/composer/xdebug-handler/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Composer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/helpers/vendor/composer/xdebug-handler/README.md

@@ -0,0 +1,288 @@
+# composer/xdebug-handler
+
+[![packagist](https://img.shields.io/packagist/v/composer/xdebug-handler.svg)](https://packagist.org/packages/composer/xdebug-handler)
+[![linux build](https://img.shields.io/travis/composer/xdebug-handler/master.svg?label=linux+build)](https://travis-ci.org/composer/xdebug-handler)
+[![windows build](https://img.shields.io/appveyor/ci/Seldaek/xdebug-handler/master.svg?label=windows+build)](https://ci.appveyor.com/project/Seldaek/xdebug-handler)
+![license](https://img.shields.io/github/license/composer/xdebug-handler.svg)
+![php](https://img.shields.io/packagist/php-v/composer/xdebug-handler.svg?colorB=8892BF&label=php)
+
+Restart a CLI process without loading the xdebug extension.
+
+Originally written as part of [composer/composer](https://github.com/composer/composer),
+now extracted and made available as a stand-alone library.
+
+## Installation
+
+Install the latest version with:
+
+```bash
+$ composer require composer/xdebug-handler
+```
+
+## Requirements
+
+* PHP 5.3.2 minimum, although functionality is disabled below PHP 5.4.0. Using the latest PHP version is highly recommended.
+
+## Basic Usage
+```php
+use Composer\XdebugHandler\XdebugHandler;
+
+$xdebug = new XdebugHandler('myapp');
+$xdebug->check();
+unset($xdebug);
+```
+
+The constructor takes two parameters:
+
+#### _$envPrefix_
+This is used to create distinct environment variables and is upper-cased and prepended to default base values. The above example enables the use of:
+
+- `MYAPP_ALLOW_XDEBUG=1` to override automatic restart and allow xdebug
+- `MYAPP_ORIGINAL_INIS` to obtain ini file locations in a restarted process
+
+#### _$colorOption_
+This optional value is added to the restart command-line and is needed to force color output in a piped child process. Only long-options are supported, for example `--ansi` or `--colors=always` etc.
+
+If the original command-line contains an argument that pattern matches this value (for example `--no-ansi`, `--colors=never`) then _$colorOption_ is ignored.
+
+If the pattern match ends with `=auto` (for example `--colors=auto`), the argument is replaced by _$colorOption_. Otherwise it is added at either the end of the command-line, or preceding the first double-dash `--` delimiter.
+
+## Advanced Usage
+
+* [How it works](#how-it-works)
+* [Limitations](#limitations)
+* [Helper methods](#helper-methods)
+* [Setter methods](#setter-methods)
+* [Process configuration](#process-configuration)
+* [Troubleshooting](#troubleshooting)
+* [Extending the library](#extending-the-library)
+
+### How it works
+
+A temporary ini file is created from the loaded (and scanned) ini files, with any references to the xdebug extension commented out. Current ini settings are merged, so that most ini settings made on the command-line or by the application are included (see [Limitations](#limitations))
+
+* `MYAPP_ALLOW_XDEBUG` is set with internal data to flag and use in the restart.
+* The command-line and environment are [configured](#process-configuration) for the restart.
+* The application is restarted in a new process using `passthru`.
+    * The restart settings are stored in the environment.
+    * `MYAPP_ALLOW_XDEBUG` is unset.
+    * The application runs and exits.
+* The main process exits with the exit code from the restarted process.
+
+### Limitations
+There are a few things to be aware of when running inside a restarted process.
+
+* Extensions set on the command-line will not be loaded.
+* Ini file locations will be reported as per the restart - see [getAllIniFiles()](#getallinifiles).
+* Php sub-processes may be loaded with xdebug enabled - see [Process configuration](#process-configuration).
+
+### Helper methods
+These static methods provide information from the current process, regardless of whether it has been restarted or not.
+
+#### _getAllIniFiles()_
+Returns an array of the original ini file locations. Use this instead of calling `php_ini_loaded_file` and `php_ini_scanned_files`, which will report the wrong values in a restarted process.
+
+```php
+use Composer\XdebugHandler\XdebugHandler;
+
+$files = XdebugHandler::getAllIniFiles();
+
+# $files[0] always exists, it could be an empty string
+$loadedIni = array_shift($files);
+$scannedInis = $files;
+```
+
+These locations are also available in the `MYAPP_ORIGINAL_INIS` environment variable. This is a path-separated string comprising the location returned from `php_ini_loaded_file`, which could be empty, followed by locations parsed from calling `php_ini_scanned_files`.
+
+#### _getRestartSettings()_
+Returns an array of settings that can be used with PHP [sub-processes](#sub-processes), or null if the process was not restarted.
+
+```php
+use Composer\XdebugHandler\XdebugHandler;
+
+$settings = XdebugHandler::getRestartSettings();
+/**
+ * $settings: array (if the current process was restarted,
+ * or called with the settings from a previous restart), or null
+ *
+ *    'tmpIni'      => the temporary ini file used in the restart (string)
+ *    'scannedInis' => if there were any scanned inis (bool)
+ *    'scanDir'     => the original PHP_INI_SCAN_DIR value (false|string)
+ *    'phprc'       => the original PHPRC value (false|string)
+ *    'inis'        => the original inis from getAllIniFiles (array)
+ *    'skipped'     => the skipped version from getSkippedVersion (string)
+ */
+```
+
+#### _getSkippedVersion()_
+Returns the xdebug version string that was skipped by the restart, or an empty value if there was no restart (or xdebug is still loaded, perhaps by an extending class restarting for a reason other than removing xdebug).
+
+```php
+use Composer\XdebugHandler\XdebugHandler;
+
+$version = XdebugHandler::getSkippedVersion();
+# $version: '2.6.0' (for example), or an empty string
+```
+
+### Setter methods
+These methods implement a fluent interface and must be called before the main `check()` method.
+
+#### _setLogger($logger)_
+Enables the output of status messages to an external PSR3 logger. All messages are reported with either `DEBUG` or `WARNING` log levels. For example (showing the level and message):
+
+```
+// Restart overridden
+DEBUG    Checking MYAPP_ALLOW_XDEBUG
+DEBUG    The xdebug extension is loaded (2.5.0)
+DEBUG    No restart (MYAPP_ALLOW_XDEBUG=1)
+
+// Failed restart
+DEBUG    Checking MYAPP_ALLOW_XDEBUG
+DEBUG    The xdebug extension is loaded (2.5.0)
+WARNING  No restart (Unable to create temp ini file at: ...)
+```
+
+Status messages can also be output with `XDEBUG_HANDLER_DEBUG`. See [Troubleshooting](#troubleshooting).
+
+#### _setMainScript($script)_
+Sets the location of the main script to run in the restart. This is only needed in more esoteric use-cases, or if the `argv[0]` location is inaccessible. The script name `--` is supported for standard input.
+
+#### _setPersistent()_
+Configures the restart using [persistent settings](#persistent-settings), so that xdebug is not loaded in any sub-process.
+
+Use this method if your application invokes one or more PHP sub-process and the xdebug extension is not needed. This avoids the overhead of implementing specific [sub-process](#sub-processes) strategies.
+
+Alternatively, this method can be used to set up a default _xdebug-free_ environment which can be changed if a sub-process requires xdebug, then restored afterwards:
+
+```php
+function SubProcessWithXdebug()
+{
+    $phpConfig = new Composer\XdebugHandler\PhpConfig();
+
+    # Set the environment to the original configuration
+    $phpConfig->useOriginal();
+
+    # run the process with xdebug loaded
+    ...
+
+    # Restore xdebug-free environment
+    $phpConfig->usePersistent();
+}
+```
+
+### Process configuration
+The library offers two strategies to invoke a new PHP process without loading xdebug, using either _standard_ or _persistent_ settings. Note that this is only important if the application calls a PHP sub-process.
+
+#### Standard settings
+Uses command-line options to remove xdebug from the new process only.
+
+* The -n option is added to the command-line. This tells PHP not to scan for additional inis.
+* The temporary ini is added to the command-line with the -c option.
+
+>_If the new process calls a PHP sub-process, xdebug will be loaded in that sub-process (unless it implements xdebug-handler, in which case there will be another restart)._
+
+This is the default strategy used in the restart.
+
+#### Persistent settings
+Uses environment variables to remove xdebug from the new process and persist these settings to any sub-process.
+
+* `PHP_INI_SCAN_DIR` is set to an empty string. This tells PHP not to scan for additional inis.
+* `PHPRC` is set to the temporary ini.
+
+>_If the new process calls a PHP sub-process, xdebug will not be loaded in that sub-process._
+
+This strategy can be used in the restart by calling [setPersistent()](#setpersistent).
+
+#### Sub-processes
+The `PhpConfig` helper class makes it easy to invoke a PHP sub-process (with or without xdebug loaded), regardless of whether there has been a restart.
+
+Each of its methods returns an array of PHP options (to add to the command-line) and sets up the environment for the required strategy. The [getRestartSettings()](#getrestartsettings) method is used internally.
+
+* `useOriginal()` - xdebug will be loaded in the new process.
+* `useStandard()` - xdebug will **not** be loaded in the new process - see [standard settings](#standard-settings).
+* `userPersistent()` - xdebug will **not** be loaded in the new process - see [persistent settings](#persistent-settings)
+
+If there was no restart, an empty options array is returned and the environment is not changed.
+
+```php
+use Composer\XdebugHandler\PhpConfig;
+
+$config = new PhpConfig;
+
+$options = $config->useOriginal();
+# $options:     empty array
+# environment:  PHPRC and PHP_INI_SCAN_DIR set to original values
+
+$options = $config->useStandard();
+# $options:     [-n, -c, tmpIni]
+# environment:  PHPRC and PHP_INI_SCAN_DIR set to original values
+
+$options = $config->usePersistent();
+# $options:     empty array
+# environment:  PHPRC=tmpIni, PHP_INI_SCAN_DIR=''
+```
+
+### Troubleshooting
+The following environment settings can be used to troubleshoot unexpected behavior:
+
+* `XDEBUG_HANDLER_DEBUG=1` Outputs status messages to `STDERR`, if it is defined, irrespective of any PSR3 logger. Each message is prefixed `xdebug-handler[pid]`, where pid is the process identifier.
+
+* `XDEBUG_HANDLER_DEBUG=2` As above, but additionally saves the temporary ini file and reports its location in a status message.
+
+### Extending the library
+The API is defined by classes and their accessible elements that are not annotated as @internal. The main class has two protected methods that can be overridden to provide additional functionality:
+
+#### _requiresRestart($isLoaded)_
+By default the process will restart if xdebug is loaded. Extending this method allows an application to decide, by returning a boolean (or equivalent) value. It is only called if `MYAPP_ALLOW_XDEBUG` is empty, so it will not be called in the restarted process (where this variable contains internal data), or if the restart has been overridden.
+
+Note that the [setMainScript()](#setmainscriptscript) and [setPersistent()](#setpersistent) setters can be used here, if required.
+
+#### _restart($command)_
+An application can extend this to modify the temporary ini file, its location given in the `tmpIni` property. New settings can be safely appended to the end of the data, which is `PHP_EOL` terminated.
+
+Note that the `$command` parameter is the escaped command-line string that will be used for the new process and must be treated accordingly.
+
+Remember to finish with `parent::restart($command)`.
+
+#### Example
+This example demonstrates two ways to extend basic functionality:
+
+* To avoid the overhead of spinning up a new process, the restart is skipped if a simple help command is requested.
+
+* The application needs write-access to phar files, so it will force a restart if `phar.readonly` is set (regardless of whether xdebug is loaded) and change this value in the temporary ini file.
+
+```php
+use Composer\XdebugHandler\XdebugHandler;
+use MyApp\Command;
+
+class MyRestarter extends XdebugHandler
+{
+    private $required;
+
+    protected function requiresRestart($isLoaded)
+    {
+        if (Command::isHelp()) {
+            # No need to disable xdebug for this
+            return false;
+        }
+
+        $this->required = (bool) ini_get('phar.readonly');
+        return $isLoaded || $this->required;
+    }
+
+    protected function restart($command)
+    {
+        if ($this->required) {
+            # Add required ini setting to tmpIni
+            $content = file_get_contents($this->tmpIni);
+            $content .= 'phar.readonly=0'.PHP_EOL;
+            file_put_contents($this->tmpIni, $content);
+        }
+
+        parent::restart($command);
+    }
+}
+```
+
+## License
+composer/xdebug-handler is licensed under the MIT License, see the LICENSE file for details.