First Commit
This commit is contained in:
mark committed
1 parent
5eb9dd037d
commit
2e62c0e60b
11877 files changed
+2035312
No files matched your search
+579
@@ -0,0 +1,579 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of Composer.
|
||||
*
|
||||
* (c) Nils Adermann <naderman@naderman.de>
|
||||
* Jordi Boggiano <j.boggiano@seld.be>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
|
||||
namespace Composer\Autoload;
|
||||
|
||||
/**
|
||||
* ClassLoader implements a PSR-0, PSR-4 and classmap class loader.
|
||||
*
|
||||
* $loader = new \Composer\Autoload\ClassLoader();
|
||||
*
|
||||
* // register classes with namespaces
|
||||
* $loader->add('Symfony\Component', __DIR__.'/component');
|
||||
* $loader->add('Symfony', __DIR__.'/framework');
|
||||
*
|
||||
* // activate the autoloader
|
||||
* $loader->register();
|
||||
*
|
||||
* // to enable searching the include path (eg. for PEAR packages)
|
||||
* $loader->setUseIncludePath(true);
|
||||
*
|
||||
* In this example, if you try to use a class in the Symfony\Component
|
||||
* namespace or one of its children (Symfony\Component\Console for instance),
|
||||
* the autoloader will first look for the class under the component/
|
||||
* directory, and it will then fallback to the framework/ directory if not
|
||||
* found before giving up.
|
||||
*
|
||||
* This class is loosely based on the Symfony UniversalClassLoader.
|
||||
*
|
||||
* @author Fabien Potencier <fabien@symfony.com>
|
||||
* @author Jordi Boggiano <j.boggiano@seld.be>
|
||||
* @see https://www.php-fig.org/psr/psr-0/
|
||||
* @see https://www.php-fig.org/psr/psr-4/
|
||||
*/
|
||||
class ClassLoader
|
||||
{
|
||||
/** @var \Closure(string):void */
|
||||
private static $includeFile;
|
||||
|
||||
/** @var string|null */
|
||||
private $vendorDir;
|
||||
|
||||
// PSR-4
|
||||
/**
|
||||
* @var array<string, array<string, int>>
|
||||
*/
|
||||
private $prefixLengthsPsr4 = array();
|
||||
/**
|
||||
* @var array<string, list<string>>
|
||||
*/
|
||||
private $prefixDirsPsr4 = array();
|
||||
/**
|
||||
* @var list<string>
|
||||
*/
|
||||
private $fallbackDirsPsr4 = array();
|
||||
|
||||
// PSR-0
|
||||
/**
|
||||
* List of PSR-0 prefixes
|
||||
*
|
||||
* Structured as array('F (first letter)' => array('Foo\Bar (full prefix)' => array('path', 'path2')))
|
||||
*
|
||||
* @var array<string, array<string, list<string>>>
|
||||
*/
|
||||
private $prefixesPsr0 = array();
|
||||
/**
|
||||
* @var list<string>
|
||||
*/
|
||||
private $fallbackDirsPsr0 = array();
|
||||
|
||||
/** @var bool */
|
||||
private $useIncludePath = false;
|
||||
|
||||
/**
|
||||
* @var array<string, string>
|
||||
*/
|
||||
private $classMap = array();
|
||||
|
||||
/** @var bool */
|
||||
private $classMapAuthoritative = false;
|
||||
|
||||
/**
|
||||
* @var array<string, bool>
|
||||
*/
|
||||
private $missingClasses = array();
|
||||
|
||||
/** @var string|null */
|
||||
private $apcuPrefix;
|
||||
|
||||
/**
|
||||
* @var array<string, self>
|
||||
*/
|
||||
private static $registeredLoaders = array();
|
||||
|
||||
/**
|
||||
* @param string|null $vendorDir
|
||||
*/
|
||||
public function __construct($vendorDir = null)
|
||||
{
|
||||
$this->vendorDir = $vendorDir;
|
||||
self::initializeIncludeClosure();
|
||||
}
|
||||
|
||||
/**
|
||||
* @return array<string, list<string>>
|
||||
*/
|
||||
public function getPrefixes()
|
||||
{
|
||||
if (!empty($this->prefixesPsr0)) {
|
||||
return call_user_func_array('array_merge', array_values($this->prefixesPsr0));
|
||||
}
|
||||
|
||||
return array();
|
||||
}
|
||||
|
||||
/**
|
||||
* @return array<string, list<string>>
|
||||
*/
|
||||
public function getPrefixesPsr4()
|
||||
{
|
||||
return $this->prefixDirsPsr4;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return list<string>
|
||||
*/
|
||||
public function getFallbackDirs()
|
||||
{
|
||||
return $this->fallbackDirsPsr0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return list<string>
|
||||
*/
|
||||
public function getFallbackDirsPsr4()
|
||||
{
|
||||
return $this->fallbackDirsPsr4;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return array<string, string> Array of classname => path
|
||||
*/
|
||||
public function getClassMap()
|
||||
{
|
||||
return $this->classMap;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param array<string, string> $classMap Class to filename map
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function addClassMap(array $classMap)
|
||||
{
|
||||
if ($this->classMap) {
|
||||
$this->classMap = array_merge($this->classMap, $classMap);
|
||||
} else {
|
||||
$this->classMap = $classMap;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Registers a set of PSR-0 directories for a given prefix, either
|
||||
* appending or prepending to the ones previously set for this prefix.
|
||||
*
|
||||
* @param string $prefix The prefix
|
||||
* @param list<string>|string $paths The PSR-0 root directories
|
||||
* @param bool $prepend Whether to prepend the directories
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function add($prefix, $paths, $prepend = false)
|
||||
{
|
||||
$paths = (array) $paths;
|
||||
if (!$prefix) {
|
||||
if ($prepend) {
|
||||
$this->fallbackDirsPsr0 = array_merge(
|
||||
$paths,
|
||||
$this->fallbackDirsPsr0
|
||||
);
|
||||
} else {
|
||||
$this->fallbackDirsPsr0 = array_merge(
|
||||
$this->fallbackDirsPsr0,
|
||||
$paths
|
||||
);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
$first = $prefix[0];
|
||||
if (!isset($this->prefixesPsr0[$first][$prefix])) {
|
||||
$this->prefixesPsr0[$first][$prefix] = $paths;
|
||||
|
||||
return;
|
||||
}
|
||||
if ($prepend) {
|
||||
$this->prefixesPsr0[$first][$prefix] = array_merge(
|
||||
$paths,
|
||||
$this->prefixesPsr0[$first][$prefix]
|
||||
);
|
||||
} else {
|
||||
$this->prefixesPsr0[$first][$prefix] = array_merge(
|
||||
$this->prefixesPsr0[$first][$prefix],
|
||||
$paths
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Registers a set of PSR-4 directories for a given namespace, either
|
||||
* appending or prepending to the ones previously set for this namespace.
|
||||
*
|
||||
* @param string $prefix The prefix/namespace, with trailing '\\'
|
||||
* @param list<string>|string $paths The PSR-4 base directories
|
||||
* @param bool $prepend Whether to prepend the directories
|
||||
*
|
||||
* @throws \InvalidArgumentException
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function addPsr4($prefix, $paths, $prepend = false)
|
||||
{
|
||||
$paths = (array) $paths;
|
||||
if (!$prefix) {
|
||||
// Register directories for the root namespace.
|
||||
if ($prepend) {
|
||||
$this->fallbackDirsPsr4 = array_merge(
|
||||
$paths,
|
||||
$this->fallbackDirsPsr4
|
||||
);
|
||||
} else {
|
||||
$this->fallbackDirsPsr4 = array_merge(
|
||||
$this->fallbackDirsPsr4,
|
||||
$paths
|
||||
);
|
||||
}
|
||||
} elseif (!isset($this->prefixDirsPsr4[$prefix])) {
|
||||
// Register directories for a new namespace.
|
||||
$length = strlen($prefix);
|
||||
if ('\\' !== $prefix[$length - 1]) {
|
||||
throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
|
||||
}
|
||||
$this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
|
||||
$this->prefixDirsPsr4[$prefix] = $paths;
|
||||
} elseif ($prepend) {
|
||||
// Prepend directories for an already registered namespace.
|
||||
$this->prefixDirsPsr4[$prefix] = array_merge(
|
||||
$paths,
|
||||
$this->prefixDirsPsr4[$prefix]
|
||||
);
|
||||
} else {
|
||||
// Append directories for an already registered namespace.
|
||||
$this->prefixDirsPsr4[$prefix] = array_merge(
|
||||
$this->prefixDirsPsr4[$prefix],
|
||||
$paths
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Registers a set of PSR-0 directories for a given prefix,
|
||||
* replacing any others previously set for this prefix.
|
||||
*
|
||||
* @param string $prefix The prefix
|
||||
* @param list<string>|string $paths The PSR-0 base directories
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function set($prefix, $paths)
|
||||
{
|
||||
if (!$prefix) {
|
||||
$this->fallbackDirsPsr0 = (array) $paths;
|
||||
} else {
|
||||
$this->prefixesPsr0[$prefix[0]][$prefix] = (array) $paths;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Registers a set of PSR-4 directories for a given namespace,
|
||||
* replacing any others previously set for this namespace.
|
||||
*
|
||||
* @param string $prefix The prefix/namespace, with trailing '\\'
|
||||
* @param list<string>|string $paths The PSR-4 base directories
|
||||
*
|
||||
* @throws \InvalidArgumentException
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function setPsr4($prefix, $paths)
|
||||
{
|
||||
if (!$prefix) {
|
||||
$this->fallbackDirsPsr4 = (array) $paths;
|
||||
} else {
|
||||
$length = strlen($prefix);
|
||||
if ('\\' !== $prefix[$length - 1]) {
|
||||
throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
|
||||
}
|
||||
$this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
|
||||
$this->prefixDirsPsr4[$prefix] = (array) $paths;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Turns on searching the include path for class files.
|
||||
*
|
||||
* @param bool $useIncludePath
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function setUseIncludePath($useIncludePath)
|
||||
{
|
||||
$this->useIncludePath = $useIncludePath;
|
||||
}
|
||||
|
||||
/**
|
||||
* Can be used to check if the autoloader uses the include path to check
|
||||
* for classes.
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function getUseIncludePath()
|
||||
{
|
||||
return $this->useIncludePath;
|
||||
}
|
||||
|
||||
/**
|
||||
* Turns off searching the prefix and fallback directories for classes
|
||||
* that have not been registered with the class map.
|
||||
*
|
||||
* @param bool $classMapAuthoritative
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function setClassMapAuthoritative($classMapAuthoritative)
|
||||
{
|
||||
$this->classMapAuthoritative = $classMapAuthoritative;
|
||||
}
|
||||
|
||||
/**
|
||||
* Should class lookup fail if not found in the current class map?
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function isClassMapAuthoritative()
|
||||
{
|
||||
return $this->classMapAuthoritative;
|
||||
}
|
||||
|
||||
/**
|
||||
* APCu prefix to use to cache found/not-found classes, if the extension is enabled.
|
||||
*
|
||||
* @param string|null $apcuPrefix
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function setApcuPrefix($apcuPrefix)
|
||||
{
|
||||
$this->apcuPrefix = function_exists('apcu_fetch') && filter_var(ini_get('apc.enabled'), FILTER_VALIDATE_BOOLEAN) ? $apcuPrefix : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* The APCu prefix in use, or null if APCu caching is not enabled.
|
||||
*
|
||||
* @return string|null
|
||||
*/
|
||||
public function getApcuPrefix()
|
||||
{
|
||||
return $this->apcuPrefix;
|
||||
}
|
||||
|
||||
/**
|
||||
* Registers this instance as an autoloader.
|
||||
*
|
||||
* @param bool $prepend Whether to prepend the autoloader or not
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function register($prepend = false)
|
||||
{
|
||||
spl_autoload_register(array($this, 'loadClass'), true, $prepend);
|
||||
|
||||
if (null === $this->vendorDir) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ($prepend) {
|
||||
self::$registeredLoaders = array($this->vendorDir => $this) + self::$registeredLoaders;
|
||||
} else {
|
||||
unset(self::$registeredLoaders[$this->vendorDir]);
|
||||
self::$registeredLoaders[$this->vendorDir] = $this;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Unregisters this instance as an autoloader.
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function unregister()
|
||||
{
|
||||
spl_autoload_unregister(array($this, 'loadClass'));
|
||||
|
||||
if (null !== $this->vendorDir) {
|
||||
unset(self::$registeredLoaders[$this->vendorDir]);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads the given class or interface.
|
||||
*
|
||||
* @param string $class The name of the class
|
||||
* @return true|null True if loaded, null otherwise
|
||||
*/
|
||||
public function loadClass($class)
|
||||
{
|
||||
if ($file = $this->findFile($class)) {
|
||||
$includeFile = self::$includeFile;
|
||||
$includeFile($file);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds the path to the file where the class is defined.
|
||||
*
|
||||
* @param string $class The name of the class
|
||||
*
|
||||
* @return string|false The path if found, false otherwise
|
||||
*/
|
||||
public function findFile($class)
|
||||
{
|
||||
// class map lookup
|
||||
if (isset($this->classMap[$class])) {
|
||||
return $this->classMap[$class];
|
||||
}
|
||||
if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) {
|
||||
return false;
|
||||
}
|
||||
if (null !== $this->apcuPrefix) {
|
||||
$file = apcu_fetch($this->apcuPrefix.$class, $hit);
|
||||
if ($hit) {
|
||||
return $file;
|
||||
}
|
||||
}
|
||||
|
||||
$file = $this->findFileWithExtension($class, '.php');
|
||||
|
||||
// Search for Hack files if we are running on HHVM
|
||||
if (false === $file && defined('HHVM_VERSION')) {
|
||||
$file = $this->findFileWithExtension($class, '.hh');
|
||||
}
|
||||
|
||||
if (null !== $this->apcuPrefix) {
|
||||
apcu_add($this->apcuPrefix.$class, $file);
|
||||
}
|
||||
|
||||
if (false === $file) {
|
||||
// Remember that this class does not exist.
|
||||
$this->missingClasses[$class] = true;
|
||||
}
|
||||
|
||||
return $file;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the currently registered loaders keyed by their corresponding vendor directories.
|
||||
*
|
||||
* @return array<string, self>
|
||||
*/
|
||||
public static function getRegisteredLoaders()
|
||||
{
|
||||
return self::$registeredLoaders;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $class
|
||||
* @param string $ext
|
||||
* @return string|false
|
||||
*/
|
||||
private function findFileWithExtension($class, $ext)
|
||||
{
|
||||
// PSR-4 lookup
|
||||
$logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext;
|
||||
|
||||
$first = $class[0];
|
||||
if (isset($this->prefixLengthsPsr4[$first])) {
|
||||
$subPath = $class;
|
||||
while (false !== $lastPos = strrpos($subPath, '\\')) {
|
||||
$subPath = substr($subPath, 0, $lastPos);
|
||||
$search = $subPath . '\\';
|
||||
if (isset($this->prefixDirsPsr4[$search])) {
|
||||
$pathEnd = DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $lastPos + 1);
|
||||
foreach ($this->prefixDirsPsr4[$search] as $dir) {
|
||||
if (file_exists($file = $dir . $pathEnd)) {
|
||||
return $file;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// PSR-4 fallback dirs
|
||||
foreach ($this->fallbackDirsPsr4 as $dir) {
|
||||
if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) {
|
||||
return $file;
|
||||
}
|
||||
}
|
||||
|
||||
// PSR-0 lookup
|
||||
if (false !== $pos = strrpos($class, '\\')) {
|
||||
// namespaced class name
|
||||
$logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1)
|
||||
. strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR);
|
||||
} else {
|
||||
// PEAR-like class name
|
||||
$logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext;
|
||||
}
|
||||
|
||||
if (isset($this->prefixesPsr0[$first])) {
|
||||
foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) {
|
||||
if (0 === strpos($class, $prefix)) {
|
||||
foreach ($dirs as $dir) {
|
||||
if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
|
||||
return $file;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// PSR-0 fallback dirs
|
||||
foreach ($this->fallbackDirsPsr0 as $dir) {
|
||||
if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
|
||||
return $file;
|
||||
}
|
||||
}
|
||||
|
||||
// PSR-0 include paths.
|
||||
if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
|
||||
return $file;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return void
|
||||
*/
|
||||
private static function initializeIncludeClosure()
|
||||
{
|
||||
if (self::$includeFile !== null) {
|
||||
return;
|
||||
}
|
||||
|
||||
/**
|
||||
* Scope isolated include.
|
||||
*
|
||||
* Prevents access to $this/self from included files.
|
||||
*
|
||||
* @param string $file
|
||||
* @return void
|
||||
*/
|
||||
self::$includeFile = \Closure::bind(static function($file) {
|
||||
include $file;
|
||||
}, null, null);
|
||||
}
|
||||
}
|
||||
+396
@@ -0,0 +1,396 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of Composer.
|
||||
*
|
||||
* (c) Nils Adermann <naderman@naderman.de>
|
||||
* Jordi Boggiano <j.boggiano@seld.be>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
|
||||
namespace Composer;
|
||||
|
||||
use Composer\Autoload\ClassLoader;
|
||||
use Composer\Semver\VersionParser;
|
||||
|
||||
/**
|
||||
* This class is copied in every Composer installed project and available to all
|
||||
*
|
||||
* See also https://getcomposer.org/doc/07-runtime.md#installed-versions
|
||||
*
|
||||
* To require its presence, you can require `composer-runtime-api ^2.0`
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class InstalledVersions
|
||||
{
|
||||
/**
|
||||
* @var string|null if set (by reflection by Composer), this should be set to the path where this class is being copied to
|
||||
* @internal
|
||||
*/
|
||||
private static $selfDir = null;
|
||||
|
||||
/**
|
||||
* @var mixed[]|null
|
||||
* @psalm-var array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>}|array{}|null
|
||||
*/
|
||||
private static $installed;
|
||||
|
||||
/**
|
||||
* @var bool
|
||||
*/
|
||||
private static $installedIsLocalDir;
|
||||
|
||||
/**
|
||||
* @var bool|null
|
||||
*/
|
||||
private static $canGetVendors;
|
||||
|
||||
/**
|
||||
* @var array[]
|
||||
* @psalm-var array<string, array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>}>
|
||||
*/
|
||||
private static $installedByVendor = array();
|
||||
|
||||
/**
|
||||
* Returns a list of all package names which are present, either by being installed, replaced or provided
|
||||
*
|
||||
* @return string[]
|
||||
* @psalm-return list<string>
|
||||
*/
|
||||
public static function getInstalledPackages()
|
||||
{
|
||||
$packages = array();
|
||||
foreach (self::getInstalled() as $installed) {
|
||||
$packages[] = array_keys($installed['versions']);
|
||||
}
|
||||
|
||||
if (1 === \count($packages)) {
|
||||
return $packages[0];
|
||||
}
|
||||
|
||||
return array_keys(array_flip(\call_user_func_array('array_merge', $packages)));
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a list of all package names with a specific type e.g. 'library'
|
||||
*
|
||||
* @param string $type
|
||||
* @return string[]
|
||||
* @psalm-return list<string>
|
||||
*/
|
||||
public static function getInstalledPackagesByType($type)
|
||||
{
|
||||
$packagesByType = array();
|
||||
|
||||
foreach (self::getInstalled() as $installed) {
|
||||
foreach ($installed['versions'] as $name => $package) {
|
||||
if (isset($package['type']) && $package['type'] === $type) {
|
||||
$packagesByType[] = $name;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return $packagesByType;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks whether the given package is installed
|
||||
*
|
||||
* This also returns true if the package name is provided or replaced by another package
|
||||
*
|
||||
* @param string $packageName
|
||||
* @param bool $includeDevRequirements
|
||||
* @return bool
|
||||
*/
|
||||
public static function isInstalled($packageName, $includeDevRequirements = true)
|
||||
{
|
||||
foreach (self::getInstalled() as $installed) {
|
||||
if (isset($installed['versions'][$packageName])) {
|
||||
return $includeDevRequirements || !isset($installed['versions'][$packageName]['dev_requirement']) || $installed['versions'][$packageName]['dev_requirement'] === false;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks whether the given package satisfies a version constraint
|
||||
*
|
||||
* e.g. If you want to know whether version 2.3+ of package foo/bar is installed, you would call:
|
||||
*
|
||||
* Composer\InstalledVersions::satisfies(new VersionParser, 'foo/bar', '^2.3')
|
||||
*
|
||||
* @param VersionParser $parser Install composer/semver to have access to this class and functionality
|
||||
* @param string $packageName
|
||||
* @param string|null $constraint A version constraint to check for, if you pass one you have to make sure composer/semver is required by your package
|
||||
* @return bool
|
||||
*/
|
||||
public static function satisfies(VersionParser $parser, $packageName, $constraint)
|
||||
{
|
||||
$constraint = $parser->parseConstraints((string) $constraint);
|
||||
$provided = $parser->parseConstraints(self::getVersionRanges($packageName));
|
||||
|
||||
return $provided->matches($constraint);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a version constraint representing all the range(s) which are installed for a given package
|
||||
*
|
||||
* It is easier to use this via isInstalled() with the $constraint argument if you need to check
|
||||
* whether a given version of a package is installed, and not just whether it exists
|
||||
*
|
||||
* @param string $packageName
|
||||
* @return string Version constraint usable with composer/semver
|
||||
*/
|
||||
public static function getVersionRanges($packageName)
|
||||
{
|
||||
foreach (self::getInstalled() as $installed) {
|
||||
if (!isset($installed['versions'][$packageName])) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$ranges = array();
|
||||
if (isset($installed['versions'][$packageName]['pretty_version'])) {
|
||||
$ranges[] = $installed['versions'][$packageName]['pretty_version'];
|
||||
}
|
||||
if (array_key_exists('aliases', $installed['versions'][$packageName])) {
|
||||
$ranges = array_merge($ranges, $installed['versions'][$packageName]['aliases']);
|
||||
}
|
||||
if (array_key_exists('replaced', $installed['versions'][$packageName])) {
|
||||
$ranges = array_merge($ranges, $installed['versions'][$packageName]['replaced']);
|
||||
}
|
||||
if (array_key_exists('provided', $installed['versions'][$packageName])) {
|
||||
$ranges = array_merge($ranges, $installed['versions'][$packageName]['provided']);
|
||||
}
|
||||
|
||||
return implode(' || ', $ranges);
|
||||
}
|
||||
|
||||
throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $packageName
|
||||
* @return string|null If the package is being replaced or provided but is not really installed, null will be returned as version, use satisfies or getVersionRanges if you need to know if a given version is present
|
||||
*/
|
||||
public static function getVersion($packageName)
|
||||
{
|
||||
foreach (self::getInstalled() as $installed) {
|
||||
if (!isset($installed['versions'][$packageName])) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!isset($installed['versions'][$packageName]['version'])) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return $installed['versions'][$packageName]['version'];
|
||||
}
|
||||
|
||||
throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $packageName
|
||||
* @return string|null If the package is being replaced or provided but is not really installed, null will be returned as version, use satisfies or getVersionRanges if you need to know if a given version is present
|
||||
*/
|
||||
public static function getPrettyVersion($packageName)
|
||||
{
|
||||
foreach (self::getInstalled() as $installed) {
|
||||
if (!isset($installed['versions'][$packageName])) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!isset($installed['versions'][$packageName]['pretty_version'])) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return $installed['versions'][$packageName]['pretty_version'];
|
||||
}
|
||||
|
||||
throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $packageName
|
||||
* @return string|null If the package is being replaced or provided but is not really installed, null will be returned as reference
|
||||
*/
|
||||
public static function getReference($packageName)
|
||||
{
|
||||
foreach (self::getInstalled() as $installed) {
|
||||
if (!isset($installed['versions'][$packageName])) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!isset($installed['versions'][$packageName]['reference'])) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return $installed['versions'][$packageName]['reference'];
|
||||
}
|
||||
|
||||
throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $packageName
|
||||
* @return string|null If the package is being replaced or provided but is not really installed, null will be returned as install path. Packages of type metapackages also have a null install path.
|
||||
*/
|
||||
public static function getInstallPath($packageName)
|
||||
{
|
||||
foreach (self::getInstalled() as $installed) {
|
||||
if (!isset($installed['versions'][$packageName])) {
|
||||
continue;
|
||||
}
|
||||
|
||||
return isset($installed['versions'][$packageName]['install_path']) ? $installed['versions'][$packageName]['install_path'] : null;
|
||||
}
|
||||
|
||||
throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
|
||||
}
|
||||
|
||||
/**
|
||||
* @return array
|
||||
* @psalm-return array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}
|
||||
*/
|
||||
public static function getRootPackage()
|
||||
{
|
||||
$installed = self::getInstalled();
|
||||
|
||||
return $installed[0]['root'];
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the raw installed.php data for custom implementations
|
||||
*
|
||||
* @deprecated Use getAllRawData() instead which returns all datasets for all autoloaders present in the process. getRawData only returns the first dataset loaded, which may not be what you expect.
|
||||
* @return array[]
|
||||
* @psalm-return array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>}
|
||||
*/
|
||||
public static function getRawData()
|
||||
{
|
||||
@trigger_error('getRawData only returns the first dataset loaded, which may not be what you expect. Use getAllRawData() instead which returns all datasets for all autoloaders present in the process.', E_USER_DEPRECATED);
|
||||
|
||||
if (null === self::$installed) {
|
||||
// only require the installed.php file if this file is loaded from its dumped location,
|
||||
// and not from its source location in the composer/composer package, see https://github.com/composer/composer/issues/9937
|
||||
if (substr(__DIR__, -8, 1) !== 'C') {
|
||||
self::$installed = include __DIR__ . '/installed.php';
|
||||
} else {
|
||||
self::$installed = array();
|
||||
}
|
||||
}
|
||||
|
||||
return self::$installed;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the raw data of all installed.php which are currently loaded for custom implementations
|
||||
*
|
||||
* @return array[]
|
||||
* @psalm-return list<array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>}>
|
||||
*/
|
||||
public static function getAllRawData()
|
||||
{
|
||||
return self::getInstalled();
|
||||
}
|
||||
|
||||
/**
|
||||
* Lets you reload the static array from another file
|
||||
*
|
||||
* This is only useful for complex integrations in which a project needs to use
|
||||
* this class but then also needs to execute another project's autoloader in process,
|
||||
* and wants to ensure both projects have access to their version of installed.php.
|
||||
*
|
||||
* A typical case would be PHPUnit, where it would need to make sure it reads all
|
||||
* the data it needs from this class, then call reload() with
|
||||
* `require $CWD/vendor/composer/installed.php` (or similar) as input to make sure
|
||||
* the project in which it runs can then also use this class safely, without
|
||||
* interference between PHPUnit's dependencies and the project's dependencies.
|
||||
*
|
||||
* @param array[] $data A vendor/composer/installed.php data set
|
||||
* @return void
|
||||
*
|
||||
* @psalm-param array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>} $data
|
||||
*/
|
||||
public static function reload($data)
|
||||
{
|
||||
self::$installed = $data;
|
||||
self::$installedByVendor = array();
|
||||
|
||||
// when using reload, we disable the duplicate protection to ensure that self::$installed data is
|
||||
// always returned, but we cannot know whether it comes from the installed.php in __DIR__ or not,
|
||||
// so we have to assume it does not, and that may result in duplicate data being returned when listing
|
||||
// all installed packages for example
|
||||
self::$installedIsLocalDir = false;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return string
|
||||
*/
|
||||
private static function getSelfDir()
|
||||
{
|
||||
if (self::$selfDir === null) {
|
||||
self::$selfDir = strtr(__DIR__, '\\', '/');
|
||||
}
|
||||
|
||||
return self::$selfDir;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return array[]
|
||||
* @psalm-return list<array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>}>
|
||||
*/
|
||||
private static function getInstalled()
|
||||
{
|
||||
if (null === self::$canGetVendors) {
|
||||
self::$canGetVendors = method_exists('Composer\Autoload\ClassLoader', 'getRegisteredLoaders');
|
||||
}
|
||||
|
||||
$installed = array();
|
||||
$copiedLocalDir = false;
|
||||
|
||||
if (self::$canGetVendors) {
|
||||
$selfDir = self::getSelfDir();
|
||||
foreach (ClassLoader::getRegisteredLoaders() as $vendorDir => $loader) {
|
||||
$vendorDir = strtr($vendorDir, '\\', '/');
|
||||
if (isset(self::$installedByVendor[$vendorDir])) {
|
||||
$installed[] = self::$installedByVendor[$vendorDir];
|
||||
} elseif (is_file($vendorDir.'/composer/installed.php')) {
|
||||
/** @var array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>} $required */
|
||||
$required = require $vendorDir.'/composer/installed.php';
|
||||
self::$installedByVendor[$vendorDir] = $required;
|
||||
$installed[] = $required;
|
||||
if (self::$installed === null && $vendorDir.'/composer' === $selfDir) {
|
||||
self::$installed = $required;
|
||||
self::$installedIsLocalDir = true;
|
||||
}
|
||||
}
|
||||
if (self::$installedIsLocalDir && $vendorDir.'/composer' === $selfDir) {
|
||||
$copiedLocalDir = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (null === self::$installed) {
|
||||
// only require the installed.php file if this file is loaded from its dumped location,
|
||||
// and not from its source location in the composer/composer package, see https://github.com/composer/composer/issues/9937
|
||||
if (substr(__DIR__, -8, 1) !== 'C') {
|
||||
/** @var array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>} $required */
|
||||
$required = require __DIR__ . '/installed.php';
|
||||
self::$installed = $required;
|
||||
} else {
|
||||
self::$installed = array();
|
||||
}
|
||||
}
|
||||
|
||||
if (self::$installed !== array() && !$copiedLocalDir) {
|
||||
$installed[] = self::$installed;
|
||||
}
|
||||
|
||||
return $installed;
|
||||
}
|
||||
}
|
||||
Vendored
+21
@@ -0,0 +1,21 @@
|
||||
|
||||
Copyright (c) Nils Adermann, Jordi Boggiano
|
||||
|
||||
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.
|
||||
|
||||
+1171
File diff suppressed because it is too large.
Load diff
+14
@@ -0,0 +1,14 @@
|
||||
<?php
|
||||
|
||||
// autoload_files.php @generated by Composer
|
||||
|
||||
$vendorDir = dirname(__DIR__);
|
||||
$baseDir = dirname($vendorDir);
|
||||
|
||||
return array(
|
||||
'6e3fae29631ef280660b3cdad06f25a8' => $vendorDir . '/symfony/deprecation-contracts/function.php',
|
||||
'320cde22f66dd4f5d3fd621d3e88b98f' => $vendorDir . '/symfony/polyfill-ctype/bootstrap.php',
|
||||
'0e6d7bf4a5811bfa5cf40c5ccd6fae6a' => $vendorDir . '/symfony/polyfill-mbstring/bootstrap.php',
|
||||
'6124b4c8570aa390c21fafd04a26c69f' => $vendorDir . '/myclabs/deep-copy/src/DeepCopy/deep_copy.php',
|
||||
'ec07570ca5a812141189b1fa81503674' => $vendorDir . '/phpunit/phpunit/src/Framework/Assert/Functions.php',
|
||||
);
|
||||
@@ -0,0 +1,10 @@
|
||||
<?php
|
||||
|
||||
// autoload_namespaces.php @generated by Composer
|
||||
|
||||
$vendorDir = dirname(__DIR__);
|
||||
$baseDir = dirname($vendorDir);
|
||||
|
||||
return array(
|
||||
'PHPMD\\' => array($vendorDir . '/phpmd/phpmd/src/main/php'),
|
||||
);
|
||||
+35
@@ -0,0 +1,35 @@
|
||||
<?php
|
||||
|
||||
// autoload_psr4.php @generated by Composer
|
||||
|
||||
$vendorDir = dirname(__DIR__);
|
||||
$baseDir = dirname($vendorDir);
|
||||
|
||||
return array(
|
||||
'Test\\' => array($baseDir . '/test'),
|
||||
'Symfony\\Polyfill\\Mbstring\\' => array($vendorDir . '/symfony/polyfill-mbstring'),
|
||||
'Symfony\\Polyfill\\Ctype\\' => array($vendorDir . '/symfony/polyfill-ctype'),
|
||||
'Symfony\\Contracts\\Service\\' => array($vendorDir . '/symfony/service-contracts'),
|
||||
'Symfony\\Component\\VarExporter\\' => array($vendorDir . '/symfony/var-exporter'),
|
||||
'Symfony\\Component\\Filesystem\\' => array($vendorDir . '/symfony/filesystem'),
|
||||
'Symfony\\Component\\DependencyInjection\\' => array($vendorDir . '/symfony/dependency-injection'),
|
||||
'Symfony\\Component\\Config\\' => array($vendorDir . '/symfony/config'),
|
||||
'Psr\\Log\\' => array($vendorDir . '/psr/log/src'),
|
||||
'Psr\\Container\\' => array($vendorDir . '/psr/container/src'),
|
||||
'PhpParser\\' => array($vendorDir . '/nikic/php-parser/lib/PhpParser'),
|
||||
'PDepend\\' => array($vendorDir . '/pdepend/pdepend/src/main/php/PDepend'),
|
||||
'DeepCopy\\' => array($vendorDir . '/myclabs/deep-copy/src/DeepCopy'),
|
||||
'Composer\\XdebugHandler\\' => array($vendorDir . '/composer/xdebug-handler/src'),
|
||||
'Composer\\Pcre\\' => array($vendorDir . '/composer/pcre/src'),
|
||||
'Com\\Tecnick\\Unicode\\Data\\' => array($vendorDir . '/tecnickcom/tc-lib-unicode-data/src'),
|
||||
'Com\\Tecnick\\Unicode\\' => array($vendorDir . '/tecnickcom/tc-lib-unicode/src'),
|
||||
'Com\\Tecnick\\Pdf\\Page\\' => array($vendorDir . '/tecnickcom/tc-lib-pdf-page/src'),
|
||||
'Com\\Tecnick\\Pdf\\Image\\' => array($vendorDir . '/tecnickcom/tc-lib-pdf-image/src'),
|
||||
'Com\\Tecnick\\Pdf\\Graph\\' => array($vendorDir . '/tecnickcom/tc-lib-pdf-graph/src'),
|
||||
'Com\\Tecnick\\Pdf\\Font\\' => array($vendorDir . '/tecnickcom/tc-lib-pdf-font/src'),
|
||||
'Com\\Tecnick\\Pdf\\Encrypt\\' => array($vendorDir . '/tecnickcom/tc-lib-pdf-encrypt/src'),
|
||||
'Com\\Tecnick\\Pdf\\' => array($baseDir . '/src'),
|
||||
'Com\\Tecnick\\File\\' => array($vendorDir . '/tecnickcom/tc-lib-file/src'),
|
||||
'Com\\Tecnick\\Color\\' => array($vendorDir . '/tecnickcom/tc-lib-color/src'),
|
||||
'Com\\Tecnick\\Barcode\\' => array($vendorDir . '/tecnickcom/tc-lib-barcode/src'),
|
||||
);
|
||||
+50
@@ -0,0 +1,50 @@
|
||||
<?php
|
||||
|
||||
// autoload_real.php @generated by Composer
|
||||
|
||||
class ComposerAutoloaderInit76bb96195740a3fe4b224cf7607d238b
|
||||
{
|
||||
private static $loader;
|
||||
|
||||
public static function loadClassLoader($class)
|
||||
{
|
||||
if ('Composer\Autoload\ClassLoader' === $class) {
|
||||
require __DIR__ . '/ClassLoader.php';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @return \Composer\Autoload\ClassLoader
|
||||
*/
|
||||
public static function getLoader()
|
||||
{
|
||||
if (null !== self::$loader) {
|
||||
return self::$loader;
|
||||
}
|
||||
|
||||
require __DIR__ . '/platform_check.php';
|
||||
|
||||
spl_autoload_register(array('ComposerAutoloaderInit76bb96195740a3fe4b224cf7607d238b', 'loadClassLoader'), true, true);
|
||||
self::$loader = $loader = new \Composer\Autoload\ClassLoader(\dirname(__DIR__));
|
||||
spl_autoload_unregister(array('ComposerAutoloaderInit76bb96195740a3fe4b224cf7607d238b', 'loadClassLoader'));
|
||||
|
||||
require __DIR__ . '/autoload_static.php';
|
||||
call_user_func(\Composer\Autoload\ComposerStaticInit76bb96195740a3fe4b224cf7607d238b::getInitializer($loader));
|
||||
|
||||
$loader->register(true);
|
||||
|
||||
$filesToLoad = \Composer\Autoload\ComposerStaticInit76bb96195740a3fe4b224cf7607d238b::$files;
|
||||
$requireFile = \Closure::bind(static function ($fileIdentifier, $file) {
|
||||
if (empty($GLOBALS['__composer_autoload_files'][$fileIdentifier])) {
|
||||
$GLOBALS['__composer_autoload_files'][$fileIdentifier] = true;
|
||||
|
||||
require $file;
|
||||
}
|
||||
}, null, null);
|
||||
foreach ($filesToLoad as $fileIdentifier => $file) {
|
||||
$requireFile($fileIdentifier, $file);
|
||||
}
|
||||
|
||||
return $loader;
|
||||
}
|
||||
}
|
||||
+1353
File diff suppressed because it is too large.
Load diff
+3665
File diff suppressed because it is too large.
Load diff
+494
@@ -0,0 +1,494 @@
|
||||
<?php return array(
|
||||
'root' => array(
|
||||
'name' => 'tecnickcom/tc-lib-pdf',
|
||||
'pretty_version' => 'dev-main',
|
||||
'version' => 'dev-main',
|
||||
'reference' => 'bbd0ede41c12081b0ec450fb3be71863e20907c2',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../../',
|
||||
'aliases' => array(),
|
||||
'dev' => true,
|
||||
),
|
||||
'versions' => array(
|
||||
'composer/pcre' => array(
|
||||
'pretty_version' => '3.3.2',
|
||||
'version' => '3.3.2.0',
|
||||
'reference' => 'b2bed4734f0cc156ee1fe9c0da2550420d99a21e',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/./pcre',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'composer/xdebug-handler' => array(
|
||||
'pretty_version' => '3.0.5',
|
||||
'version' => '3.0.5.0',
|
||||
'reference' => '6c1925561632e83d60a44492e0b344cf48ab85ef',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/./xdebug-handler',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'myclabs/deep-copy' => array(
|
||||
'pretty_version' => '1.13.4',
|
||||
'version' => '1.13.4.0',
|
||||
'reference' => '07d290f0c47959fd5eed98c95ee5602db07e0b6a',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../myclabs/deep-copy',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'nikic/php-parser' => array(
|
||||
'pretty_version' => 'v5.6.1',
|
||||
'version' => '5.6.1.0',
|
||||
'reference' => 'f103601b29efebd7ff4a1ca7b3eeea9e3336a2a2',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../nikic/php-parser',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'pdepend/pdepend' => array(
|
||||
'pretty_version' => '2.16.2',
|
||||
'version' => '2.16.2.0',
|
||||
'reference' => 'f942b208dc2a0868454d01b29f0c75bbcfc6ed58',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../pdepend/pdepend',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'phar-io/manifest' => array(
|
||||
'pretty_version' => '2.0.4',
|
||||
'version' => '2.0.4.0',
|
||||
'reference' => '54750ef60c58e43759730615a392c31c80e23176',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../phar-io/manifest',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'phar-io/version' => array(
|
||||
'pretty_version' => '3.2.1',
|
||||
'version' => '3.2.1.0',
|
||||
'reference' => '4f7fd7836c6f332bb2933569e566a0d6c4cbed74',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../phar-io/version',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'phpmd/phpmd' => array(
|
||||
'pretty_version' => '2.15.0',
|
||||
'version' => '2.15.0.0',
|
||||
'reference' => '74a1f56e33afad4128b886e334093e98e1b5e7c0',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../phpmd/phpmd',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'phpunit/php-code-coverage' => array(
|
||||
'pretty_version' => '10.1.16',
|
||||
'version' => '10.1.16.0',
|
||||
'reference' => '7e308268858ed6baedc8704a304727d20bc07c77',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../phpunit/php-code-coverage',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'phpunit/php-file-iterator' => array(
|
||||
'pretty_version' => '4.1.0',
|
||||
'version' => '4.1.0.0',
|
||||
'reference' => 'a95037b6d9e608ba092da1b23931e537cadc3c3c',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../phpunit/php-file-iterator',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'phpunit/php-invoker' => array(
|
||||
'pretty_version' => '4.0.0',
|
||||
'version' => '4.0.0.0',
|
||||
'reference' => 'f5e568ba02fa5ba0ddd0f618391d5a9ea50b06d7',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../phpunit/php-invoker',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'phpunit/php-text-template' => array(
|
||||
'pretty_version' => '3.0.1',
|
||||
'version' => '3.0.1.0',
|
||||
'reference' => '0c7b06ff49e3d5072f057eb1fa59258bf287a748',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../phpunit/php-text-template',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'phpunit/php-timer' => array(
|
||||
'pretty_version' => '6.0.0',
|
||||
'version' => '6.0.0.0',
|
||||
'reference' => 'e2a2d67966e740530f4a3343fe2e030ffdc1161d',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../phpunit/php-timer',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'phpunit/phpunit' => array(
|
||||
'pretty_version' => '10.5.40',
|
||||
'version' => '10.5.40.0',
|
||||
'reference' => 'e6ddda95af52f69c1e0c7b4f977cccb58048798c',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../phpunit/phpunit',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'psr/container' => array(
|
||||
'pretty_version' => '2.0.2',
|
||||
'version' => '2.0.2.0',
|
||||
'reference' => 'c71ecc56dfe541dbd90c5360474fbc405f8d5963',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../psr/container',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'psr/container-implementation' => array(
|
||||
'dev_requirement' => true,
|
||||
'provided' => array(
|
||||
0 => '1.1|2.0',
|
||||
),
|
||||
),
|
||||
'psr/log' => array(
|
||||
'pretty_version' => '3.0.2',
|
||||
'version' => '3.0.2.0',
|
||||
'reference' => 'f16e1d5863e37f8d8c2a01719f5b34baa2b714d3',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../psr/log',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'sebastian/cli-parser' => array(
|
||||
'pretty_version' => '2.0.1',
|
||||
'version' => '2.0.1.0',
|
||||
'reference' => 'c34583b87e7b7a8055bf6c450c2c77ce32a24084',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../sebastian/cli-parser',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'sebastian/code-unit' => array(
|
||||
'pretty_version' => '2.0.0',
|
||||
'version' => '2.0.0.0',
|
||||
'reference' => 'a81fee9eef0b7a76af11d121767abc44c104e503',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../sebastian/code-unit',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'sebastian/code-unit-reverse-lookup' => array(
|
||||
'pretty_version' => '3.0.0',
|
||||
'version' => '3.0.0.0',
|
||||
'reference' => '5e3a687f7d8ae33fb362c5c0743794bbb2420a1d',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../sebastian/code-unit-reverse-lookup',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'sebastian/comparator' => array(
|
||||
'pretty_version' => '5.0.4',
|
||||
'version' => '5.0.4.0',
|
||||
'reference' => 'e8e53097718d2b53cfb2aa859b06a41abf58c62e',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../sebastian/comparator',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'sebastian/complexity' => array(
|
||||
'pretty_version' => '3.2.0',
|
||||
'version' => '3.2.0.0',
|
||||
'reference' => '68ff824baeae169ec9f2137158ee529584553799',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../sebastian/complexity',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'sebastian/diff' => array(
|
||||
'pretty_version' => '5.1.1',
|
||||
'version' => '5.1.1.0',
|
||||
'reference' => 'c41e007b4b62af48218231d6c2275e4c9b975b2e',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../sebastian/diff',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'sebastian/environment' => array(
|
||||
'pretty_version' => '6.1.0',
|
||||
'version' => '6.1.0.0',
|
||||
'reference' => '8074dbcd93529b357029f5cc5058fd3e43666984',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../sebastian/environment',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'sebastian/exporter' => array(
|
||||
'pretty_version' => '5.1.4',
|
||||
'version' => '5.1.4.0',
|
||||
'reference' => '0735b90f4da94969541dac1da743446e276defa6',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../sebastian/exporter',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'sebastian/global-state' => array(
|
||||
'pretty_version' => '6.0.2',
|
||||
'version' => '6.0.2.0',
|
||||
'reference' => '987bafff24ecc4c9ac418cab1145b96dd6e9cbd9',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../sebastian/global-state',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'sebastian/lines-of-code' => array(
|
||||
'pretty_version' => '2.0.2',
|
||||
'version' => '2.0.2.0',
|
||||
'reference' => '856e7f6a75a84e339195d48c556f23be2ebf75d0',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../sebastian/lines-of-code',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'sebastian/object-enumerator' => array(
|
||||
'pretty_version' => '5.0.0',
|
||||
'version' => '5.0.0.0',
|
||||
'reference' => '202d0e344a580d7f7d04b3fafce6933e59dae906',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../sebastian/object-enumerator',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'sebastian/object-reflector' => array(
|
||||
'pretty_version' => '3.0.0',
|
||||
'version' => '3.0.0.0',
|
||||
'reference' => '24ed13d98130f0e7122df55d06c5c4942a577957',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../sebastian/object-reflector',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'sebastian/recursion-context' => array(
|
||||
'pretty_version' => '5.0.1',
|
||||
'version' => '5.0.1.0',
|
||||
'reference' => '47e34210757a2f37a97dcd207d032e1b01e64c7a',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../sebastian/recursion-context',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'sebastian/type' => array(
|
||||
'pretty_version' => '4.0.0',
|
||||
'version' => '4.0.0.0',
|
||||
'reference' => '462699a16464c3944eefc02ebdd77882bd3925bf',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../sebastian/type',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'sebastian/version' => array(
|
||||
'pretty_version' => '4.0.1',
|
||||
'version' => '4.0.1.0',
|
||||
'reference' => 'c51fa83a5d8f43f1402e3f32a005e6262244ef17',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../sebastian/version',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'squizlabs/php_codesniffer' => array(
|
||||
'pretty_version' => '3.13.0',
|
||||
'version' => '3.13.0.0',
|
||||
'reference' => '65ff2489553b83b4597e89c3b8b721487011d186',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../squizlabs/php_codesniffer',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'symfony/config' => array(
|
||||
'pretty_version' => 'v6.4.26',
|
||||
'version' => '6.4.26.0',
|
||||
'reference' => 'f18dc5926cb203e125956987def795d052ee774e',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../symfony/config',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'symfony/dependency-injection' => array(
|
||||
'pretty_version' => 'v6.4.26',
|
||||
'version' => '6.4.26.0',
|
||||
'reference' => '5f311eaf0b321f8ec640f6bae12da43a14026898',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../symfony/dependency-injection',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'symfony/deprecation-contracts' => array(
|
||||
'pretty_version' => 'v3.6.0',
|
||||
'version' => '3.6.0.0',
|
||||
'reference' => '63afe740e99a13ba87ec199bb07bbdee937a5b62',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../symfony/deprecation-contracts',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'symfony/filesystem' => array(
|
||||
'pretty_version' => 'v6.4.24',
|
||||
'version' => '6.4.24.0',
|
||||
'reference' => '75ae2edb7cdcc0c53766c30b0a2512b8df574bd8',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../symfony/filesystem',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'symfony/polyfill-ctype' => array(
|
||||
'pretty_version' => 'v1.33.0',
|
||||
'version' => '1.33.0.0',
|
||||
'reference' => 'a3cc8b044a6ea513310cbd48ef7333b384945638',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../symfony/polyfill-ctype',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'symfony/polyfill-mbstring' => array(
|
||||
'pretty_version' => 'v1.33.0',
|
||||
'version' => '1.33.0.0',
|
||||
'reference' => '6d857f4d76bd4b343eac26d6b539585d2bc56493',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../symfony/polyfill-mbstring',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => false,
|
||||
),
|
||||
'symfony/service-contracts' => array(
|
||||
'pretty_version' => 'v3.6.0',
|
||||
'version' => '3.6.0.0',
|
||||
'reference' => 'f021b05a130d35510bd6b25fe9053c2a8a15d5d4',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../symfony/service-contracts',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'symfony/service-implementation' => array(
|
||||
'dev_requirement' => true,
|
||||
'provided' => array(
|
||||
0 => '1.1|2.0|3.0',
|
||||
),
|
||||
),
|
||||
'symfony/var-exporter' => array(
|
||||
'pretty_version' => 'v6.4.26',
|
||||
'version' => '6.4.26.0',
|
||||
'reference' => '466fcac5fa2e871f83d31173f80e9c2684743bfc',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../symfony/var-exporter',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
'tecnickcom/tc-lib-barcode' => array(
|
||||
'pretty_version' => '2.4.8',
|
||||
'version' => '2.4.8.0',
|
||||
'reference' => 'f238ffd120d98a34df6573590e7ed02f766a91c4',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../tecnickcom/tc-lib-barcode',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => false,
|
||||
),
|
||||
'tecnickcom/tc-lib-color' => array(
|
||||
'pretty_version' => '2.2.13',
|
||||
'version' => '2.2.13.0',
|
||||
'reference' => '85d1366fb33813aa521d30e3d7c7d7d82a8103a6',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../tecnickcom/tc-lib-color',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => false,
|
||||
),
|
||||
'tecnickcom/tc-lib-file' => array(
|
||||
'pretty_version' => '2.2.2',
|
||||
'version' => '2.2.2.0',
|
||||
'reference' => 'ec6989700b77baa8a8d88952ad4fd8f53211c370',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../tecnickcom/tc-lib-file',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => false,
|
||||
),
|
||||
'tecnickcom/tc-lib-pdf' => array(
|
||||
'pretty_version' => 'dev-main',
|
||||
'version' => 'dev-main',
|
||||
'reference' => 'bbd0ede41c12081b0ec450fb3be71863e20907c2',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../../',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => false,
|
||||
),
|
||||
'tecnickcom/tc-lib-pdf-encrypt' => array(
|
||||
'pretty_version' => '2.1.16',
|
||||
'version' => '2.1.16.0',
|
||||
'reference' => '4e154df154e586523033187dfc54a2a8e113a7db',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../tecnickcom/tc-lib-pdf-encrypt',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => false,
|
||||
),
|
||||
'tecnickcom/tc-lib-pdf-font' => array(
|
||||
'pretty_version' => '2.6.12',
|
||||
'version' => '2.6.12.0',
|
||||
'reference' => '961ddeb8f02c7186e9efcf37693cbd1f21af1dc1',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../tecnickcom/tc-lib-pdf-font',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => false,
|
||||
),
|
||||
'tecnickcom/tc-lib-pdf-graph' => array(
|
||||
'pretty_version' => '2.3.2',
|
||||
'version' => '2.3.2.0',
|
||||
'reference' => '2125360e68abc1f0fba25e0de2f8f8df9aba4d41',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../tecnickcom/tc-lib-pdf-graph',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => false,
|
||||
),
|
||||
'tecnickcom/tc-lib-pdf-image' => array(
|
||||
'pretty_version' => '2.1.14',
|
||||
'version' => '2.1.14.0',
|
||||
'reference' => 'f9bc757b3fe3b8d675ae993404048cceeb037417',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../tecnickcom/tc-lib-pdf-image',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => false,
|
||||
),
|
||||
'tecnickcom/tc-lib-pdf-page' => array(
|
||||
'pretty_version' => '4.2.12',
|
||||
'version' => '4.2.12.0',
|
||||
'reference' => 'c446d399372df775c5f8c3a5cfc30e85bfb6c102',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../tecnickcom/tc-lib-pdf-page',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => false,
|
||||
),
|
||||
'tecnickcom/tc-lib-unicode' => array(
|
||||
'pretty_version' => '2.0.25',
|
||||
'version' => '2.0.25.0',
|
||||
'reference' => '9165ea29a46a38938097377b3ec518e0fd0a8092',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../tecnickcom/tc-lib-unicode',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => false,
|
||||
),
|
||||
'tecnickcom/tc-lib-unicode-data' => array(
|
||||
'pretty_version' => '2.0.24',
|
||||
'version' => '2.0.24.0',
|
||||
'reference' => 'cc0ac553b70ecfda9ffeda71ca2f490bfaff5036',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../tecnickcom/tc-lib-unicode-data',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => false,
|
||||
),
|
||||
'theseer/tokenizer' => array(
|
||||
'pretty_version' => '1.2.3',
|
||||
'version' => '1.2.3.0',
|
||||
'reference' => '737eda637ed5e28c3413cb1ebe8bb52cbf1ca7a2',
|
||||
'type' => 'library',
|
||||
'install_path' => __DIR__ . '/../theseer/tokenizer',
|
||||
'aliases' => array(),
|
||||
'dev_requirement' => true,
|
||||
),
|
||||
),
|
||||
);
|
||||
+19
@@ -0,0 +1,19 @@
|
||||
Copyright (C) 2021 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.
|
||||
+189
@@ -0,0 +1,189 @@
|
||||
composer/pcre
|
||||
=============
|
||||
|
||||
PCRE wrapping library that offers type-safe `preg_*` replacements.
|
||||
|
||||
This library gives you a way to ensure `preg_*` functions do not fail silently, returning
|
||||
unexpected `null`s that may not be handled.
|
||||
|
||||
As of 3.0 this library enforces [`PREG_UNMATCHED_AS_NULL`](#preg_unmatched_as_null) usage
|
||||
for all matching and replaceCallback functions, [read more below](#preg_unmatched_as_null)
|
||||
to understand the implications.
|
||||
|
||||
It thus makes it easier to work with static analysis tools like PHPStan or Psalm as it
|
||||
simplifies and reduces the possible return values from all the `preg_*` functions which
|
||||
are quite packed with edge cases. As of v2.2.0 / v3.2.0 the library also comes with a
|
||||
[PHPStan extension](#phpstan-extension) for parsing regular expressions and giving you even better output types.
|
||||
|
||||
This library is a thin wrapper around `preg_*` functions with [some limitations](#restrictions--limitations).
|
||||
If you are looking for a richer API to handle regular expressions have a look at
|
||||
[rawr/t-regx](https://packagist.org/packages/rawr/t-regx) instead.
|
||||
|
||||
[](https://github.com/composer/pcre/actions)
|
||||
|
||||
|
||||
Installation
|
||||
------------
|
||||
|
||||
Install the latest version with:
|
||||
|
||||
```bash
|
||||
$ composer require composer/pcre
|
||||
```
|
||||
|
||||
|
||||
Requirements
|
||||
------------
|
||||
|
||||
* PHP 7.4.0 is required for 3.x versions
|
||||
* PHP 7.2.0 is required for 2.x versions
|
||||
* PHP 5.3.2 is required for 1.x versions
|
||||
|
||||
|
||||
Basic usage
|
||||
-----------
|
||||
|
||||
Instead of:
|
||||
|
||||
```php
|
||||
if (preg_match('{fo+}', $string, $matches)) { ... }
|
||||
if (preg_match('{fo+}', $string, $matches, PREG_OFFSET_CAPTURE)) { ... }
|
||||
if (preg_match_all('{fo+}', $string, $matches)) { ... }
|
||||
$newString = preg_replace('{fo+}', 'bar', $string);
|
||||
$newString = preg_replace_callback('{fo+}', function ($match) { return strtoupper($match[0]); }, $string);
|
||||
$newString = preg_replace_callback_array(['{fo+}' => fn ($match) => strtoupper($match[0])], $string);
|
||||
$filtered = preg_grep('{[a-z]}', $elements);
|
||||
$array = preg_split('{[a-z]+}', $string);
|
||||
```
|
||||
|
||||
You can now call these on the `Preg` class:
|
||||
|
||||
```php
|
||||
use Composer\Pcre\Preg;
|
||||
|
||||
if (Preg::match('{fo+}', $string, $matches)) { ... }
|
||||
if (Preg::matchWithOffsets('{fo+}', $string, $matches)) { ... }
|
||||
if (Preg::matchAll('{fo+}', $string, $matches)) { ... }
|
||||
$newString = Preg::replace('{fo+}', 'bar', $string);
|
||||
$newString = Preg::replaceCallback('{fo+}', function ($match) { return strtoupper($match[0]); }, $string);
|
||||
$newString = Preg::replaceCallbackArray(['{fo+}' => fn ($match) => strtoupper($match[0])], $string);
|
||||
$filtered = Preg::grep('{[a-z]}', $elements);
|
||||
$array = Preg::split('{[a-z]+}', $string);
|
||||
```
|
||||
|
||||
The main difference is if anything fails to match/replace/.., it will throw a `Composer\Pcre\PcreException`
|
||||
instead of returning `null` (or false in some cases), so you can now use the return values safely relying on
|
||||
the fact that they can only be strings (for replace), ints (for match) or arrays (for grep/split).
|
||||
|
||||
Additionally the `Preg` class provides match methods that return `bool` rather than `int`, for stricter type safety
|
||||
when the number of pattern matches is not useful:
|
||||
|
||||
```php
|
||||
use Composer\Pcre\Preg;
|
||||
|
||||
if (Preg::isMatch('{fo+}', $string, $matches)) // bool
|
||||
if (Preg::isMatchAll('{fo+}', $string, $matches)) // bool
|
||||
```
|
||||
|
||||
Finally the `Preg` class provides a few `*StrictGroups` method variants that ensure match groups
|
||||
are always present and thus non-nullable, making it easier to write type-safe code:
|
||||
|
||||
```php
|
||||
use Composer\Pcre\Preg;
|
||||
|
||||
// $matches is guaranteed to be an array of strings, if a subpattern does not match and produces a null it will throw
|
||||
if (Preg::matchStrictGroups('{fo+}', $string, $matches))
|
||||
if (Preg::matchAllStrictGroups('{fo+}', $string, $matches))
|
||||
```
|
||||
|
||||
**Note:** This is generally safe to use as long as you do not have optional subpatterns (i.e. `(something)?`
|
||||
or `(something)*` or branches with a `|` that result in some groups not being matched at all).
|
||||
A subpattern that can match an empty string like `(.*)` is **not** optional, it will be present as an
|
||||
empty string in the matches. A non-matching subpattern, even if optional like `(?:foo)?` will anyway not be present in
|
||||
matches so it is also not a problem to use these with `*StrictGroups` methods.
|
||||
|
||||
If you would prefer a slightly more verbose usage, replacing by-ref arguments by result objects, you can use the `Regex` class:
|
||||
|
||||
```php
|
||||
use Composer\Pcre\Regex;
|
||||
|
||||
// this is useful when you are just interested in knowing if something matched
|
||||
// as it returns a bool instead of int(1/0) for match
|
||||
$bool = Regex::isMatch('{fo+}', $string);
|
||||
|
||||
$result = Regex::match('{fo+}', $string);
|
||||
if ($result->matched) { something($result->matches); }
|
||||
|
||||
$result = Regex::matchWithOffsets('{fo+}', $string);
|
||||
if ($result->matched) { something($result->matches); }
|
||||
|
||||
$result = Regex::matchAll('{fo+}', $string);
|
||||
if ($result->matched && $result->count > 3) { something($result->matches); }
|
||||
|
||||
$newString = Regex::replace('{fo+}', 'bar', $string)->result;
|
||||
$newString = Regex::replaceCallback('{fo+}', function ($match) { return strtoupper($match[0]); }, $string)->result;
|
||||
$newString = Regex::replaceCallbackArray(['{fo+}' => fn ($match) => strtoupper($match[0])], $string)->result;
|
||||
```
|
||||
|
||||
Note that `preg_grep` and `preg_split` are only callable via the `Preg` class as they do not have
|
||||
complex return types warranting a specific result object.
|
||||
|
||||
See the [MatchResult](src/MatchResult.php), [MatchWithOffsetsResult](src/MatchWithOffsetsResult.php), [MatchAllResult](src/MatchAllResult.php),
|
||||
[MatchAllWithOffsetsResult](src/MatchAllWithOffsetsResult.php), and [ReplaceResult](src/ReplaceResult.php) class sources for more details.
|
||||
|
||||
Restrictions / Limitations
|
||||
--------------------------
|
||||
|
||||
Due to type safety requirements a few restrictions are in place.
|
||||
|
||||
- matching using `PREG_OFFSET_CAPTURE` is made available via `matchWithOffsets` and `matchAllWithOffsets`.
|
||||
You cannot pass the flag to `match`/`matchAll`.
|
||||
- `Preg::split` will also reject `PREG_SPLIT_OFFSET_CAPTURE` and you should use `splitWithOffsets`
|
||||
instead.
|
||||
- `matchAll` rejects `PREG_SET_ORDER` as it also changes the shape of the returned matches. There
|
||||
is no alternative provided as you can fairly easily code around it.
|
||||
- `preg_filter` is not supported as it has a rather crazy API, most likely you should rather
|
||||
use `Preg::grep` in combination with some loop and `Preg::replace`.
|
||||
- `replace`, `replaceCallback` and `replaceCallbackArray` do not support an array `$subject`,
|
||||
only simple strings.
|
||||
- As of 2.0, the library always uses `PREG_UNMATCHED_AS_NULL` for matching, which offers [much
|
||||
saner/more predictable results](#preg_unmatched_as_null). As of 3.0 the flag is also set for
|
||||
`replaceCallback` and `replaceCallbackArray`.
|
||||
|
||||
#### PREG_UNMATCHED_AS_NULL
|
||||
|
||||
As of 2.0, this library always uses PREG_UNMATCHED_AS_NULL for all `match*` and `isMatch*`
|
||||
functions. As of 3.0 it is also done for `replaceCallback` and `replaceCallbackArray`.
|
||||
|
||||
This means your matches will always contain all matching groups, either as null if unmatched
|
||||
or as string if it matched.
|
||||
|
||||
The advantages in clarity and predictability are clearer if you compare the two outputs of
|
||||
running this with and without PREG_UNMATCHED_AS_NULL in $flags:
|
||||
|
||||
```php
|
||||
preg_match('/(a)(b)*(c)(d)*/', 'ac', $matches, $flags);
|
||||
```
|
||||
|
||||
| no flag | PREG_UNMATCHED_AS_NULL |
|
||||
| --- | --- |
|
||||
| array (size=4) | array (size=5) |
|
||||
| 0 => string 'ac' (length=2) | 0 => string 'ac' (length=2) |
|
||||
| 1 => string 'a' (length=1) | 1 => string 'a' (length=1) |
|
||||
| 2 => string '' (length=0) | 2 => null |
|
||||
| 3 => string 'c' (length=1) | 3 => string 'c' (length=1) |
|
||||
| | 4 => null |
|
||||
| group 2 (any unmatched group preceding one that matched) is set to `''`. You cannot tell if it matched an empty string or did not match at all | group 2 is `null` when unmatched and a string if it matched, easy to check for |
|
||||
| group 4 (any optional group without a matching one following) is missing altogether. So you have to check with `isset()`, but really you want `isset($m[4]) && $m[4] !== ''` for safety unless you are very careful to check that a non-optional group follows it | group 4 is always set, and null in this case as there was no match, easy to check for with `$m[4] !== null` |
|
||||
|
||||
PHPStan Extension
|
||||
-----------------
|
||||
|
||||
To use the PHPStan extension if you do not use `phpstan/extension-installer` you can include `vendor/composer/pcre/extension.neon` in your PHPStan config.
|
||||
|
||||
The extension provides much better type information for $matches as well as regex validation where possible.
|
||||
|
||||
License
|
||||
-------
|
||||
|
||||
composer/pcre is licensed under the MIT License, see the LICENSE file for details.
|
||||
+54
@@ -0,0 +1,54 @@
|
||||
{
|
||||
"name": "composer/pcre",
|
||||
"description": "PCRE wrapping library that offers type-safe preg_* replacements.",
|
||||
"type": "library",
|
||||
"license": "MIT",
|
||||
"keywords": [
|
||||
"pcre",
|
||||
"regex",
|
||||
"preg",
|
||||
"regular expression"
|
||||
],
|
||||
"authors": [
|
||||
{
|
||||
"name": "Jordi Boggiano",
|
||||
"email": "j.boggiano@seld.be",
|
||||
"homepage": "http://seld.be"
|
||||
}
|
||||
],
|
||||
"require": {
|
||||
"php": "^7.4 || ^8.0"
|
||||
},
|
||||
"require-dev": {
|
||||
"phpunit/phpunit": "^8 || ^9",
|
||||
"phpstan/phpstan": "^1.12 || ^2",
|
||||
"phpstan/phpstan-strict-rules": "^1 || ^2"
|
||||
},
|
||||
"conflict": {
|
||||
"phpstan/phpstan": "<1.11.10"
|
||||
},
|
||||
"autoload": {
|
||||
"psr-4": {
|
||||
"Composer\\Pcre\\": "src"
|
||||
}
|
||||
},
|
||||
"autoload-dev": {
|
||||
"psr-4": {
|
||||
"Composer\\Pcre\\": "tests"
|
||||
}
|
||||
},
|
||||
"extra": {
|
||||
"branch-alias": {
|
||||
"dev-main": "3.x-dev"
|
||||
},
|
||||
"phpstan": {
|
||||
"includes": [
|
||||
"extension.neon"
|
||||
]
|
||||
}
|
||||
},
|
||||
"scripts": {
|
||||
"test": "@php vendor/bin/phpunit",
|
||||
"phpstan": "@php phpstan analyse"
|
||||
}
|
||||
}
|
||||
+22
@@ -0,0 +1,22 @@
|
||||
# composer/pcre PHPStan extensions
|
||||
#
|
||||
# These can be reused by third party packages by including 'vendor/composer/pcre/extension.neon'
|
||||
# in your phpstan config
|
||||
|
||||
services:
|
||||
-
|
||||
class: Composer\Pcre\PHPStan\PregMatchParameterOutTypeExtension
|
||||
tags:
|
||||
- phpstan.staticMethodParameterOutTypeExtension
|
||||
-
|
||||
class: Composer\Pcre\PHPStan\PregMatchTypeSpecifyingExtension
|
||||
tags:
|
||||
- phpstan.typeSpecifier.staticMethodTypeSpecifyingExtension
|
||||
-
|
||||
class: Composer\Pcre\PHPStan\PregReplaceCallbackClosureTypeExtension
|
||||
tags:
|
||||
- phpstan.staticMethodParameterClosureTypeExtension
|
||||
|
||||
rules:
|
||||
- Composer\Pcre\PHPStan\UnsafeStrictGroupsCallRule
|
||||
- Composer\Pcre\PHPStan\InvalidRegexPatternRule
|
||||
@@ -0,0 +1,46 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of composer/pcre.
|
||||
*
|
||||
* (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\Pcre;
|
||||
|
||||
final class MatchAllResult
|
||||
{
|
||||
/**
|
||||
* An array of match group => list of matched strings
|
||||
*
|
||||
* @readonly
|
||||
* @var array<int|string, list<string|null>>
|
||||
*/
|
||||
public $matches;
|
||||
|
||||
/**
|
||||
* @readonly
|
||||
* @var 0|positive-int
|
||||
*/
|
||||
public $count;
|
||||
|
||||
/**
|
||||
* @readonly
|
||||
* @var bool
|
||||
*/
|
||||
public $matched;
|
||||
|
||||
/**
|
||||
* @param 0|positive-int $count
|
||||
* @param array<int|string, list<string|null>> $matches
|
||||
*/
|
||||
public function __construct(int $count, array $matches)
|
||||
{
|
||||
$this->matches = $matches;
|
||||
$this->matched = (bool) $count;
|
||||
$this->count = $count;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of composer/pcre.
|
||||
*
|
||||
* (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\Pcre;
|
||||
|
||||
final class MatchAllStrictGroupsResult
|
||||
{
|
||||
/**
|
||||
* An array of match group => list of matched strings
|
||||
*
|
||||
* @readonly
|
||||
* @var array<int|string, list<string>>
|
||||
*/
|
||||
public $matches;
|
||||
|
||||
/**
|
||||
* @readonly
|
||||
* @var 0|positive-int
|
||||
*/
|
||||
public $count;
|
||||
|
||||
/**
|
||||
* @readonly
|
||||
* @var bool
|
||||
*/
|
||||
public $matched;
|
||||
|
||||
/**
|
||||
* @param 0|positive-int $count
|
||||
* @param array<list<string>> $matches
|
||||
*/
|
||||
public function __construct(int $count, array $matches)
|
||||
{
|
||||
$this->matches = $matches;
|
||||
$this->matched = (bool) $count;
|
||||
$this->count = $count;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of composer/pcre.
|
||||
*
|
||||
* (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\Pcre;
|
||||
|
||||
final class MatchAllWithOffsetsResult
|
||||
{
|
||||
/**
|
||||
* An array of match group => list of matches, every match being a pair of string matched + offset in bytes (or -1 if no match)
|
||||
*
|
||||
* @readonly
|
||||
* @var array<int|string, list<array{string|null, int}>>
|
||||
* @phpstan-var array<int|string, list<array{string|null, int<-1, max>}>>
|
||||
*/
|
||||
public $matches;
|
||||
|
||||
/**
|
||||
* @readonly
|
||||
* @var 0|positive-int
|
||||
*/
|
||||
public $count;
|
||||
|
||||
/**
|
||||
* @readonly
|
||||
* @var bool
|
||||
*/
|
||||
public $matched;
|
||||
|
||||
/**
|
||||
* @param 0|positive-int $count
|
||||
* @param array<int|string, list<array{string|null, int}>> $matches
|
||||
* @phpstan-param array<int|string, list<array{string|null, int<-1, max>}>> $matches
|
||||
*/
|
||||
public function __construct(int $count, array $matches)
|
||||
{
|
||||
$this->matches = $matches;
|
||||
$this->matched = (bool) $count;
|
||||
$this->count = $count;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of composer/pcre.
|
||||
*
|
||||
* (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\Pcre;
|
||||
|
||||
final class MatchResult
|
||||
{
|
||||
/**
|
||||
* An array of match group => string matched
|
||||
*
|
||||
* @readonly
|
||||
* @var array<int|string, string|null>
|
||||
*/
|
||||
public $matches;
|
||||
|
||||
/**
|
||||
* @readonly
|
||||
* @var bool
|
||||
*/
|
||||
public $matched;
|
||||
|
||||
/**
|
||||
* @param 0|positive-int $count
|
||||
* @param array<string|null> $matches
|
||||
*/
|
||||
public function __construct(int $count, array $matches)
|
||||
{
|
||||
$this->matches = $matches;
|
||||
$this->matched = (bool) $count;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of composer/pcre.
|
||||
*
|
||||
* (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\Pcre;
|
||||
|
||||
final class MatchStrictGroupsResult
|
||||
{
|
||||
/**
|
||||
* An array of match group => string matched
|
||||
*
|
||||
* @readonly
|
||||
* @var array<int|string, string>
|
||||
*/
|
||||
public $matches;
|
||||
|
||||
/**
|
||||
* @readonly
|
||||
* @var bool
|
||||
*/
|
||||
public $matched;
|
||||
|
||||
/**
|
||||
* @param 0|positive-int $count
|
||||
* @param array<string> $matches
|
||||
*/
|
||||
public function __construct(int $count, array $matches)
|
||||
{
|
||||
$this->matches = $matches;
|
||||
$this->matched = (bool) $count;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of composer/pcre.
|
||||
*
|
||||
* (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\Pcre;
|
||||
|
||||
final class MatchWithOffsetsResult
|
||||
{
|
||||
/**
|
||||
* An array of match group => pair of string matched + offset in bytes (or -1 if no match)
|
||||
*
|
||||
* @readonly
|
||||
* @var array<int|string, array{string|null, int}>
|
||||
* @phpstan-var array<int|string, array{string|null, int<-1, max>}>
|
||||
*/
|
||||
public $matches;
|
||||
|
||||
/**
|
||||
* @readonly
|
||||
* @var bool
|
||||
*/
|
||||
public $matched;
|
||||
|
||||
/**
|
||||
* @param 0|positive-int $count
|
||||
* @param array<array{string|null, int}> $matches
|
||||
* @phpstan-param array<int|string, array{string|null, int<-1, max>}> $matches
|
||||
*/
|
||||
public function __construct(int $count, array $matches)
|
||||
{
|
||||
$this->matches = $matches;
|
||||
$this->matched = (bool) $count;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,142 @@
|
||||
<?php declare(strict_types = 1);
|
||||
|
||||
namespace Composer\Pcre\PHPStan;
|
||||
|
||||
use Composer\Pcre\Preg;
|
||||
use Composer\Pcre\Regex;
|
||||
use Composer\Pcre\PcreException;
|
||||
use Nette\Utils\RegexpException;
|
||||
use Nette\Utils\Strings;
|
||||
use PhpParser\Node;
|
||||
use PhpParser\Node\Expr\StaticCall;
|
||||
use PhpParser\Node\Name\FullyQualified;
|
||||
use PHPStan\Analyser\Scope;
|
||||
use PHPStan\Rules\Rule;
|
||||
use PHPStan\Rules\RuleErrorBuilder;
|
||||
use function in_array;
|
||||
use function sprintf;
|
||||
|
||||
/**
|
||||
* Copy of PHPStan's RegularExpressionPatternRule
|
||||
*
|
||||
* @implements Rule<StaticCall>
|
||||
*/
|
||||
class InvalidRegexPatternRule implements Rule
|
||||
{
|
||||
public function getNodeType(): string
|
||||
{
|
||||
return StaticCall::class;
|
||||
}
|
||||
|
||||
public function processNode(Node $node, Scope $scope): array
|
||||
{
|
||||
$patterns = $this->extractPatterns($node, $scope);
|
||||
|
||||
$errors = [];
|
||||
foreach ($patterns as $pattern) {
|
||||
$errorMessage = $this->validatePattern($pattern);
|
||||
if ($errorMessage === null) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$errors[] = RuleErrorBuilder::message(sprintf('Regex pattern is invalid: %s', $errorMessage))->identifier('regexp.pattern')->build();
|
||||
}
|
||||
|
||||
return $errors;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return string[]
|
||||
*/
|
||||
private function extractPatterns(StaticCall $node, Scope $scope): array
|
||||
{
|
||||
if (!$node->class instanceof FullyQualified) {
|
||||
return [];
|
||||
}
|
||||
$isRegex = $node->class->toString() === Regex::class;
|
||||
$isPreg = $node->class->toString() === Preg::class;
|
||||
if (!$isRegex && !$isPreg) {
|
||||
return [];
|
||||
}
|
||||
if (!$node->name instanceof Node\Identifier || !Preg::isMatch('{^(match|isMatch|grep|replace|split)}', $node->name->name)) {
|
||||
return [];
|
||||
}
|
||||
|
||||
$functionName = $node->name->name;
|
||||
if (!isset($node->getArgs()[0])) {
|
||||
return [];
|
||||
}
|
||||
|
||||
$patternNode = $node->getArgs()[0]->value;
|
||||
$patternType = $scope->getType($patternNode);
|
||||
|
||||
$patternStrings = [];
|
||||
|
||||
foreach ($patternType->getConstantStrings() as $constantStringType) {
|
||||
if ($functionName === 'replaceCallbackArray') {
|
||||
continue;
|
||||
}
|
||||
|
||||
$patternStrings[] = $constantStringType->getValue();
|
||||
}
|
||||
|
||||
foreach ($patternType->getConstantArrays() as $constantArrayType) {
|
||||
if (
|
||||
in_array($functionName, [
|
||||
'replace',
|
||||
'replaceCallback',
|
||||
], true)
|
||||
) {
|
||||
foreach ($constantArrayType->getValueTypes() as $arrayKeyType) {
|
||||
foreach ($arrayKeyType->getConstantStrings() as $constantString) {
|
||||
$patternStrings[] = $constantString->getValue();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ($functionName !== 'replaceCallbackArray') {
|
||||
continue;
|
||||
}
|
||||
|
||||
foreach ($constantArrayType->getKeyTypes() as $arrayKeyType) {
|
||||
foreach ($arrayKeyType->getConstantStrings() as $constantString) {
|
||||
$patternStrings[] = $constantString->getValue();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return $patternStrings;
|
||||
}
|
||||
|
||||
private function validatePattern(string $pattern): ?string
|
||||
{
|
||||
try {
|
||||
$msg = null;
|
||||
$prev = set_error_handler(function (int $severity, string $message, string $file) use (&$msg): bool {
|
||||
$msg = preg_replace("#^preg_match(_all)?\\(.*?\\): #", '', $message);
|
||||
|
||||
return true;
|
||||
});
|
||||
|
||||
if ($pattern === '') {
|
||||
return 'Empty string is not a valid regular expression';
|
||||
}
|
||||
|
||||
Preg::match($pattern, '');
|
||||
if ($msg !== null) {
|
||||
return $msg;
|
||||
}
|
||||
} catch (PcreException $e) {
|
||||
if ($e->getCode() === PREG_INTERNAL_ERROR && $msg !== null) {
|
||||
return $msg;
|
||||
}
|
||||
|
||||
return preg_replace('{.*? failed executing ".*": }', '', $e->getMessage());
|
||||
} finally {
|
||||
restore_error_handler();
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
<?php declare(strict_types=1);
|
||||
|
||||
namespace Composer\Pcre\PHPStan;
|
||||
|
||||
use PHPStan\Analyser\Scope;
|
||||
use PHPStan\Type\ArrayType;
|
||||
use PHPStan\Type\Constant\ConstantArrayType;
|
||||
use PHPStan\Type\Constant\ConstantIntegerType;
|
||||
use PHPStan\Type\IntersectionType;
|
||||
use PHPStan\Type\TypeCombinator;
|
||||
use PHPStan\Type\Type;
|
||||
use PhpParser\Node\Arg;
|
||||
use PHPStan\Type\Php\RegexArrayShapeMatcher;
|
||||
use PHPStan\Type\TypeTraverser;
|
||||
use PHPStan\Type\UnionType;
|
||||
|
||||
final class PregMatchFlags
|
||||
{
|
||||
static public function getType(?Arg $flagsArg, Scope $scope): ?Type
|
||||
{
|
||||
if ($flagsArg === null) {
|
||||
return new ConstantIntegerType(PREG_UNMATCHED_AS_NULL);
|
||||
}
|
||||
|
||||
$flagsType = $scope->getType($flagsArg->value);
|
||||
|
||||
$constantScalars = $flagsType->getConstantScalarValues();
|
||||
if ($constantScalars === []) {
|
||||
return null;
|
||||
}
|
||||
|
||||
$internalFlagsTypes = [];
|
||||
foreach ($flagsType->getConstantScalarValues() as $constantScalarValue) {
|
||||
if (!is_int($constantScalarValue)) {
|
||||
return null;
|
||||
}
|
||||
|
||||
$internalFlagsTypes[] = new ConstantIntegerType($constantScalarValue | PREG_UNMATCHED_AS_NULL);
|
||||
}
|
||||
return TypeCombinator::union(...$internalFlagsTypes);
|
||||
}
|
||||
|
||||
static public function removeNullFromMatches(Type $matchesType): Type
|
||||
{
|
||||
return TypeTraverser::map($matchesType, static function (Type $type, callable $traverse): Type {
|
||||
if ($type instanceof UnionType || $type instanceof IntersectionType) {
|
||||
return $traverse($type);
|
||||
}
|
||||
|
||||
if ($type instanceof ConstantArrayType) {
|
||||
return new ConstantArrayType(
|
||||
$type->getKeyTypes(),
|
||||
array_map(static function (Type $valueType) use ($traverse): Type {
|
||||
return $traverse($valueType);
|
||||
}, $type->getValueTypes()),
|
||||
$type->getNextAutoIndexes(),
|
||||
[],
|
||||
$type->isList()
|
||||
);
|
||||
}
|
||||
|
||||
if ($type instanceof ArrayType) {
|
||||
return new ArrayType($type->getKeyType(), $traverse($type->getItemType()));
|
||||
}
|
||||
|
||||
return TypeCombinator::removeNull($type);
|
||||
});
|
||||
}
|
||||
|
||||
}
|
||||
+65
@@ -0,0 +1,65 @@
|
||||
<?php declare(strict_types=1);
|
||||
|
||||
namespace Composer\Pcre\PHPStan;
|
||||
|
||||
use Composer\Pcre\Preg;
|
||||
use PhpParser\Node\Expr\StaticCall;
|
||||
use PHPStan\Analyser\Scope;
|
||||
use PHPStan\Reflection\MethodReflection;
|
||||
use PHPStan\Reflection\ParameterReflection;
|
||||
use PHPStan\TrinaryLogic;
|
||||
use PHPStan\Type\Php\RegexArrayShapeMatcher;
|
||||
use PHPStan\Type\StaticMethodParameterOutTypeExtension;
|
||||
use PHPStan\Type\Type;
|
||||
|
||||
final class PregMatchParameterOutTypeExtension implements StaticMethodParameterOutTypeExtension
|
||||
{
|
||||
/**
|
||||
* @var RegexArrayShapeMatcher
|
||||
*/
|
||||
private $regexShapeMatcher;
|
||||
|
||||
public function __construct(
|
||||
RegexArrayShapeMatcher $regexShapeMatcher
|
||||
)
|
||||
{
|
||||
$this->regexShapeMatcher = $regexShapeMatcher;
|
||||
}
|
||||
|
||||
public function isStaticMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool
|
||||
{
|
||||
return
|
||||
$methodReflection->getDeclaringClass()->getName() === Preg::class
|
||||
&& in_array($methodReflection->getName(), [
|
||||
'match', 'isMatch', 'matchStrictGroups', 'isMatchStrictGroups',
|
||||
'matchAll', 'isMatchAll', 'matchAllStrictGroups', 'isMatchAllStrictGroups'
|
||||
], true)
|
||||
&& $parameter->getName() === 'matches';
|
||||
}
|
||||
|
||||
public function getParameterOutTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type
|
||||
{
|
||||
$args = $methodCall->getArgs();
|
||||
$patternArg = $args[0] ?? null;
|
||||
$matchesArg = $args[2] ?? null;
|
||||
$flagsArg = $args[3] ?? null;
|
||||
|
||||
if (
|
||||
$patternArg === null || $matchesArg === null
|
||||
) {
|
||||
return null;
|
||||
}
|
||||
|
||||
$flagsType = PregMatchFlags::getType($flagsArg, $scope);
|
||||
if ($flagsType === null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
if (stripos($methodReflection->getName(), 'matchAll') !== false) {
|
||||
return $this->regexShapeMatcher->matchAllExpr($patternArg->value, $flagsType, TrinaryLogic::createMaybe(), $scope);
|
||||
}
|
||||
|
||||
return $this->regexShapeMatcher->matchExpr($patternArg->value, $flagsType, TrinaryLogic::createMaybe(), $scope);
|
||||
}
|
||||
|
||||
}
|
||||
+119
@@ -0,0 +1,119 @@
|
||||
<?php declare(strict_types=1);
|
||||
|
||||
namespace Composer\Pcre\PHPStan;
|
||||
|
||||
use Composer\Pcre\Preg;
|
||||
use PhpParser\Node\Expr\StaticCall;
|
||||
use PHPStan\Analyser\Scope;
|
||||
use PHPStan\Analyser\SpecifiedTypes;
|
||||
use PHPStan\Analyser\TypeSpecifier;
|
||||
use PHPStan\Analyser\TypeSpecifierAwareExtension;
|
||||
use PHPStan\Analyser\TypeSpecifierContext;
|
||||
use PHPStan\Reflection\MethodReflection;
|
||||
use PHPStan\TrinaryLogic;
|
||||
use PHPStan\Type\Constant\ConstantArrayType;
|
||||
use PHPStan\Type\Php\RegexArrayShapeMatcher;
|
||||
use PHPStan\Type\StaticMethodTypeSpecifyingExtension;
|
||||
use PHPStan\Type\TypeCombinator;
|
||||
use PHPStan\Type\Type;
|
||||
|
||||
final class PregMatchTypeSpecifyingExtension implements StaticMethodTypeSpecifyingExtension, TypeSpecifierAwareExtension
|
||||
{
|
||||
/**
|
||||
* @var TypeSpecifier
|
||||
*/
|
||||
private $typeSpecifier;
|
||||
|
||||
/**
|
||||
* @var RegexArrayShapeMatcher
|
||||
*/
|
||||
private $regexShapeMatcher;
|
||||
|
||||
public function __construct(RegexArrayShapeMatcher $regexShapeMatcher)
|
||||
{
|
||||
$this->regexShapeMatcher = $regexShapeMatcher;
|
||||
}
|
||||
|
||||
public function setTypeSpecifier(TypeSpecifier $typeSpecifier): void
|
||||
{
|
||||
$this->typeSpecifier = $typeSpecifier;
|
||||
}
|
||||
|
||||
public function getClass(): string
|
||||
{
|
||||
return Preg::class;
|
||||
}
|
||||
|
||||
public function isStaticMethodSupported(MethodReflection $methodReflection, StaticCall $node, TypeSpecifierContext $context): bool
|
||||
{
|
||||
return in_array($methodReflection->getName(), [
|
||||
'match', 'isMatch', 'matchStrictGroups', 'isMatchStrictGroups',
|
||||
'matchAll', 'isMatchAll', 'matchAllStrictGroups', 'isMatchAllStrictGroups'
|
||||
], true)
|
||||
&& !$context->null();
|
||||
}
|
||||
|
||||
public function specifyTypes(MethodReflection $methodReflection, StaticCall $node, Scope $scope, TypeSpecifierContext $context): SpecifiedTypes
|
||||
{
|
||||
$args = $node->getArgs();
|
||||
$patternArg = $args[0] ?? null;
|
||||
$matchesArg = $args[2] ?? null;
|
||||
$flagsArg = $args[3] ?? null;
|
||||
|
||||
if (
|
||||
$patternArg === null || $matchesArg === null
|
||||
) {
|
||||
return new SpecifiedTypes();
|
||||
}
|
||||
|
||||
$flagsType = PregMatchFlags::getType($flagsArg, $scope);
|
||||
if ($flagsType === null) {
|
||||
return new SpecifiedTypes();
|
||||
}
|
||||
|
||||
if (stripos($methodReflection->getName(), 'matchAll') !== false) {
|
||||
$matchedType = $this->regexShapeMatcher->matchAllExpr($patternArg->value, $flagsType, TrinaryLogic::createFromBoolean($context->true()), $scope);
|
||||
} else {
|
||||
$matchedType = $this->regexShapeMatcher->matchExpr($patternArg->value, $flagsType, TrinaryLogic::createFromBoolean($context->true()), $scope);
|
||||
}
|
||||
|
||||
if ($matchedType === null) {
|
||||
return new SpecifiedTypes();
|
||||
}
|
||||
|
||||
if (
|
||||
in_array($methodReflection->getName(), ['matchStrictGroups', 'isMatchStrictGroups', 'matchAllStrictGroups', 'isMatchAllStrictGroups'], true)
|
||||
) {
|
||||
$matchedType = PregMatchFlags::removeNullFromMatches($matchedType);
|
||||
}
|
||||
|
||||
$overwrite = false;
|
||||
if ($context->false()) {
|
||||
$overwrite = true;
|
||||
$context = $context->negate();
|
||||
}
|
||||
|
||||
// @phpstan-ignore function.alreadyNarrowedType
|
||||
if (method_exists('PHPStan\Analyser\SpecifiedTypes', 'setRootExpr')) {
|
||||
$typeSpecifier = $this->typeSpecifier->create(
|
||||
$matchesArg->value,
|
||||
$matchedType,
|
||||
$context,
|
||||
$scope
|
||||
)->setRootExpr($node);
|
||||
|
||||
return $overwrite ? $typeSpecifier->setAlwaysOverwriteTypes() : $typeSpecifier;
|
||||
}
|
||||
|
||||
// @phpstan-ignore arguments.count
|
||||
return $this->typeSpecifier->create(
|
||||
$matchesArg->value,
|
||||
$matchedType,
|
||||
$context,
|
||||
// @phpstan-ignore argument.type
|
||||
$overwrite,
|
||||
$scope,
|
||||
$node
|
||||
);
|
||||
}
|
||||
}
|
||||
+91
@@ -0,0 +1,91 @@
|
||||
<?php declare(strict_types=1);
|
||||
|
||||
namespace Composer\Pcre\PHPStan;
|
||||
|
||||
use Composer\Pcre\Preg;
|
||||
use Composer\Pcre\Regex;
|
||||
use PhpParser\Node\Expr\StaticCall;
|
||||
use PHPStan\Analyser\Scope;
|
||||
use PHPStan\Reflection\MethodReflection;
|
||||
use PHPStan\Reflection\Native\NativeParameterReflection;
|
||||
use PHPStan\Reflection\ParameterReflection;
|
||||
use PHPStan\TrinaryLogic;
|
||||
use PHPStan\Type\ClosureType;
|
||||
use PHPStan\Type\Constant\ConstantArrayType;
|
||||
use PHPStan\Type\Php\RegexArrayShapeMatcher;
|
||||
use PHPStan\Type\StaticMethodParameterClosureTypeExtension;
|
||||
use PHPStan\Type\StringType;
|
||||
use PHPStan\Type\TypeCombinator;
|
||||
use PHPStan\Type\Type;
|
||||
|
||||
final class PregReplaceCallbackClosureTypeExtension implements StaticMethodParameterClosureTypeExtension
|
||||
{
|
||||
/**
|
||||
* @var RegexArrayShapeMatcher
|
||||
*/
|
||||
private $regexShapeMatcher;
|
||||
|
||||
public function __construct(RegexArrayShapeMatcher $regexShapeMatcher)
|
||||
{
|
||||
$this->regexShapeMatcher = $regexShapeMatcher;
|
||||
}
|
||||
|
||||
public function isStaticMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool
|
||||
{
|
||||
return in_array($methodReflection->getDeclaringClass()->getName(), [Preg::class, Regex::class], true)
|
||||
&& in_array($methodReflection->getName(), ['replaceCallback', 'replaceCallbackStrictGroups'], true)
|
||||
&& $parameter->getName() === 'replacement';
|
||||
}
|
||||
|
||||
public function getTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type
|
||||
{
|
||||
$args = $methodCall->getArgs();
|
||||
$patternArg = $args[0] ?? null;
|
||||
$flagsArg = $args[5] ?? null;
|
||||
|
||||
if (
|
||||
$patternArg === null
|
||||
) {
|
||||
return null;
|
||||
}
|
||||
|
||||
$flagsType = PregMatchFlags::getType($flagsArg, $scope);
|
||||
|
||||
$matchesType = $this->regexShapeMatcher->matchExpr($patternArg->value, $flagsType, TrinaryLogic::createYes(), $scope);
|
||||
if ($matchesType === null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
if ($methodReflection->getName() === 'replaceCallbackStrictGroups' && count($matchesType->getConstantArrays()) === 1) {
|
||||
$matchesType = $matchesType->getConstantArrays()[0];
|
||||
$matchesType = new ConstantArrayType(
|
||||
$matchesType->getKeyTypes(),
|
||||
array_map(static function (Type $valueType): Type {
|
||||
if (count($valueType->getConstantArrays()) === 1) {
|
||||
$valueTypeArray = $valueType->getConstantArrays()[0];
|
||||
return new ConstantArrayType(
|
||||
$valueTypeArray->getKeyTypes(),
|
||||
array_map(static function (Type $valueType): Type {
|
||||
return TypeCombinator::removeNull($valueType);
|
||||
}, $valueTypeArray->getValueTypes()),
|
||||
$valueTypeArray->getNextAutoIndexes(),
|
||||
[],
|
||||
$valueTypeArray->isList()
|
||||
);
|
||||
}
|
||||
return TypeCombinator::removeNull($valueType);
|
||||
}, $matchesType->getValueTypes()),
|
||||
$matchesType->getNextAutoIndexes(),
|
||||
[],
|
||||
$matchesType->isList()
|
||||
);
|
||||
}
|
||||
|
||||
return new ClosureType(
|
||||
[
|
||||
new NativeParameterReflection($parameter->getName(), $parameter->isOptional(), $matchesType, $parameter->passedByReference(), $parameter->isVariadic(), $parameter->getDefaultValue()),
|
||||
],
|
||||
new StringType()
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,112 @@
|
||||
<?php declare(strict_types=1);
|
||||
|
||||
namespace Composer\Pcre\PHPStan;
|
||||
|
||||
use Composer\Pcre\Preg;
|
||||
use Composer\Pcre\Regex;
|
||||
use PhpParser\Node;
|
||||
use PhpParser\Node\Expr\StaticCall;
|
||||
use PhpParser\Node\Name\FullyQualified;
|
||||
use PHPStan\Analyser\Scope;
|
||||
use PHPStan\Analyser\SpecifiedTypes;
|
||||
use PHPStan\Rules\Rule;
|
||||
use PHPStan\Rules\RuleErrorBuilder;
|
||||
use PHPStan\TrinaryLogic;
|
||||
use PHPStan\Type\ObjectType;
|
||||
use PHPStan\Type\Type;
|
||||
use PHPStan\Type\TypeCombinator;
|
||||
use PHPStan\Type\Php\RegexArrayShapeMatcher;
|
||||
use function sprintf;
|
||||
|
||||
/**
|
||||
* @implements Rule<StaticCall>
|
||||
*/
|
||||
final class UnsafeStrictGroupsCallRule implements Rule
|
||||
{
|
||||
/**
|
||||
* @var RegexArrayShapeMatcher
|
||||
*/
|
||||
private $regexShapeMatcher;
|
||||
|
||||
public function __construct(RegexArrayShapeMatcher $regexShapeMatcher)
|
||||
{
|
||||
$this->regexShapeMatcher = $regexShapeMatcher;
|
||||
}
|
||||
|
||||
public function getNodeType(): string
|
||||
{
|
||||
return StaticCall::class;
|
||||
}
|
||||
|
||||
public function processNode(Node $node, Scope $scope): array
|
||||
{
|
||||
if (!$node->class instanceof FullyQualified) {
|
||||
return [];
|
||||
}
|
||||
$isRegex = $node->class->toString() === Regex::class;
|
||||
$isPreg = $node->class->toString() === Preg::class;
|
||||
if (!$isRegex && !$isPreg) {
|
||||
return [];
|
||||
}
|
||||
if (!$node->name instanceof Node\Identifier || !in_array($node->name->name, ['matchStrictGroups', 'isMatchStrictGroups', 'matchAllStrictGroups', 'isMatchAllStrictGroups'], true)) {
|
||||
return [];
|
||||
}
|
||||
|
||||
$args = $node->getArgs();
|
||||
if (!isset($args[0])) {
|
||||
return [];
|
||||
}
|
||||
|
||||
$patternArg = $args[0] ?? null;
|
||||
if ($isPreg) {
|
||||
if (!isset($args[2])) { // no matches set, skip as the matches won't be used anyway
|
||||
return [];
|
||||
}
|
||||
$flagsArg = $args[3] ?? null;
|
||||
} else {
|
||||
$flagsArg = $args[2] ?? null;
|
||||
}
|
||||
|
||||
if ($patternArg === null) {
|
||||
return [];
|
||||
}
|
||||
|
||||
$flagsType = PregMatchFlags::getType($flagsArg, $scope);
|
||||
if ($flagsType === null) {
|
||||
return [];
|
||||
}
|
||||
|
||||
$matchedType = $this->regexShapeMatcher->matchExpr($patternArg->value, $flagsType, TrinaryLogic::createYes(), $scope);
|
||||
if ($matchedType === null) {
|
||||
return [
|
||||
RuleErrorBuilder::message(sprintf('The %s call is potentially unsafe as $matches\' type could not be inferred.', $node->name->name))
|
||||
->identifier('composerPcre.maybeUnsafeStrictGroups')
|
||||
->build(),
|
||||
];
|
||||
}
|
||||
|
||||
if (count($matchedType->getConstantArrays()) === 1) {
|
||||
$matchedType = $matchedType->getConstantArrays()[0];
|
||||
$nullableGroups = [];
|
||||
foreach ($matchedType->getValueTypes() as $index => $type) {
|
||||
if (TypeCombinator::containsNull($type)) {
|
||||
$nullableGroups[] = $matchedType->getKeyTypes()[$index]->getValue();
|
||||
}
|
||||
}
|
||||
|
||||
if (\count($nullableGroups) > 0) {
|
||||
return [
|
||||
RuleErrorBuilder::message(sprintf(
|
||||
'The %s call is unsafe as match group%s "%s" %s optional and may be null.',
|
||||
$node->name->name,
|
||||
\count($nullableGroups) > 1 ? 's' : '',
|
||||
implode('", "', $nullableGroups),
|
||||
\count($nullableGroups) > 1 ? 'are' : 'is'
|
||||
))->identifier('composerPcre.unsafeStrictGroups')->build(),
|
||||
];
|
||||
}
|
||||
}
|
||||
|
||||
return [];
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of composer/pcre.
|
||||
*
|
||||
* (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\Pcre;
|
||||
|
||||
class PcreException extends \RuntimeException
|
||||
{
|
||||
/**
|
||||
* @param string $function
|
||||
* @param string|string[] $pattern
|
||||
* @return self
|
||||
*/
|
||||
public static function fromFunction($function, $pattern)
|
||||
{
|
||||
$code = preg_last_error();
|
||||
|
||||
if (is_array($pattern)) {
|
||||
$pattern = implode(', ', $pattern);
|
||||
}
|
||||
|
||||
return new PcreException($function.'(): failed executing "'.$pattern.'": '.self::pcreLastErrorMessage($code), $code);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param int $code
|
||||
* @return string
|
||||
*/
|
||||
private static function pcreLastErrorMessage($code)
|
||||
{
|
||||
if (function_exists('preg_last_error_msg')) {
|
||||
return preg_last_error_msg();
|
||||
}
|
||||
|
||||
$constants = get_defined_constants(true);
|
||||
if (!isset($constants['pcre']) || !is_array($constants['pcre'])) {
|
||||
return 'UNDEFINED_ERROR';
|
||||
}
|
||||
|
||||
foreach ($constants['pcre'] as $const => $val) {
|
||||
if ($val === $code && substr($const, -6) === '_ERROR') {
|
||||
return $const;
|
||||
}
|
||||
}
|
||||
|
||||
return 'UNDEFINED_ERROR';
|
||||
}
|
||||
}
|
||||
+430
@@ -0,0 +1,430 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of composer/pcre.
|
||||
*
|
||||
* (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\Pcre;
|
||||
|
||||
class Preg
|
||||
{
|
||||
/** @internal */
|
||||
public const ARRAY_MSG = '$subject as an array is not supported. You can use \'foreach\' instead.';
|
||||
/** @internal */
|
||||
public const INVALID_TYPE_MSG = '$subject must be a string, %s given.';
|
||||
|
||||
/**
|
||||
* @param non-empty-string $pattern
|
||||
* @param array<mixed> $matches Set by method
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL> $flags PREG_UNMATCHED_AS_NULL is always set, no other flags are supported
|
||||
* @return 0|1
|
||||
*
|
||||
* @param-out array<int|string, string|null> $matches
|
||||
*/
|
||||
public static function match(string $pattern, string $subject, ?array &$matches = null, int $flags = 0, int $offset = 0): int
|
||||
{
|
||||
self::checkOffsetCapture($flags, 'matchWithOffsets');
|
||||
|
||||
$result = preg_match($pattern, $subject, $matches, $flags | PREG_UNMATCHED_AS_NULL, $offset);
|
||||
if ($result === false) {
|
||||
throw PcreException::fromFunction('preg_match', $pattern);
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Variant of `match()` which outputs non-null matches (or throws)
|
||||
*
|
||||
* @param non-empty-string $pattern
|
||||
* @param array<mixed> $matches Set by method
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL> $flags PREG_UNMATCHED_AS_NULL is always set, no other flags are supported
|
||||
* @return 0|1
|
||||
* @throws UnexpectedNullMatchException
|
||||
*
|
||||
* @param-out array<int|string, string> $matches
|
||||
*/
|
||||
public static function matchStrictGroups(string $pattern, string $subject, ?array &$matches = null, int $flags = 0, int $offset = 0): int
|
||||
{
|
||||
$result = self::match($pattern, $subject, $matchesInternal, $flags, $offset);
|
||||
$matches = self::enforceNonNullMatches($pattern, $matchesInternal, 'match');
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs preg_match with PREG_OFFSET_CAPTURE
|
||||
*
|
||||
* @param non-empty-string $pattern
|
||||
* @param array<mixed> $matches Set by method
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL|PREG_OFFSET_CAPTURE> $flags PREG_UNMATCHED_AS_NULL and PREG_OFFSET_CAPTURE are always set, no other flags are supported
|
||||
* @return 0|1
|
||||
*
|
||||
* @param-out array<int|string, array{string|null, int<-1, max>}> $matches
|
||||
*/
|
||||
public static function matchWithOffsets(string $pattern, string $subject, ?array &$matches, int $flags = 0, int $offset = 0): int
|
||||
{
|
||||
$result = preg_match($pattern, $subject, $matches, $flags | PREG_UNMATCHED_AS_NULL | PREG_OFFSET_CAPTURE, $offset);
|
||||
if ($result === false) {
|
||||
throw PcreException::fromFunction('preg_match', $pattern);
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param non-empty-string $pattern
|
||||
* @param array<mixed> $matches Set by method
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL> $flags PREG_UNMATCHED_AS_NULL is always set, no other flags are supported
|
||||
* @return 0|positive-int
|
||||
*
|
||||
* @param-out array<int|string, list<string|null>> $matches
|
||||
*/
|
||||
public static function matchAll(string $pattern, string $subject, ?array &$matches = null, int $flags = 0, int $offset = 0): int
|
||||
{
|
||||
self::checkOffsetCapture($flags, 'matchAllWithOffsets');
|
||||
self::checkSetOrder($flags);
|
||||
|
||||
$result = preg_match_all($pattern, $subject, $matches, $flags | PREG_UNMATCHED_AS_NULL, $offset);
|
||||
if (!is_int($result)) { // PHP < 8 may return null, 8+ returns int|false
|
||||
throw PcreException::fromFunction('preg_match_all', $pattern);
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Variant of `match()` which outputs non-null matches (or throws)
|
||||
*
|
||||
* @param non-empty-string $pattern
|
||||
* @param array<mixed> $matches Set by method
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL> $flags PREG_UNMATCHED_AS_NULL is always set, no other flags are supported
|
||||
* @return 0|positive-int
|
||||
* @throws UnexpectedNullMatchException
|
||||
*
|
||||
* @param-out array<int|string, list<string>> $matches
|
||||
*/
|
||||
public static function matchAllStrictGroups(string $pattern, string $subject, ?array &$matches = null, int $flags = 0, int $offset = 0): int
|
||||
{
|
||||
$result = self::matchAll($pattern, $subject, $matchesInternal, $flags, $offset);
|
||||
$matches = self::enforceNonNullMatchAll($pattern, $matchesInternal, 'matchAll');
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs preg_match_all with PREG_OFFSET_CAPTURE
|
||||
*
|
||||
* @param non-empty-string $pattern
|
||||
* @param array<mixed> $matches Set by method
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL|PREG_OFFSET_CAPTURE> $flags PREG_UNMATCHED_AS_NULL and PREG_MATCH_OFFSET are always set, no other flags are supported
|
||||
* @return 0|positive-int
|
||||
*
|
||||
* @param-out array<int|string, list<array{string|null, int<-1, max>}>> $matches
|
||||
*/
|
||||
public static function matchAllWithOffsets(string $pattern, string $subject, ?array &$matches, int $flags = 0, int $offset = 0): int
|
||||
{
|
||||
self::checkSetOrder($flags);
|
||||
|
||||
$result = preg_match_all($pattern, $subject, $matches, $flags | PREG_UNMATCHED_AS_NULL | PREG_OFFSET_CAPTURE, $offset);
|
||||
if (!is_int($result)) { // PHP < 8 may return null, 8+ returns int|false
|
||||
throw PcreException::fromFunction('preg_match_all', $pattern);
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string|string[] $pattern
|
||||
* @param string|string[] $replacement
|
||||
* @param string $subject
|
||||
* @param int $count Set by method
|
||||
*
|
||||
* @param-out int<0, max> $count
|
||||
*/
|
||||
public static function replace($pattern, $replacement, $subject, int $limit = -1, ?int &$count = null): string
|
||||
{
|
||||
if (!is_scalar($subject)) {
|
||||
if (is_array($subject)) {
|
||||
throw new \InvalidArgumentException(static::ARRAY_MSG);
|
||||
}
|
||||
|
||||
throw new \TypeError(sprintf(static::INVALID_TYPE_MSG, gettype($subject)));
|
||||
}
|
||||
|
||||
$result = preg_replace($pattern, $replacement, $subject, $limit, $count);
|
||||
if ($result === null) {
|
||||
throw PcreException::fromFunction('preg_replace', $pattern);
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string|string[] $pattern
|
||||
* @param ($flags is PREG_OFFSET_CAPTURE ? (callable(array<int|string, array{string|null, int<-1, max>}>): string) : callable(array<int|string, string|null>): string) $replacement
|
||||
* @param string $subject
|
||||
* @param int $count Set by method
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL|PREG_OFFSET_CAPTURE> $flags PREG_OFFSET_CAPTURE is supported, PREG_UNMATCHED_AS_NULL is always set
|
||||
*
|
||||
* @param-out int<0, max> $count
|
||||
*/
|
||||
public static function replaceCallback($pattern, callable $replacement, $subject, int $limit = -1, ?int &$count = null, int $flags = 0): string
|
||||
{
|
||||
if (!is_scalar($subject)) {
|
||||
if (is_array($subject)) {
|
||||
throw new \InvalidArgumentException(static::ARRAY_MSG);
|
||||
}
|
||||
|
||||
throw new \TypeError(sprintf(static::INVALID_TYPE_MSG, gettype($subject)));
|
||||
}
|
||||
|
||||
$result = preg_replace_callback($pattern, $replacement, $subject, $limit, $count, $flags | PREG_UNMATCHED_AS_NULL);
|
||||
if ($result === null) {
|
||||
throw PcreException::fromFunction('preg_replace_callback', $pattern);
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Variant of `replaceCallback()` which outputs non-null matches (or throws)
|
||||
*
|
||||
* @param string $pattern
|
||||
* @param ($flags is PREG_OFFSET_CAPTURE ? (callable(array<int|string, array{string, int<0, max>}>): string) : callable(array<int|string, string>): string) $replacement
|
||||
* @param string $subject
|
||||
* @param int $count Set by method
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL|PREG_OFFSET_CAPTURE> $flags PREG_OFFSET_CAPTURE is supported, PREG_UNMATCHED_AS_NULL is always set
|
||||
*
|
||||
* @param-out int<0, max> $count
|
||||
*/
|
||||
public static function replaceCallbackStrictGroups(string $pattern, callable $replacement, $subject, int $limit = -1, ?int &$count = null, int $flags = 0): string
|
||||
{
|
||||
return self::replaceCallback($pattern, function (array $matches) use ($pattern, $replacement) {
|
||||
return $replacement(self::enforceNonNullMatches($pattern, $matches, 'replaceCallback'));
|
||||
}, $subject, $limit, $count, $flags);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param ($flags is PREG_OFFSET_CAPTURE ? (array<string, callable(array<int|string, array{string|null, int<-1, max>}>): string>) : array<string, callable(array<int|string, string|null>): string>) $pattern
|
||||
* @param string $subject
|
||||
* @param int $count Set by method
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL|PREG_OFFSET_CAPTURE> $flags PREG_OFFSET_CAPTURE is supported, PREG_UNMATCHED_AS_NULL is always set
|
||||
*
|
||||
* @param-out int<0, max> $count
|
||||
*/
|
||||
public static function replaceCallbackArray(array $pattern, $subject, int $limit = -1, ?int &$count = null, int $flags = 0): string
|
||||
{
|
||||
if (!is_scalar($subject)) {
|
||||
if (is_array($subject)) {
|
||||
throw new \InvalidArgumentException(static::ARRAY_MSG);
|
||||
}
|
||||
|
||||
throw new \TypeError(sprintf(static::INVALID_TYPE_MSG, gettype($subject)));
|
||||
}
|
||||
|
||||
$result = preg_replace_callback_array($pattern, $subject, $limit, $count, $flags | PREG_UNMATCHED_AS_NULL);
|
||||
if ($result === null) {
|
||||
$pattern = array_keys($pattern);
|
||||
throw PcreException::fromFunction('preg_replace_callback_array', $pattern);
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param int-mask<PREG_SPLIT_NO_EMPTY|PREG_SPLIT_DELIM_CAPTURE|PREG_SPLIT_OFFSET_CAPTURE> $flags PREG_SPLIT_NO_EMPTY or PREG_SPLIT_DELIM_CAPTURE
|
||||
* @return list<string>
|
||||
*/
|
||||
public static function split(string $pattern, string $subject, int $limit = -1, int $flags = 0): array
|
||||
{
|
||||
if (($flags & PREG_SPLIT_OFFSET_CAPTURE) !== 0) {
|
||||
throw new \InvalidArgumentException('PREG_SPLIT_OFFSET_CAPTURE is not supported as it changes the type of $matches, use splitWithOffsets() instead');
|
||||
}
|
||||
|
||||
$result = preg_split($pattern, $subject, $limit, $flags);
|
||||
if ($result === false) {
|
||||
throw PcreException::fromFunction('preg_split', $pattern);
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param int-mask<PREG_SPLIT_NO_EMPTY|PREG_SPLIT_DELIM_CAPTURE|PREG_SPLIT_OFFSET_CAPTURE> $flags PREG_SPLIT_NO_EMPTY or PREG_SPLIT_DELIM_CAPTURE, PREG_SPLIT_OFFSET_CAPTURE is always set
|
||||
* @return list<array{string, int}>
|
||||
* @phpstan-return list<array{string, int<0, max>}>
|
||||
*/
|
||||
public static function splitWithOffsets(string $pattern, string $subject, int $limit = -1, int $flags = 0): array
|
||||
{
|
||||
$result = preg_split($pattern, $subject, $limit, $flags | PREG_SPLIT_OFFSET_CAPTURE);
|
||||
if ($result === false) {
|
||||
throw PcreException::fromFunction('preg_split', $pattern);
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* @template T of string|\Stringable
|
||||
* @param string $pattern
|
||||
* @param array<T> $array
|
||||
* @param int-mask<PREG_GREP_INVERT> $flags PREG_GREP_INVERT
|
||||
* @return array<T>
|
||||
*/
|
||||
public static function grep(string $pattern, array $array, int $flags = 0): array
|
||||
{
|
||||
$result = preg_grep($pattern, $array, $flags);
|
||||
if ($result === false) {
|
||||
throw PcreException::fromFunction('preg_grep', $pattern);
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Variant of match() which returns a bool instead of int
|
||||
*
|
||||
* @param non-empty-string $pattern
|
||||
* @param array<mixed> $matches Set by method
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL> $flags PREG_UNMATCHED_AS_NULL is always set, no other flags are supported
|
||||
*
|
||||
* @param-out array<int|string, string|null> $matches
|
||||
*/
|
||||
public static function isMatch(string $pattern, string $subject, ?array &$matches = null, int $flags = 0, int $offset = 0): bool
|
||||
{
|
||||
return (bool) static::match($pattern, $subject, $matches, $flags, $offset);
|
||||
}
|
||||
|
||||
/**
|
||||
* Variant of `isMatch()` which outputs non-null matches (or throws)
|
||||
*
|
||||
* @param non-empty-string $pattern
|
||||
* @param array<mixed> $matches Set by method
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL> $flags PREG_UNMATCHED_AS_NULL is always set, no other flags are supported
|
||||
* @throws UnexpectedNullMatchException
|
||||
*
|
||||
* @param-out array<int|string, string> $matches
|
||||
*/
|
||||
public static function isMatchStrictGroups(string $pattern, string $subject, ?array &$matches = null, int $flags = 0, int $offset = 0): bool
|
||||
{
|
||||
return (bool) self::matchStrictGroups($pattern, $subject, $matches, $flags, $offset);
|
||||
}
|
||||
|
||||
/**
|
||||
* Variant of matchAll() which returns a bool instead of int
|
||||
*
|
||||
* @param non-empty-string $pattern
|
||||
* @param array<mixed> $matches Set by method
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL> $flags PREG_UNMATCHED_AS_NULL is always set, no other flags are supported
|
||||
*
|
||||
* @param-out array<int|string, list<string|null>> $matches
|
||||
*/
|
||||
public static function isMatchAll(string $pattern, string $subject, ?array &$matches = null, int $flags = 0, int $offset = 0): bool
|
||||
{
|
||||
return (bool) static::matchAll($pattern, $subject, $matches, $flags, $offset);
|
||||
}
|
||||
|
||||
/**
|
||||
* Variant of `isMatchAll()` which outputs non-null matches (or throws)
|
||||
*
|
||||
* @param non-empty-string $pattern
|
||||
* @param array<mixed> $matches Set by method
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL> $flags PREG_UNMATCHED_AS_NULL is always set, no other flags are supported
|
||||
*
|
||||
* @param-out array<int|string, list<string>> $matches
|
||||
*/
|
||||
public static function isMatchAllStrictGroups(string $pattern, string $subject, ?array &$matches = null, int $flags = 0, int $offset = 0): bool
|
||||
{
|
||||
return (bool) self::matchAllStrictGroups($pattern, $subject, $matches, $flags, $offset);
|
||||
}
|
||||
|
||||
/**
|
||||
* Variant of matchWithOffsets() which returns a bool instead of int
|
||||
*
|
||||
* Runs preg_match with PREG_OFFSET_CAPTURE
|
||||
*
|
||||
* @param non-empty-string $pattern
|
||||
* @param array<mixed> $matches Set by method
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL> $flags PREG_UNMATCHED_AS_NULL is always set, no other flags are supported
|
||||
*
|
||||
* @param-out array<int|string, array{string|null, int<-1, max>}> $matches
|
||||
*/
|
||||
public static function isMatchWithOffsets(string $pattern, string $subject, ?array &$matches, int $flags = 0, int $offset = 0): bool
|
||||
{
|
||||
return (bool) static::matchWithOffsets($pattern, $subject, $matches, $flags, $offset);
|
||||
}
|
||||
|
||||
/**
|
||||
* Variant of matchAllWithOffsets() which returns a bool instead of int
|
||||
*
|
||||
* Runs preg_match_all with PREG_OFFSET_CAPTURE
|
||||
*
|
||||
* @param non-empty-string $pattern
|
||||
* @param array<mixed> $matches Set by method
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL> $flags PREG_UNMATCHED_AS_NULL is always set, no other flags are supported
|
||||
*
|
||||
* @param-out array<int|string, list<array{string|null, int<-1, max>}>> $matches
|
||||
*/
|
||||
public static function isMatchAllWithOffsets(string $pattern, string $subject, ?array &$matches, int $flags = 0, int $offset = 0): bool
|
||||
{
|
||||
return (bool) static::matchAllWithOffsets($pattern, $subject, $matches, $flags, $offset);
|
||||
}
|
||||
|
||||
private static function checkOffsetCapture(int $flags, string $useFunctionName): void
|
||||
{
|
||||
if (($flags & PREG_OFFSET_CAPTURE) !== 0) {
|
||||
throw new \InvalidArgumentException('PREG_OFFSET_CAPTURE is not supported as it changes the type of $matches, use ' . $useFunctionName . '() instead');
|
||||
}
|
||||
}
|
||||
|
||||
private static function checkSetOrder(int $flags): void
|
||||
{
|
||||
if (($flags & PREG_SET_ORDER) !== 0) {
|
||||
throw new \InvalidArgumentException('PREG_SET_ORDER is not supported as it changes the type of $matches');
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param array<int|string, string|null|array{string|null, int}> $matches
|
||||
* @return array<int|string, string>
|
||||
* @throws UnexpectedNullMatchException
|
||||
*/
|
||||
private static function enforceNonNullMatches(string $pattern, array $matches, string $variantMethod)
|
||||
{
|
||||
foreach ($matches as $group => $match) {
|
||||
if (is_string($match) || (is_array($match) && is_string($match[0]))) {
|
||||
continue;
|
||||
}
|
||||
|
||||
throw new UnexpectedNullMatchException('Pattern "'.$pattern.'" had an unexpected unmatched group "'.$group.'", make sure the pattern always matches or use '.$variantMethod.'() instead.');
|
||||
}
|
||||
|
||||
/** @var array<string> */
|
||||
return $matches;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param array<int|string, list<string|null>> $matches
|
||||
* @return array<int|string, list<string>>
|
||||
* @throws UnexpectedNullMatchException
|
||||
*/
|
||||
private static function enforceNonNullMatchAll(string $pattern, array $matches, string $variantMethod)
|
||||
{
|
||||
foreach ($matches as $group => $groupMatches) {
|
||||
foreach ($groupMatches as $match) {
|
||||
if (null === $match) {
|
||||
throw new UnexpectedNullMatchException('Pattern "'.$pattern.'" had an unexpected unmatched group "'.$group.'", make sure the pattern always matches or use '.$variantMethod.'() instead.');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** @var array<int|string, list<string>> */
|
||||
return $matches;
|
||||
}
|
||||
}
|
||||
+176
@@ -0,0 +1,176 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of composer/pcre.
|
||||
*
|
||||
* (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\Pcre;
|
||||
|
||||
class Regex
|
||||
{
|
||||
/**
|
||||
* @param non-empty-string $pattern
|
||||
*/
|
||||
public static function isMatch(string $pattern, string $subject, int $offset = 0): bool
|
||||
{
|
||||
return (bool) Preg::match($pattern, $subject, $matches, 0, $offset);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param non-empty-string $pattern
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL> $flags PREG_UNMATCHED_AS_NULL is always set, no other flags are supported
|
||||
*/
|
||||
public static function match(string $pattern, string $subject, int $flags = 0, int $offset = 0): MatchResult
|
||||
{
|
||||
self::checkOffsetCapture($flags, 'matchWithOffsets');
|
||||
|
||||
$count = Preg::match($pattern, $subject, $matches, $flags, $offset);
|
||||
|
||||
return new MatchResult($count, $matches);
|
||||
}
|
||||
|
||||
/**
|
||||
* Variant of `match()` which returns non-null matches (or throws)
|
||||
*
|
||||
* @param non-empty-string $pattern
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL> $flags PREG_UNMATCHED_AS_NULL is always set, no other flags are supported
|
||||
* @throws UnexpectedNullMatchException
|
||||
*/
|
||||
public static function matchStrictGroups(string $pattern, string $subject, int $flags = 0, int $offset = 0): MatchStrictGroupsResult
|
||||
{
|
||||
// @phpstan-ignore composerPcre.maybeUnsafeStrictGroups
|
||||
$count = Preg::matchStrictGroups($pattern, $subject, $matches, $flags, $offset);
|
||||
|
||||
return new MatchStrictGroupsResult($count, $matches);
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs preg_match with PREG_OFFSET_CAPTURE
|
||||
*
|
||||
* @param non-empty-string $pattern
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL|PREG_OFFSET_CAPTURE> $flags PREG_UNMATCHED_AS_NULL and PREG_MATCH_OFFSET are always set, no other flags are supported
|
||||
*/
|
||||
public static function matchWithOffsets(string $pattern, string $subject, int $flags = 0, int $offset = 0): MatchWithOffsetsResult
|
||||
{
|
||||
$count = Preg::matchWithOffsets($pattern, $subject, $matches, $flags, $offset);
|
||||
|
||||
return new MatchWithOffsetsResult($count, $matches);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param non-empty-string $pattern
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL> $flags PREG_UNMATCHED_AS_NULL is always set, no other flags are supported
|
||||
*/
|
||||
public static function matchAll(string $pattern, string $subject, int $flags = 0, int $offset = 0): MatchAllResult
|
||||
{
|
||||
self::checkOffsetCapture($flags, 'matchAllWithOffsets');
|
||||
self::checkSetOrder($flags);
|
||||
|
||||
$count = Preg::matchAll($pattern, $subject, $matches, $flags, $offset);
|
||||
|
||||
return new MatchAllResult($count, $matches);
|
||||
}
|
||||
|
||||
/**
|
||||
* Variant of `matchAll()` which returns non-null matches (or throws)
|
||||
*
|
||||
* @param non-empty-string $pattern
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL> $flags PREG_UNMATCHED_AS_NULL is always set, no other flags are supported
|
||||
* @throws UnexpectedNullMatchException
|
||||
*/
|
||||
public static function matchAllStrictGroups(string $pattern, string $subject, int $flags = 0, int $offset = 0): MatchAllStrictGroupsResult
|
||||
{
|
||||
self::checkOffsetCapture($flags, 'matchAllWithOffsets');
|
||||
self::checkSetOrder($flags);
|
||||
|
||||
// @phpstan-ignore composerPcre.maybeUnsafeStrictGroups
|
||||
$count = Preg::matchAllStrictGroups($pattern, $subject, $matches, $flags, $offset);
|
||||
|
||||
return new MatchAllStrictGroupsResult($count, $matches);
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs preg_match_all with PREG_OFFSET_CAPTURE
|
||||
*
|
||||
* @param non-empty-string $pattern
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL|PREG_OFFSET_CAPTURE> $flags PREG_UNMATCHED_AS_NULL and PREG_MATCH_OFFSET are always set, no other flags are supported
|
||||
*/
|
||||
public static function matchAllWithOffsets(string $pattern, string $subject, int $flags = 0, int $offset = 0): MatchAllWithOffsetsResult
|
||||
{
|
||||
self::checkSetOrder($flags);
|
||||
|
||||
$count = Preg::matchAllWithOffsets($pattern, $subject, $matches, $flags, $offset);
|
||||
|
||||
return new MatchAllWithOffsetsResult($count, $matches);
|
||||
}
|
||||
/**
|
||||
* @param string|string[] $pattern
|
||||
* @param string|string[] $replacement
|
||||
* @param string $subject
|
||||
*/
|
||||
public static function replace($pattern, $replacement, $subject, int $limit = -1): ReplaceResult
|
||||
{
|
||||
$result = Preg::replace($pattern, $replacement, $subject, $limit, $count);
|
||||
|
||||
return new ReplaceResult($count, $result);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string|string[] $pattern
|
||||
* @param ($flags is PREG_OFFSET_CAPTURE ? (callable(array<int|string, array{string|null, int<-1, max>}>): string) : callable(array<int|string, string|null>): string) $replacement
|
||||
* @param string $subject
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL|PREG_OFFSET_CAPTURE> $flags PREG_OFFSET_CAPTURE is supported, PREG_UNMATCHED_AS_NULL is always set
|
||||
*/
|
||||
public static function replaceCallback($pattern, callable $replacement, $subject, int $limit = -1, int $flags = 0): ReplaceResult
|
||||
{
|
||||
$result = Preg::replaceCallback($pattern, $replacement, $subject, $limit, $count, $flags);
|
||||
|
||||
return new ReplaceResult($count, $result);
|
||||
}
|
||||
|
||||
/**
|
||||
* Variant of `replaceCallback()` which outputs non-null matches (or throws)
|
||||
*
|
||||
* @param string $pattern
|
||||
* @param ($flags is PREG_OFFSET_CAPTURE ? (callable(array<int|string, array{string, int<0, max>}>): string) : callable(array<int|string, string>): string) $replacement
|
||||
* @param string $subject
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL|PREG_OFFSET_CAPTURE> $flags PREG_OFFSET_CAPTURE is supported, PREG_UNMATCHED_AS_NULL is always set
|
||||
*/
|
||||
public static function replaceCallbackStrictGroups($pattern, callable $replacement, $subject, int $limit = -1, int $flags = 0): ReplaceResult
|
||||
{
|
||||
$result = Preg::replaceCallbackStrictGroups($pattern, $replacement, $subject, $limit, $count, $flags);
|
||||
|
||||
return new ReplaceResult($count, $result);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param ($flags is PREG_OFFSET_CAPTURE ? (array<string, callable(array<int|string, array{string|null, int<-1, max>}>): string>) : array<string, callable(array<int|string, string|null>): string>) $pattern
|
||||
* @param string $subject
|
||||
* @param int-mask<PREG_UNMATCHED_AS_NULL|PREG_OFFSET_CAPTURE> $flags PREG_OFFSET_CAPTURE is supported, PREG_UNMATCHED_AS_NULL is always set
|
||||
*/
|
||||
public static function replaceCallbackArray(array $pattern, $subject, int $limit = -1, int $flags = 0): ReplaceResult
|
||||
{
|
||||
$result = Preg::replaceCallbackArray($pattern, $subject, $limit, $count, $flags);
|
||||
|
||||
return new ReplaceResult($count, $result);
|
||||
}
|
||||
|
||||
private static function checkOffsetCapture(int $flags, string $useFunctionName): void
|
||||
{
|
||||
if (($flags & PREG_OFFSET_CAPTURE) !== 0) {
|
||||
throw new \InvalidArgumentException('PREG_OFFSET_CAPTURE is not supported as it changes the return type, use '.$useFunctionName.'() instead');
|
||||
}
|
||||
}
|
||||
|
||||
private static function checkSetOrder(int $flags): void
|
||||
{
|
||||
if (($flags & PREG_SET_ORDER) !== 0) {
|
||||
throw new \InvalidArgumentException('PREG_SET_ORDER is not supported as it changes the return type');
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of composer/pcre.
|
||||
*
|
||||
* (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\Pcre;
|
||||
|
||||
final class ReplaceResult
|
||||
{
|
||||
/**
|
||||
* @readonly
|
||||
* @var string
|
||||
*/
|
||||
public $result;
|
||||
|
||||
/**
|
||||
* @readonly
|
||||
* @var 0|positive-int
|
||||
*/
|
||||
public $count;
|
||||
|
||||
/**
|
||||
* @readonly
|
||||
* @var bool
|
||||
*/
|
||||
public $matched;
|
||||
|
||||
/**
|
||||
* @param 0|positive-int $count
|
||||
*/
|
||||
public function __construct(int $count, string $result)
|
||||
{
|
||||
$this->count = $count;
|
||||
$this->matched = (bool) $count;
|
||||
$this->result = $result;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of composer/pcre.
|
||||
*
|
||||
* (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\Pcre;
|
||||
|
||||
class UnexpectedNullMatchException extends PcreException
|
||||
{
|
||||
public static function fromFunction($function, $pattern)
|
||||
{
|
||||
throw new \LogicException('fromFunction should not be called on '.self::class.', use '.PcreException::class);
|
||||
}
|
||||
}
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
<?php
|
||||
|
||||
// platform_check.php @generated by Composer
|
||||
|
||||
$issues = array();
|
||||
|
||||
if (!(PHP_VERSION_ID >= 80100)) {
|
||||
$issues[] = 'Your Composer dependencies require a PHP version ">= 8.1.0". You are running ' . PHP_VERSION . '.';
|
||||
}
|
||||
|
||||
if ($issues) {
|
||||
if (!headers_sent()) {
|
||||
header('HTTP/1.1 500 Internal Server Error');
|
||||
}
|
||||
if (!ini_get('display_errors')) {
|
||||
if (PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg') {
|
||||
fwrite(STDERR, 'Composer detected issues in your platform:' . PHP_EOL.PHP_EOL . implode(PHP_EOL, $issues) . PHP_EOL.PHP_EOL);
|
||||
} elseif (!headers_sent()) {
|
||||
echo 'Composer detected issues in your platform:' . PHP_EOL.PHP_EOL . str_replace('You are running '.PHP_VERSION.'.', '', implode(PHP_EOL, $issues)) . PHP_EOL.PHP_EOL;
|
||||
}
|
||||
}
|
||||
throw new \RuntimeException(
|
||||
'Composer detected issues in your platform: ' . implode(' ', $issues)
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,143 @@
|
||||
## [Unreleased]
|
||||
|
||||
## [3.0.5] - 2024-05-06
|
||||
* Fixed: fail restart if PHP_BINARY is not available
|
||||
|
||||
## [3.0.4] - 2024-03-26
|
||||
* Added: Functional tests.
|
||||
* Fixed: Incompatibility with PHPUnit 10.
|
||||
|
||||
## [3.0.3] - 2022-02-25
|
||||
* Added: support for composer/pcre versions 2 and 3.
|
||||
|
||||
## [3.0.2] - 2022-02-24
|
||||
* Fixed: regression in 3.0.1 affecting Xdebug 2
|
||||
|
||||
## [3.0.1] - 2022-01-04
|
||||
* Fixed: error when calling `isXdebugActive` before class instantiation.
|
||||
|
||||
## [3.0.0] - 2021-12-23
|
||||
* Removed: support for legacy PHP versions (< PHP 7.2.5).
|
||||
* Added: type declarations to arguments and return values.
|
||||
* Added: strict typing to all classes.
|
||||
|
||||
## [2.0.3] - 2021-12-08
|
||||
* Added: support, type annotations and refactoring for stricter PHPStan analysis.
|
||||
|
||||
## [2.0.2] - 2021-07-31
|
||||
* Added: support for `xdebug_info('mode')` in Xdebug 3.1.
|
||||
* Added: support for Psr\Log versions 2 and 3.
|
||||
* Fixed: remove ini directives from non-cli HOST/PATH sections.
|
||||
|
||||
## [2.0.1] - 2021-05-05
|
||||
* Fixed: don't restart if the cwd is a UNC path and cmd.exe will be invoked.
|
||||
|
||||
## [2.0.0] - 2021-04-09
|
||||
* Break: this is a major release, see [UPGRADE.md](UPGRADE.md) for more information.
|
||||
* Break: removed optional `$colorOption` constructor param and passthru fallback.
|
||||
* Break: renamed `requiresRestart` param from `$isLoaded` to `$default`.
|
||||
* Break: changed `restart` param `$command` from a string to an array.
|
||||
* Added: support for Xdebug3 to only restart if Xdebug is not running with `xdebug.mode=off`.
|
||||
* Added: `isXdebugActive()` method to determine if Xdebug is still running in the restart.
|
||||
* Added: feature to bypass the shell in PHP-7.4+ by giving `proc_open` an array of arguments.
|
||||
* Added: Process utility class to the API.
|
||||
|
||||
## [1.4.6] - 2021-03-25
|
||||
* Fixed: fail restart if `proc_open` has been disabled in `disable_functions`.
|
||||
* Fixed: enable Windows CTRL event handling in the restarted process.
|
||||
|
||||
## [1.4.5] - 2020-11-13
|
||||
* Fixed: use `proc_open` when available for correct FD forwarding to the restarted process.
|
||||
|
||||
## [1.4.4] - 2020-10-24
|
||||
* Fixed: exception if 'pcntl_signal' is disabled.
|
||||
|
||||
## [1.4.3] - 2020-08-19
|
||||
* Fixed: restore SIGINT to default handler in restarted process if no other handler exists.
|
||||
|
||||
## [1.4.2] - 2020-06-04
|
||||
* Fixed: ignore SIGINTs to let the restarted process handle them.
|
||||
|
||||
## [1.4.1] - 2020-03-01
|
||||
* Fixed: restart fails if an ini file is empty.
|
||||
|
||||
## [1.4.0] - 2019-11-06
|
||||
* Added: support for `NO_COLOR` environment variable: https://no-color.org
|
||||
* Added: color support for Hyper terminal: https://github.com/zeit/hyper
|
||||
* Fixed: correct capitalization of Xdebug (apparently).
|
||||
* Fixed: improved handling for uopz extension.
|
||||
|
||||
## [1.3.3] - 2019-05-27
|
||||
* Fixed: add environment changes to `$_ENV` if it is being used.
|
||||
|
||||
## [1.3.2] - 2019-01-28
|
||||
* 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/3.0.5...HEAD
|
||||
[3.0.5]: https://github.com/composer/xdebug-handler/compare/3.0.4...3.0.5
|
||||
[3.0.4]: https://github.com/composer/xdebug-handler/compare/3.0.3...3.0.4
|
||||
[3.0.3]: https://github.com/composer/xdebug-handler/compare/3.0.2...3.0.3
|
||||
[3.0.2]: https://github.com/composer/xdebug-handler/compare/3.0.1...3.0.2
|
||||
[3.0.1]: https://github.com/composer/xdebug-handler/compare/3.0.0...3.0.1
|
||||
[3.0.0]: https://github.com/composer/xdebug-handler/compare/2.0.3...3.0.0
|
||||
[2.0.3]: https://github.com/composer/xdebug-handler/compare/2.0.2...2.0.3
|
||||
[2.0.2]: https://github.com/composer/xdebug-handler/compare/2.0.1...2.0.2
|
||||
[2.0.1]: https://github.com/composer/xdebug-handler/compare/2.0.0...2.0.1
|
||||
[2.0.0]: https://github.com/composer/xdebug-handler/compare/1.4.6...2.0.0
|
||||
[1.4.6]: https://github.com/composer/xdebug-handler/compare/1.4.5...1.4.6
|
||||
[1.4.5]: https://github.com/composer/xdebug-handler/compare/1.4.4...1.4.5
|
||||
[1.4.4]: https://github.com/composer/xdebug-handler/compare/1.4.3...1.4.4
|
||||
[1.4.3]: https://github.com/composer/xdebug-handler/compare/1.4.2...1.4.3
|
||||
[1.4.2]: https://github.com/composer/xdebug-handler/compare/1.4.1...1.4.2
|
||||
[1.4.1]: https://github.com/composer/xdebug-handler/compare/1.4.0...1.4.1
|
||||
[1.4.0]: https://github.com/composer/xdebug-handler/compare/1.3.3...1.4.0
|
||||
[1.3.3]: https://github.com/composer/xdebug-handler/compare/1.3.2...1.3.3
|
||||
[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
|
||||
@@ -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.
|
||||
+305
@@ -0,0 +1,305 @@
|
||||
# composer/xdebug-handler
|
||||
|
||||
[](https://packagist.org/packages/composer/xdebug-handler)
|
||||
[](https://github.com/composer/xdebug-handler/actions?query=branch:main)
|
||||
|
||||
|
||||
|
||||
Restart a CLI process without loading the Xdebug extension, unless `xdebug.mode=off`.
|
||||
|
||||
Originally written as part of [composer/composer](https://github.com/composer/composer),
|
||||
now extracted and made available as a stand-alone library.
|
||||
|
||||
### Version 3
|
||||
|
||||
Removed support for legacy PHP versions and added type declarations.
|
||||
|
||||
Long term support for version 2 (PHP 5.3.2 - 7.2.4) follows [Composer 2.2 LTS](https://blog.packagist.com/composer-2-2/) policy.
|
||||
|
||||
## Installation
|
||||
|
||||
Install the latest version with:
|
||||
|
||||
```bash
|
||||
$ composer require composer/xdebug-handler
|
||||
```
|
||||
|
||||
## Requirements
|
||||
|
||||
* PHP 7.2.5 minimum, although 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 a single parameter, `$envPrefix`, which is upper-cased and prepended to default base values to create two distinct environment variables. 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
|
||||
|
||||
## 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)
|
||||
* [Examples](#examples)
|
||||
|
||||
### 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.
|
||||
* 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.
|
||||
|
||||
See [Examples](#examples) for further information.
|
||||
|
||||
#### Signal handling
|
||||
Asynchronous signal handling is automatically enabled if the pcntl extension is loaded. `SIGINT` is set to `SIG_IGN` in the parent
|
||||
process and restored to `SIG_DFL` in the restarted process (if no other handler has been set).
|
||||
|
||||
From PHP 7.4 on Windows, `CTRL+C` and `CTRL+BREAK` handling is automatically enabled in the restarted process and ignored in the parent 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-array).
|
||||
* 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(): array_
|
||||
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(): ?array_
|
||||
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(): string_
|
||||
Returns the Xdebug version string that was skipped by the restart, or an empty string 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: '3.1.1' (for example), or an empty string
|
||||
```
|
||||
|
||||
#### _isXdebugActive(): bool_
|
||||
Returns true if Xdebug is loaded and is running in an active mode (if it supports modes). Returns false if Xdebug is not loaded, or it is running with `xdebug.mode=off`.
|
||||
|
||||
### Setter methods
|
||||
These methods implement a fluent interface and must be called before the main `check()` method.
|
||||
|
||||
#### _setLogger(LoggerInterface $logger): self_
|
||||
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):
|
||||
|
||||
```
|
||||
// No restart
|
||||
DEBUG Checking MYAPP_ALLOW_XDEBUG
|
||||
DEBUG The Xdebug extension is loaded (3.1.1) xdebug.mode=off
|
||||
DEBUG No restart (APP_ALLOW_XDEBUG=0) Allowed by xdebug.mode
|
||||
|
||||
// Restart overridden
|
||||
DEBUG Checking MYAPP_ALLOW_XDEBUG
|
||||
DEBUG The Xdebug extension is loaded (3.1.1) xdebug.mode=coverage,debug,develop
|
||||
DEBUG No restart (MYAPP_ALLOW_XDEBUG=1)
|
||||
|
||||
// Failed restart
|
||||
DEBUG Checking MYAPP_ALLOW_XDEBUG
|
||||
DEBUG The Xdebug extension is loaded (3.1.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(string $script): self_
|
||||
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(): self_
|
||||
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-self).
|
||||
|
||||
#### 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-array) 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(bool $default): bool_
|
||||
By default the process will restart if Xdebug is loaded and not running with `xdebug.mode=off`. 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()](#setmainscriptstring-script-self) and [setPersistent()](#setpersistent-self) setters can be used here, if required.
|
||||
|
||||
#### _restart(array $command): void_
|
||||
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.
|
||||
|
||||
The `$command` parameter is an array of unescaped command-line arguments that will be used for the new process.
|
||||
|
||||
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(bool $default): bool
|
||||
{
|
||||
if (Command::isHelp()) {
|
||||
# No need to disable Xdebug for this
|
||||
return false;
|
||||
}
|
||||
|
||||
$this->required = (bool) ini_get('phar.readonly');
|
||||
return $this->required || $default;
|
||||
}
|
||||
|
||||
protected function restart(array $command): void
|
||||
{
|
||||
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);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Examples
|
||||
The `tests\App` directory contains command-line scripts that demonstrate the internal workings in a variety of scenarios.
|
||||
See [Functional Test Scripts](./tests/App/README.md).
|
||||
|
||||
## License
|
||||
composer/xdebug-handler is licensed under the MIT License, see the LICENSE file for details.
|
||||
@@ -0,0 +1,44 @@
|
||||
{
|
||||
"name": "composer/xdebug-handler",
|
||||
"description": "Restarts a process without Xdebug.",
|
||||
"type": "library",
|
||||
"license": "MIT",
|
||||
"keywords": [
|
||||
"xdebug",
|
||||
"performance"
|
||||
],
|
||||
"authors": [
|
||||
{
|
||||
"name": "John Stevenson",
|
||||
"email": "john-stevenson@blueyonder.co.uk"
|
||||
}
|
||||
],
|
||||
"support": {
|
||||
"irc": "ircs://irc.libera.chat:6697/composer",
|
||||
"issues": "https://github.com/composer/xdebug-handler/issues"
|
||||
},
|
||||
"require": {
|
||||
"php": "^7.2.5 || ^8.0",
|
||||
"psr/log": "^1 || ^2 || ^3",
|
||||
"composer/pcre": "^1 || ^2 || ^3"
|
||||
},
|
||||
"require-dev": {
|
||||
"phpstan/phpstan": "^1.0",
|
||||
"phpstan/phpstan-strict-rules": "^1.1",
|
||||
"phpunit/phpunit": "^8.5 || ^9.6 || ^10.5"
|
||||
},
|
||||
"autoload": {
|
||||
"psr-4": {
|
||||
"Composer\\XdebugHandler\\": "src"
|
||||
}
|
||||
},
|
||||
"autoload-dev": {
|
||||
"psr-4": {
|
||||
"Composer\\XdebugHandler\\Tests\\": "tests"
|
||||
}
|
||||
},
|
||||
"scripts": {
|
||||
"test": "@php vendor/bin/phpunit",
|
||||
"phpstan": "@php vendor/bin/phpstan analyse"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,91 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
/*
|
||||
* This file is part of composer/xdebug-handler.
|
||||
*
|
||||
* (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\XdebugHandler;
|
||||
|
||||
/**
|
||||
* @author John Stevenson <john-stevenson@blueyonder.co.uk>
|
||||
*
|
||||
* @phpstan-type restartData array{tmpIni: string, scannedInis: bool, scanDir: false|string, phprc: false|string, inis: string[], skipped: string}
|
||||
*/
|
||||
class PhpConfig
|
||||
{
|
||||
/**
|
||||
* Use the original PHP configuration
|
||||
*
|
||||
* @return string[] Empty array of PHP cli options
|
||||
*/
|
||||
public function useOriginal(): array
|
||||
{
|
||||
$this->getDataAndReset();
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Use standard restart settings
|
||||
*
|
||||
* @return string[] PHP cli options
|
||||
*/
|
||||
public function useStandard(): array
|
||||
{
|
||||
$data = $this->getDataAndReset();
|
||||
if ($data !== null) {
|
||||
return ['-n', '-c', $data['tmpIni']];
|
||||
}
|
||||
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Use environment variables to persist settings
|
||||
*
|
||||
* @return string[] Empty array of PHP cli options
|
||||
*/
|
||||
public function usePersistent(): array
|
||||
{
|
||||
$data = $this->getDataAndReset();
|
||||
if ($data !== null) {
|
||||
$this->updateEnv('PHPRC', $data['tmpIni']);
|
||||
$this->updateEnv('PHP_INI_SCAN_DIR', '');
|
||||
}
|
||||
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns restart data if available and resets the environment
|
||||
*
|
||||
* @phpstan-return restartData|null
|
||||
*/
|
||||
private function getDataAndReset(): ?array
|
||||
{
|
||||
$data = XdebugHandler::getRestartSettings();
|
||||
if ($data !== null) {
|
||||
$this->updateEnv('PHPRC', $data['phprc']);
|
||||
$this->updateEnv('PHP_INI_SCAN_DIR', $data['scanDir']);
|
||||
}
|
||||
|
||||
return $data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates a restart settings value in the environment
|
||||
*
|
||||
* @param string $name
|
||||
* @param string|false $value
|
||||
*/
|
||||
private function updateEnv(string $name, $value): void
|
||||
{
|
||||
Process::setEnv($name, false !== $value ? $value : null);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,119 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of composer/xdebug-handler.
|
||||
*
|
||||
* (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.
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Composer\XdebugHandler;
|
||||
|
||||
use Composer\Pcre\Preg;
|
||||
|
||||
/**
|
||||
* Process utility functions
|
||||
*
|
||||
* @author John Stevenson <john-stevenson@blueyonder.co.uk>
|
||||
*/
|
||||
class Process
|
||||
{
|
||||
/**
|
||||
* Escapes a string to be used as a shell argument.
|
||||
*
|
||||
* From https://github.com/johnstevenson/winbox-args
|
||||
* MIT Licensed (c) John Stevenson <john-stevenson@blueyonder.co.uk>
|
||||
*
|
||||
* @param string $arg The argument to be escaped
|
||||
* @param bool $meta Additionally escape cmd.exe meta characters
|
||||
* @param bool $module The argument is the module to invoke
|
||||
*/
|
||||
public static function escape(string $arg, bool $meta = true, bool $module = false): string
|
||||
{
|
||||
if (!defined('PHP_WINDOWS_VERSION_BUILD')) {
|
||||
return "'".str_replace("'", "'\\''", $arg)."'";
|
||||
}
|
||||
|
||||
$quote = strpbrk($arg, " \t") !== false || $arg === '';
|
||||
|
||||
$arg = Preg::replace('/(\\\\*)"/', '$1$1\\"', $arg, -1, $dquotes);
|
||||
$dquotes = (bool) $dquotes;
|
||||
|
||||
if ($meta) {
|
||||
$meta = $dquotes || Preg::isMatch('/%[^%]+%/', $arg);
|
||||
|
||||
if (!$meta) {
|
||||
$quote = $quote || strpbrk($arg, '^&|<>()') !== false;
|
||||
} elseif ($module && !$dquotes && $quote) {
|
||||
$meta = false;
|
||||
}
|
||||
}
|
||||
|
||||
if ($quote) {
|
||||
$arg = '"'.(Preg::replace('/(\\\\*)$/', '$1$1', $arg)).'"';
|
||||
}
|
||||
|
||||
if ($meta) {
|
||||
$arg = Preg::replace('/(["^&|<>()%])/', '^$1', $arg);
|
||||
}
|
||||
|
||||
return $arg;
|
||||
}
|
||||
|
||||
/**
|
||||
* Escapes an array of arguments that make up a shell command
|
||||
*
|
||||
* @param string[] $args Argument list, with the module name first
|
||||
*/
|
||||
public static function escapeShellCommand(array $args): string
|
||||
{
|
||||
$command = '';
|
||||
$module = array_shift($args);
|
||||
|
||||
if ($module !== null) {
|
||||
$command = self::escape($module, true, true);
|
||||
|
||||
foreach ($args as $arg) {
|
||||
$command .= ' '.self::escape($arg);
|
||||
}
|
||||
}
|
||||
|
||||
return $command;
|
||||
}
|
||||
|
||||
/**
|
||||
* Makes putenv environment changes available in $_SERVER and $_ENV
|
||||
*
|
||||
* @param string $name
|
||||
* @param ?string $value A null value unsets the variable
|
||||
*/
|
||||
public static function setEnv(string $name, ?string $value = null): bool
|
||||
{
|
||||
$unset = null === $value;
|
||||
|
||||
if (!putenv($unset ? $name : $name.'='.$value)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if ($unset) {
|
||||
unset($_SERVER[$name]);
|
||||
} else {
|
||||
$_SERVER[$name] = $value;
|
||||
}
|
||||
|
||||
// Update $_ENV if it is being used
|
||||
if (false !== stripos((string) ini_get('variables_order'), 'E')) {
|
||||
if ($unset) {
|
||||
unset($_ENV[$name]);
|
||||
} else {
|
||||
$_ENV[$name] = $value;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,222 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of composer/xdebug-handler.
|
||||
*
|
||||
* (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.
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Composer\XdebugHandler;
|
||||
|
||||
use Psr\Log\LoggerInterface;
|
||||
use Psr\Log\LogLevel;
|
||||
|
||||
/**
|
||||
* @author John Stevenson <john-stevenson@blueyonder.co.uk>
|
||||
* @internal
|
||||
*/
|
||||
class Status
|
||||
{
|
||||
const ENV_RESTART = 'XDEBUG_HANDLER_RESTART';
|
||||
const CHECK = 'Check';
|
||||
const ERROR = 'Error';
|
||||
const INFO = 'Info';
|
||||
const NORESTART = 'NoRestart';
|
||||
const RESTART = 'Restart';
|
||||
const RESTARTING = 'Restarting';
|
||||
const RESTARTED = 'Restarted';
|
||||
|
||||
/** @var bool */
|
||||
private $debug;
|
||||
|
||||
/** @var string */
|
||||
private $envAllowXdebug;
|
||||
|
||||
/** @var string|null */
|
||||
private $loaded;
|
||||
|
||||
/** @var LoggerInterface|null */
|
||||
private $logger;
|
||||
|
||||
/** @var bool */
|
||||
private $modeOff;
|
||||
|
||||
/** @var float */
|
||||
private $time;
|
||||
|
||||
/**
|
||||
* @param string $envAllowXdebug Prefixed _ALLOW_XDEBUG name
|
||||
* @param bool $debug Whether debug output is required
|
||||
*/
|
||||
public function __construct(string $envAllowXdebug, bool $debug)
|
||||
{
|
||||
$start = getenv(self::ENV_RESTART);
|
||||
Process::setEnv(self::ENV_RESTART);
|
||||
$this->time = is_numeric($start) ? round((microtime(true) - $start) * 1000) : 0;
|
||||
|
||||
$this->envAllowXdebug = $envAllowXdebug;
|
||||
$this->debug = $debug && defined('STDERR');
|
||||
$this->modeOff = false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Activates status message output to a PSR3 logger
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function setLogger(LoggerInterface $logger): void
|
||||
{
|
||||
$this->logger = $logger;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calls a handler method to report a message
|
||||
*
|
||||
* @throws \InvalidArgumentException If $op is not known
|
||||
*/
|
||||
public function report(string $op, ?string $data): void
|
||||
{
|
||||
if ($this->logger !== null || $this->debug) {
|
||||
$param = (string) $data;
|
||||
|
||||
switch($op) {
|
||||
case self::CHECK:
|
||||
$this->reportCheck($param);
|
||||
break;
|
||||
case self::ERROR:
|
||||
$this->reportError($param);
|
||||
break;
|
||||
case self::INFO:
|
||||
$this->reportInfo($param);
|
||||
break;
|
||||
case self::NORESTART:
|
||||
$this->reportNoRestart();
|
||||
break;
|
||||
case self::RESTART:
|
||||
$this->reportRestart();
|
||||
break;
|
||||
case self::RESTARTED:
|
||||
$this->reportRestarted();
|
||||
break;
|
||||
case self::RESTARTING:
|
||||
$this->reportRestarting($param);
|
||||
break;
|
||||
default:
|
||||
throw new \InvalidArgumentException('Unknown op handler: '.$op);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Outputs a status message
|
||||
*/
|
||||
private function output(string $text, ?string $level = null): void
|
||||
{
|
||||
if ($this->logger !== null) {
|
||||
$this->logger->log($level !== null ? $level: LogLevel::DEBUG, $text);
|
||||
}
|
||||
|
||||
if ($this->debug) {
|
||||
fwrite(STDERR, sprintf('xdebug-handler[%d] %s', getmypid(), $text.PHP_EOL));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checking status message
|
||||
*/
|
||||
private function reportCheck(string $loaded): void
|
||||
{
|
||||
list($version, $mode) = explode('|', $loaded);
|
||||
|
||||
if ($version !== '') {
|
||||
$this->loaded = '('.$version.')'.($mode !== '' ? ' xdebug.mode='.$mode : '');
|
||||
}
|
||||
$this->modeOff = $mode === 'off';
|
||||
$this->output('Checking '.$this->envAllowXdebug);
|
||||
}
|
||||
|
||||
/**
|
||||
* Error status message
|
||||
*/
|
||||
private function reportError(string $error): void
|
||||
{
|
||||
$this->output(sprintf('No restart (%s)', $error), LogLevel::WARNING);
|
||||
}
|
||||
|
||||
/**
|
||||
* Info status message
|
||||
*/
|
||||
private function reportInfo(string $info): void
|
||||
{
|
||||
$this->output($info);
|
||||
}
|
||||
|
||||
/**
|
||||
* No restart status message
|
||||
*/
|
||||
private function reportNoRestart(): void
|
||||
{
|
||||
$this->output($this->getLoadedMessage());
|
||||
|
||||
if ($this->loaded !== null) {
|
||||
$text = sprintf('No restart (%s)', $this->getEnvAllow());
|
||||
if (!((bool) getenv($this->envAllowXdebug))) {
|
||||
$text .= ' Allowed by '.($this->modeOff ? 'xdebug.mode' : 'application');
|
||||
}
|
||||
$this->output($text);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Restart status message
|
||||
*/
|
||||
private function reportRestart(): void
|
||||
{
|
||||
$this->output($this->getLoadedMessage());
|
||||
Process::setEnv(self::ENV_RESTART, (string) microtime(true));
|
||||
}
|
||||
|
||||
/**
|
||||
* Restarted status message
|
||||
*/
|
||||
private function reportRestarted(): void
|
||||
{
|
||||
$loaded = $this->getLoadedMessage();
|
||||
$text = sprintf('Restarted (%d ms). %s', $this->time, $loaded);
|
||||
$level = $this->loaded !== null ? LogLevel::WARNING : null;
|
||||
$this->output($text, $level);
|
||||
}
|
||||
|
||||
/**
|
||||
* Restarting status message
|
||||
*/
|
||||
private function reportRestarting(string $command): void
|
||||
{
|
||||
$text = sprintf('Process restarting (%s)', $this->getEnvAllow());
|
||||
$this->output($text);
|
||||
$text = 'Running: '.$command;
|
||||
$this->output($text);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the _ALLOW_XDEBUG environment variable as name=value
|
||||
*/
|
||||
private function getEnvAllow(): string
|
||||
{
|
||||
return $this->envAllowXdebug.'='.getenv($this->envAllowXdebug);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the Xdebug status and version
|
||||
*/
|
||||
private function getLoadedMessage(): string
|
||||
{
|
||||
$loaded = $this->loaded !== null ? sprintf('loaded %s', $this->loaded) : 'not loaded';
|
||||
return 'The Xdebug extension is '.$loaded;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,722 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of composer/xdebug-handler.
|
||||
*
|
||||
* (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.
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Composer\XdebugHandler;
|
||||
|
||||
use Composer\Pcre\Preg;
|
||||
use Psr\Log\LoggerInterface;
|
||||
|
||||
/**
|
||||
* @author John Stevenson <john-stevenson@blueyonder.co.uk>
|
||||
*
|
||||
* @phpstan-import-type restartData from PhpConfig
|
||||
*/
|
||||
class XdebugHandler
|
||||
{
|
||||
const SUFFIX_ALLOW = '_ALLOW_XDEBUG';
|
||||
const SUFFIX_INIS = '_ORIGINAL_INIS';
|
||||
const RESTART_ID = 'internal';
|
||||
const RESTART_SETTINGS = 'XDEBUG_HANDLER_SETTINGS';
|
||||
const DEBUG = 'XDEBUG_HANDLER_DEBUG';
|
||||
|
||||
/** @var string|null */
|
||||
protected $tmpIni;
|
||||
|
||||
/** @var bool */
|
||||
private static $inRestart;
|
||||
|
||||
/** @var string */
|
||||
private static $name;
|
||||
|
||||
/** @var string|null */
|
||||
private static $skipped;
|
||||
|
||||
/** @var bool */
|
||||
private static $xdebugActive;
|
||||
|
||||
/** @var string|null */
|
||||
private static $xdebugMode;
|
||||
|
||||
/** @var string|null */
|
||||
private static $xdebugVersion;
|
||||
|
||||
/** @var bool */
|
||||
private $cli;
|
||||
|
||||
/** @var string|null */
|
||||
private $debug;
|
||||
|
||||
/** @var string */
|
||||
private $envAllowXdebug;
|
||||
|
||||
/** @var string */
|
||||
private $envOriginalInis;
|
||||
|
||||
/** @var bool */
|
||||
private $persistent;
|
||||
|
||||
/** @var string|null */
|
||||
private $script;
|
||||
|
||||
/** @var Status */
|
||||
private $statusWriter;
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*
|
||||
* The $envPrefix is used to create distinct environment variables. It is
|
||||
* uppercased and prepended to the default base values. For example 'myapp'
|
||||
* would result in MYAPP_ALLOW_XDEBUG and MYAPP_ORIGINAL_INIS.
|
||||
*
|
||||
* @param string $envPrefix Value used in environment variables
|
||||
* @throws \RuntimeException If the parameter is invalid
|
||||
*/
|
||||
public function __construct(string $envPrefix)
|
||||
{
|
||||
if ($envPrefix === '') {
|
||||
throw new \RuntimeException('Invalid constructor parameter');
|
||||
}
|
||||
|
||||
self::$name = strtoupper($envPrefix);
|
||||
$this->envAllowXdebug = self::$name.self::SUFFIX_ALLOW;
|
||||
$this->envOriginalInis = self::$name.self::SUFFIX_INIS;
|
||||
|
||||
self::setXdebugDetails();
|
||||
self::$inRestart = false;
|
||||
|
||||
if ($this->cli = PHP_SAPI === 'cli') {
|
||||
$this->debug = (string) getenv(self::DEBUG);
|
||||
}
|
||||
|
||||
$this->statusWriter = new Status($this->envAllowXdebug, (bool) $this->debug);
|
||||
}
|
||||
|
||||
/**
|
||||
* Activates status message output to a PSR3 logger
|
||||
*/
|
||||
public function setLogger(LoggerInterface $logger): self
|
||||
{
|
||||
$this->statusWriter->setLogger($logger);
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the main script location if it cannot be called from argv
|
||||
*/
|
||||
public function setMainScript(string $script): self
|
||||
{
|
||||
$this->script = $script;
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Persist the settings to keep Xdebug out of sub-processes
|
||||
*/
|
||||
public function setPersistent(): self
|
||||
{
|
||||
$this->persistent = true;
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if Xdebug is loaded and the process needs to be restarted
|
||||
*
|
||||
* This behaviour can be disabled by setting the MYAPP_ALLOW_XDEBUG
|
||||
* environment variable to 1. This variable is used internally so that
|
||||
* the restarted process is created only once.
|
||||
*/
|
||||
public function check(): void
|
||||
{
|
||||
$this->notify(Status::CHECK, self::$xdebugVersion.'|'.self::$xdebugMode);
|
||||
$envArgs = explode('|', (string) getenv($this->envAllowXdebug));
|
||||
|
||||
if (!((bool) $envArgs[0]) && $this->requiresRestart(self::$xdebugActive)) {
|
||||
// Restart required
|
||||
$this->notify(Status::RESTART);
|
||||
$command = $this->prepareRestart();
|
||||
|
||||
if ($command !== null) {
|
||||
$this->restart($command);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (self::RESTART_ID === $envArgs[0] && count($envArgs) === 5) {
|
||||
// Restarted, so unset environment variable and use saved values
|
||||
$this->notify(Status::RESTARTED);
|
||||
|
||||
Process::setEnv($this->envAllowXdebug);
|
||||
self::$inRestart = true;
|
||||
|
||||
if (self::$xdebugVersion === null) {
|
||||
// Skipped version is only set if Xdebug is not loaded
|
||||
self::$skipped = $envArgs[1];
|
||||
}
|
||||
|
||||
$this->tryEnableSignals();
|
||||
|
||||
// Put restart settings in the environment
|
||||
$this->setEnvRestartSettings($envArgs);
|
||||
return;
|
||||
}
|
||||
|
||||
$this->notify(Status::NORESTART);
|
||||
$settings = self::getRestartSettings();
|
||||
|
||||
if ($settings !== null) {
|
||||
// Called with existing settings, so sync our settings
|
||||
$this->syncSettings($settings);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns an array of php.ini locations with at least one entry
|
||||
*
|
||||
* The equivalent of calling php_ini_loaded_file then php_ini_scanned_files.
|
||||
* The loaded ini location is the first entry and may be an empty string.
|
||||
*
|
||||
* @return non-empty-list<string>
|
||||
*/
|
||||
public static function getAllIniFiles(): array
|
||||
{
|
||||
if (self::$name !== null) {
|
||||
$env = getenv(self::$name.self::SUFFIX_INIS);
|
||||
|
||||
if (false !== $env) {
|
||||
return explode(PATH_SEPARATOR, $env);
|
||||
}
|
||||
}
|
||||
|
||||
$paths = [(string) php_ini_loaded_file()];
|
||||
$scanned = php_ini_scanned_files();
|
||||
|
||||
if ($scanned !== false) {
|
||||
$paths = array_merge($paths, array_map('trim', explode(',', $scanned)));
|
||||
}
|
||||
|
||||
return $paths;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns an array of restart settings or null
|
||||
*
|
||||
* Settings will be available if the current process was restarted, or
|
||||
* called with the settings from an existing restart.
|
||||
*
|
||||
* @phpstan-return restartData|null
|
||||
*/
|
||||
public static function getRestartSettings(): ?array
|
||||
{
|
||||
$envArgs = explode('|', (string) getenv(self::RESTART_SETTINGS));
|
||||
|
||||
if (count($envArgs) !== 6
|
||||
|| (!self::$inRestart && php_ini_loaded_file() !== $envArgs[0])) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return [
|
||||
'tmpIni' => $envArgs[0],
|
||||
'scannedInis' => (bool) $envArgs[1],
|
||||
'scanDir' => '*' === $envArgs[2] ? false : $envArgs[2],
|
||||
'phprc' => '*' === $envArgs[3] ? false : $envArgs[3],
|
||||
'inis' => explode(PATH_SEPARATOR, $envArgs[4]),
|
||||
'skipped' => $envArgs[5],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the Xdebug version that triggered a successful restart
|
||||
*/
|
||||
public static function getSkippedVersion(): string
|
||||
{
|
||||
return (string) self::$skipped;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns whether Xdebug is loaded and active
|
||||
*
|
||||
* true: if Xdebug is loaded and is running in an active mode.
|
||||
* false: if Xdebug is not loaded, or it is running with xdebug.mode=off.
|
||||
*/
|
||||
public static function isXdebugActive(): bool
|
||||
{
|
||||
self::setXdebugDetails();
|
||||
return self::$xdebugActive;
|
||||
}
|
||||
|
||||
/**
|
||||
* Allows an extending class to decide if there should be a restart
|
||||
*
|
||||
* The default is to restart if Xdebug is loaded and its mode is not "off".
|
||||
*/
|
||||
protected function requiresRestart(bool $default): bool
|
||||
{
|
||||
return $default;
|
||||
}
|
||||
|
||||
/**
|
||||
* Allows an extending class to access the tmpIni
|
||||
*
|
||||
* @param non-empty-list<string> $command
|
||||
*/
|
||||
protected function restart(array $command): void
|
||||
{
|
||||
$this->doRestart($command);
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes the restarted command then deletes the tmp ini
|
||||
*
|
||||
* @param non-empty-list<string> $command
|
||||
* @phpstan-return never
|
||||
*/
|
||||
private function doRestart(array $command): void
|
||||
{
|
||||
if (PHP_VERSION_ID >= 70400) {
|
||||
$cmd = $command;
|
||||
$displayCmd = sprintf('[%s]', implode(', ', $cmd));
|
||||
} else {
|
||||
$cmd = Process::escapeShellCommand($command);
|
||||
if (defined('PHP_WINDOWS_VERSION_BUILD')) {
|
||||
// Outer quotes required on cmd string below PHP 8
|
||||
$cmd = '"'.$cmd.'"';
|
||||
}
|
||||
$displayCmd = $cmd;
|
||||
}
|
||||
|
||||
$this->tryEnableSignals();
|
||||
$this->notify(Status::RESTARTING, $displayCmd);
|
||||
|
||||
$process = proc_open($cmd, [], $pipes);
|
||||
if (is_resource($process)) {
|
||||
$exitCode = proc_close($process);
|
||||
}
|
||||
|
||||
if (!isset($exitCode)) {
|
||||
// Unlikely that php or the default shell cannot be invoked
|
||||
$this->notify(Status::ERROR, 'Unable to restart process');
|
||||
$exitCode = -1;
|
||||
} else {
|
||||
$this->notify(Status::INFO, 'Restarted process exited '.$exitCode);
|
||||
}
|
||||
|
||||
if ($this->debug === '2') {
|
||||
$this->notify(Status::INFO, 'Temp ini saved: '.$this->tmpIni);
|
||||
} else {
|
||||
@unlink((string) $this->tmpIni);
|
||||
}
|
||||
|
||||
exit($exitCode);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the command line array if everything was written for the restart
|
||||
*
|
||||
* If any of the following fails (however unlikely) we must return false to
|
||||
* stop potential recursion:
|
||||
* - tmp ini file creation
|
||||
* - environment variable creation
|
||||
*
|
||||
* @return non-empty-list<string>|null
|
||||
*/
|
||||
private function prepareRestart(): ?array
|
||||
{
|
||||
if (!$this->cli) {
|
||||
$this->notify(Status::ERROR, 'Unsupported SAPI: '.PHP_SAPI);
|
||||
return null;
|
||||
}
|
||||
|
||||
if (($argv = $this->checkServerArgv()) === null) {
|
||||
$this->notify(Status::ERROR, '$_SERVER[argv] is not as expected');
|
||||
return null;
|
||||
}
|
||||
|
||||
if (!$this->checkConfiguration($info)) {
|
||||
$this->notify(Status::ERROR, $info);
|
||||
return null;
|
||||
}
|
||||
|
||||
$mainScript = (string) $this->script;
|
||||
if (!$this->checkMainScript($mainScript, $argv)) {
|
||||
$this->notify(Status::ERROR, 'Unable to access main script: '.$mainScript);
|
||||
return null;
|
||||
}
|
||||
|
||||
$tmpDir = sys_get_temp_dir();
|
||||
$iniError = 'Unable to create temp ini file at: '.$tmpDir;
|
||||
|
||||
if (($tmpfile = @tempnam($tmpDir, '')) === false) {
|
||||
$this->notify(Status::ERROR, $iniError);
|
||||
return null;
|
||||
}
|
||||
|
||||
$error = null;
|
||||
$iniFiles = self::getAllIniFiles();
|
||||
$scannedInis = count($iniFiles) > 1;
|
||||
|
||||
if (!$this->writeTmpIni($tmpfile, $iniFiles, $error)) {
|
||||
$this->notify(Status::ERROR, $error ?? $iniError);
|
||||
@unlink($tmpfile);
|
||||
return null;
|
||||
}
|
||||
|
||||
if (!$this->setEnvironment($scannedInis, $iniFiles, $tmpfile)) {
|
||||
$this->notify(Status::ERROR, 'Unable to set environment variables');
|
||||
@unlink($tmpfile);
|
||||
return null;
|
||||
}
|
||||
|
||||
$this->tmpIni = $tmpfile;
|
||||
|
||||
return $this->getCommand($argv, $tmpfile, $mainScript);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the tmp ini file was written
|
||||
*
|
||||
* @param non-empty-list<string> $iniFiles All ini files used in the current process
|
||||
*/
|
||||
private function writeTmpIni(string $tmpFile, array $iniFiles, ?string &$error): bool
|
||||
{
|
||||
// $iniFiles has at least one item and it may be empty
|
||||
if ($iniFiles[0] === '') {
|
||||
array_shift($iniFiles);
|
||||
}
|
||||
|
||||
$content = '';
|
||||
$sectionRegex = '/^\s*\[(?:PATH|HOST)\s*=/mi';
|
||||
$xdebugRegex = '/^\s*(zend_extension\s*=.*xdebug.*)$/mi';
|
||||
|
||||
foreach ($iniFiles as $file) {
|
||||
// Check for inaccessible ini files
|
||||
if (($data = @file_get_contents($file)) === false) {
|
||||
$error = 'Unable to read ini: '.$file;
|
||||
return false;
|
||||
}
|
||||
// Check and remove directives after HOST and PATH sections
|
||||
if (Preg::isMatchWithOffsets($sectionRegex, $data, $matches)) {
|
||||
$data = substr($data, 0, $matches[0][1]);
|
||||
}
|
||||
$content .= Preg::replace($xdebugRegex, ';$1', $data).PHP_EOL;
|
||||
}
|
||||
|
||||
// Merge loaded settings into our ini content, if it is valid
|
||||
$config = parse_ini_string($content);
|
||||
$loaded = ini_get_all(null, false);
|
||||
|
||||
if (false === $config || false === $loaded) {
|
||||
$error = 'Unable to parse ini data';
|
||||
return false;
|
||||
}
|
||||
|
||||
$content .= $this->mergeLoadedConfig($loaded, $config);
|
||||
|
||||
// Work-around for https://bugs.php.net/bug.php?id=75932
|
||||
$content .= 'opcache.enable_cli=0'.PHP_EOL;
|
||||
|
||||
return (bool) @file_put_contents($tmpFile, $content);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the command line arguments for the restart
|
||||
*
|
||||
* @param non-empty-list<string> $argv
|
||||
* @return non-empty-list<string>
|
||||
*/
|
||||
private function getCommand(array $argv, string $tmpIni, string $mainScript): array
|
||||
{
|
||||
$php = [PHP_BINARY];
|
||||
$args = array_slice($argv, 1);
|
||||
|
||||
if (!$this->persistent) {
|
||||
// Use command-line options
|
||||
array_push($php, '-n', '-c', $tmpIni);
|
||||
}
|
||||
|
||||
return array_merge($php, [$mainScript], $args);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the restart environment variables were set
|
||||
*
|
||||
* No need to update $_SERVER since this is set in the restarted process.
|
||||
*
|
||||
* @param non-empty-list<string> $iniFiles All ini files used in the current process
|
||||
*/
|
||||
private function setEnvironment(bool $scannedInis, array $iniFiles, string $tmpIni): bool
|
||||
{
|
||||
$scanDir = getenv('PHP_INI_SCAN_DIR');
|
||||
$phprc = getenv('PHPRC');
|
||||
|
||||
// Make original inis available to restarted process
|
||||
if (!putenv($this->envOriginalInis.'='.implode(PATH_SEPARATOR, $iniFiles))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if ($this->persistent) {
|
||||
// Use the environment to persist the settings
|
||||
if (!putenv('PHP_INI_SCAN_DIR=') || !putenv('PHPRC='.$tmpIni)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Flag restarted process and save values for it to use
|
||||
$envArgs = [
|
||||
self::RESTART_ID,
|
||||
self::$xdebugVersion,
|
||||
(int) $scannedInis,
|
||||
false === $scanDir ? '*' : $scanDir,
|
||||
false === $phprc ? '*' : $phprc,
|
||||
];
|
||||
|
||||
return putenv($this->envAllowXdebug.'='.implode('|', $envArgs));
|
||||
}
|
||||
|
||||
/**
|
||||
* Logs status messages
|
||||
*/
|
||||
private function notify(string $op, ?string $data = null): void
|
||||
{
|
||||
$this->statusWriter->report($op, $data);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns default, changed and command-line ini settings
|
||||
*
|
||||
* @param mixed[] $loadedConfig All current ini settings
|
||||
* @param mixed[] $iniConfig Settings from user ini files
|
||||
*
|
||||
*/
|
||||
private function mergeLoadedConfig(array $loadedConfig, array $iniConfig): string
|
||||
{
|
||||
$content = '';
|
||||
|
||||
foreach ($loadedConfig as $name => $value) {
|
||||
// Value will either be null, string or array (HHVM only)
|
||||
if (!is_string($value)
|
||||
|| strpos($name, 'xdebug') === 0
|
||||
|| $name === 'apc.mmap_file_mask') {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!isset($iniConfig[$name]) || $iniConfig[$name] !== $value) {
|
||||
// Double-quote escape each value
|
||||
$content .= $name.'="'.addcslashes($value, '\\"').'"'.PHP_EOL;
|
||||
}
|
||||
}
|
||||
|
||||
return $content;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the script name can be used
|
||||
*
|
||||
* @param non-empty-list<string> $argv
|
||||
*/
|
||||
private function checkMainScript(string &$mainScript, array $argv): bool
|
||||
{
|
||||
if ($mainScript !== '') {
|
||||
// Allow an application to set -- for standard input
|
||||
return file_exists($mainScript) || '--' === $mainScript;
|
||||
}
|
||||
|
||||
if (file_exists($mainScript = $argv[0])) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// Use a backtrace to resolve Phar and chdir issues.
|
||||
$trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
|
||||
$main = end($trace);
|
||||
|
||||
if ($main !== false && isset($main['file'])) {
|
||||
return file_exists($mainScript = $main['file']);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds restart settings to the environment
|
||||
*
|
||||
* @param non-empty-list<string> $envArgs
|
||||
*/
|
||||
private function setEnvRestartSettings(array $envArgs): void
|
||||
{
|
||||
$settings = [
|
||||
php_ini_loaded_file(),
|
||||
$envArgs[2],
|
||||
$envArgs[3],
|
||||
$envArgs[4],
|
||||
getenv($this->envOriginalInis),
|
||||
self::$skipped,
|
||||
];
|
||||
|
||||
Process::setEnv(self::RESTART_SETTINGS, implode('|', $settings));
|
||||
}
|
||||
|
||||
/**
|
||||
* Syncs settings and the environment if called with existing settings
|
||||
*
|
||||
* @phpstan-param restartData $settings
|
||||
*/
|
||||
private function syncSettings(array $settings): void
|
||||
{
|
||||
if (false === getenv($this->envOriginalInis)) {
|
||||
// Called by another app, so make original inis available
|
||||
Process::setEnv($this->envOriginalInis, implode(PATH_SEPARATOR, $settings['inis']));
|
||||
}
|
||||
|
||||
self::$skipped = $settings['skipped'];
|
||||
$this->notify(Status::INFO, 'Process called with existing restart settings');
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if there are no known configuration issues
|
||||
*/
|
||||
private function checkConfiguration(?string &$info): bool
|
||||
{
|
||||
if (!function_exists('proc_open')) {
|
||||
$info = 'proc_open function is disabled';
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!file_exists(PHP_BINARY)) {
|
||||
$info = 'PHP_BINARY is not available';
|
||||
return false;
|
||||
}
|
||||
|
||||
if (extension_loaded('uopz') && !((bool) ini_get('uopz.disable'))) {
|
||||
// uopz works at opcode level and disables exit calls
|
||||
if (function_exists('uopz_allow_exit')) {
|
||||
@uopz_allow_exit(true);
|
||||
} else {
|
||||
$info = 'uopz extension is not compatible';
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Check UNC paths when using cmd.exe
|
||||
if (defined('PHP_WINDOWS_VERSION_BUILD') && PHP_VERSION_ID < 70400) {
|
||||
$workingDir = getcwd();
|
||||
|
||||
if ($workingDir === false) {
|
||||
$info = 'unable to determine working directory';
|
||||
return false;
|
||||
}
|
||||
|
||||
if (0 === strpos($workingDir, '\\\\')) {
|
||||
$info = 'cmd.exe does not support UNC paths: '.$workingDir;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Enables async signals and control interrupts in the restarted process
|
||||
*
|
||||
* Available on Unix PHP 7.1+ with the pcntl extension and Windows PHP 7.4+.
|
||||
*/
|
||||
private function tryEnableSignals(): void
|
||||
{
|
||||
if (function_exists('pcntl_async_signals') && function_exists('pcntl_signal')) {
|
||||
pcntl_async_signals(true);
|
||||
$message = 'Async signals enabled';
|
||||
|
||||
if (!self::$inRestart) {
|
||||
// Restarting, so ignore SIGINT in parent
|
||||
pcntl_signal(SIGINT, SIG_IGN);
|
||||
} elseif (is_int(pcntl_signal_get_handler(SIGINT))) {
|
||||
// Restarted, no handler set so force default action
|
||||
pcntl_signal(SIGINT, SIG_DFL);
|
||||
}
|
||||
}
|
||||
|
||||
if (!self::$inRestart && function_exists('sapi_windows_set_ctrl_handler')) {
|
||||
// Restarting, so set a handler to ignore CTRL events in the parent.
|
||||
// This ensures that CTRL+C events will be available in the child
|
||||
// process without having to enable them there, which is unreliable.
|
||||
sapi_windows_set_ctrl_handler(function ($evt) {});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns $_SERVER['argv'] if it is as expected
|
||||
*
|
||||
* @return non-empty-list<string>|null
|
||||
*/
|
||||
private function checkServerArgv(): ?array
|
||||
{
|
||||
$result = [];
|
||||
|
||||
if (isset($_SERVER['argv']) && is_array($_SERVER['argv'])) {
|
||||
foreach ($_SERVER['argv'] as $value) {
|
||||
if (!is_string($value)) {
|
||||
return null;
|
||||
}
|
||||
|
||||
$result[] = $value;
|
||||
}
|
||||
}
|
||||
|
||||
return count($result) > 0 ? $result : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets static properties $xdebugActive, $xdebugVersion and $xdebugMode
|
||||
*/
|
||||
private static function setXdebugDetails(): void
|
||||
{
|
||||
if (self::$xdebugActive !== null) {
|
||||
return;
|
||||
}
|
||||
|
||||
self::$xdebugActive = false;
|
||||
if (!extension_loaded('xdebug')) {
|
||||
return;
|
||||
}
|
||||
|
||||
$version = phpversion('xdebug');
|
||||
self::$xdebugVersion = $version !== false ? $version : 'unknown';
|
||||
|
||||
if (version_compare(self::$xdebugVersion, '3.1', '>=')) {
|
||||
$modes = xdebug_info('mode');
|
||||
self::$xdebugMode = count($modes) === 0 ? 'off' : implode(',', $modes);
|
||||
self::$xdebugActive = self::$xdebugMode !== 'off';
|
||||
return;
|
||||
}
|
||||
|
||||
// See if xdebug.mode is supported in this version
|
||||
$iniMode = ini_get('xdebug.mode');
|
||||
if ($iniMode === false) {
|
||||
self::$xdebugActive = true;
|
||||
return;
|
||||
}
|
||||
|
||||
// Environment value wins but cannot be empty
|
||||
$envMode = (string) getenv('XDEBUG_MODE');
|
||||
if ($envMode !== '') {
|
||||
self::$xdebugMode = $envMode;
|
||||
} else {
|
||||
self::$xdebugMode = $iniMode !== '' ? $iniMode : 'off';
|
||||
}
|
||||
|
||||
// An empty comma-separated list is treated as mode 'off'
|
||||
if (Preg::isMatch('/^,+$/', str_replace(' ', '', self::$xdebugMode))) {
|
||||
self::$xdebugMode = 'off';
|
||||
}
|
||||
|
||||
self::$xdebugActive = self::$xdebugMode !== 'off';
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user