Use sebastian/version-requirement

README.md

@@ -57,6 +57,7 @@ Here is a list of all components that are primarily developed and maintained by
 * [sebastian/recursion-context](https://github.com/sebastianbergmann/recursion-context)
 * [sebastian/type](https://github.com/sebastianbergmann/type)
 * [sebastian/version](https://github.com/sebastianbergmann/version)
+* [sebastian/version-requirement](https://github.com/sebastianbergmann/version-requirement)
 
 A very special thanks to everyone who has contributed to the [PHPUnit Manual](https://github.com/sebastianbergmann/phpunit-documentation-english).
 

build.xml

@@ -303,6 +303,13 @@
             </fileset>
         </copy>
 
+        <copy file="${basedir}/vendor/sebastian/version-requirement/LICENSE" tofile="${basedir}/build/tmp/phar/sebastian-version-requirement/LICENSE"/>
+        <copy todir="${basedir}/build/tmp/phar/sebastian-version-requirement">
+            <fileset dir="${basedir}/vendor/sebastian/version-requirement/src">
+                <include name="**/*.php" />
+            </fileset>
+        </copy>
+
         <copy file="${basedir}/vendor/staabm/side-effects-detector/LICENSE" tofile="${basedir}/build/tmp/phar/staabm-side-effects-detector/LICENSE"/>
         <copy todir="${basedir}/build/tmp/phar/staabm-side-effects-detector">
             <fileset dir="${basedir}/vendor/staabm/side-effects-detector/lib">

composer.json

@@ -27,6 +27,7 @@
         "security": "https://github.com/sebastianbergmann/phpunit/security/policy"
     },
     "prefer-stable": true,
+    "minimum-stability": "dev",
     "require": {
         "php": ">=8.4.1",
         "ext-dom": "*",
@@ -55,6 +56,7 @@
         "sebastian/recursion-context": "^8.0.0",
         "sebastian/type": "^7.0.1",
         "sebastian/version": "^7.0.0",
+        "sebastian/version-requirement": "^1.0",
         "staabm/side-effects-detector": "^1.0.5"
     },
     "config": {

src/Metadata/Api/Requirements.php

@@ -42,6 +42,7 @@
 use PHPUnit\Metadata\Version\Requirement;
 use PHPUnit\Runner\Version;
 use PHPUnit\TextUI\Configuration\Registry as ConfigurationRegistry;
+use SebastianBergmann\VersionRequirement\Requirement as RequirementImplementation;
 
 /**
  * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
@@ -68,7 +69,7 @@ public function requirementsNotSatisfiedFor(string $className, string $methodNam
 
                 $this->warnAboutIncompleteVersion($metadata->versionRequirement(), $className, $methodName);
 
-                if (!$versionRequirement->isSatisfiedBy(PHP_VERSION)) {
+                if (!$this->isSatisfiedBy($versionRequirement, PHP_VERSION)) {
                     $notSatisfied[] = sprintf(
                         'PHP %s is required.',
                         $versionRequirement->asString(),
@@ -91,7 +92,7 @@ public function requirementsNotSatisfiedFor(string $className, string $methodNam
 
                 if (!extension_loaded($metadata->extension()) ||
                     ($metadata->hasVersionRequirement() &&
-                    !$metadata->versionRequirement()->isSatisfiedBy($extensionVersion))) {
+                    !$this->isSatisfiedBy($metadata->versionRequirement(), $extensionVersion))) {
                     $notSatisfied[] = sprintf(
                         'PHP extension %s%s is required.',
                         $metadata->extension(),
@@ -107,7 +108,7 @@ public function requirementsNotSatisfiedFor(string $className, string $methodNam
 
                 $this->warnAboutIncompleteVersion($metadata->versionRequirement(), $className, $methodName);
 
-                if (!$versionRequirement->isSatisfiedBy(Version::id())) {
+                if (!$this->isSatisfiedBy($versionRequirement, Version::id())) {
                     $notSatisfied[] = sprintf(
                         'PHPUnit %s is required.',
                         $versionRequirement->asString(),
@@ -269,6 +270,17 @@ public function requiresXdebug(string $className, string $methodName): bool
         return false;
     }
 
+    private function isSatisfiedBy(Requirement $versionRequirement, string $version): bool
+    {
+        $requirement = $versionRequirement->asString();
+
+        if ($versionRequirement instanceof InvalidVersionRequirement || $requirement === '') {
+            return false;
+        }
+
+        return RequirementImplementation::from($requirement)->isSatisfiedBy($version);
+    }
+
     /**
      * @param class-string     $className
      * @param non-empty-string $methodName

src/Metadata/Version/ComparisonRequirement.php

@@ -9,7 +9,6 @@
  */
 namespace PHPUnit\Metadata\Version;
 
-use function version_compare;
 use PHPUnit\Util\VersionComparisonOperator;
 
 /**
@@ -28,11 +27,6 @@ public function __construct(string $version, VersionComparisonOperator $operator
         $this->operator = $operator;
     }
 
-    public function isSatisfiedBy(string $version): bool
-    {
-        return version_compare($version, $this->version, $this->operator->asString());
-    }
-
     public function asString(): string
     {
         return $this->operator->asString() . ' ' . $this->version;

src/Metadata/Version/ConstraintRequirement.php

@@ -9,47 +9,22 @@
  */
 namespace PHPUnit\Metadata\Version;
 
-use function assert;
-use function preg_replace;
-use PharIo\Version\Version;
-use PharIo\Version\VersionConstraint;
-
 /**
  * @immutable
  *
  * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
  */
 final readonly class ConstraintRequirement extends Requirement
 {
-    private VersionConstraint $constraint;
+    private string $constraint;
 
-    public function __construct(VersionConstraint $constraint)
+    public function __construct(string $constraint)
     {
         $this->constraint = $constraint;
     }
 
-    public function isSatisfiedBy(string $version): bool
-    {
-        return $this->constraint->complies(
-            new Version($this->sanitize($version)),
-        );
-    }
-
     public function asString(): string
     {
-        return $this->constraint->asString();
-    }
-
-    private function sanitize(string $version): string
-    {
-        $sanitized = preg_replace(
-            '/^(\d+\.\d+(?:.\d+)?).*$/',
-            '$1',
-            $version,
-        );
-
-        assert($sanitized !== null);
-
-        return $sanitized;
+        return $this->constraint;
     }
 }

src/Metadata/Version/InvalidVersionRequirement.php

@@ -29,11 +29,6 @@ public function __construct(string $message)
         $this->message = $message;
     }
 
-    public function isSatisfiedBy(string $version): bool
-    {
-        return false;
-    }
-
     /**
      * @return non-empty-string
      */

src/Metadata/Version/Requirement.php

@@ -9,12 +9,14 @@
  */
 namespace PHPUnit\Metadata\Version;
 
-use function preg_match;
-use PharIo\Version\UnsupportedVersionConstraintException;
-use PharIo\Version\VersionConstraintParser;
+use function assert;
+use function explode;
 use PHPUnit\Metadata\InvalidVersionRequirementException;
-use PHPUnit\Util\InvalidVersionOperatorException;
 use PHPUnit\Util\VersionComparisonOperator;
+use SebastianBergmann\VersionRequirement\ComparisonRequirement as ComparisonRequirementImplementation;
+use SebastianBergmann\VersionRequirement\ConstraintRequirement as ConstraintRequirementImplementation;
+use SebastianBergmann\VersionRequirement\Exception;
+use SebastianBergmann\VersionRequirement\Requirement as RequirementImplementation;
 
 /**
  * @immutable
@@ -23,35 +25,32 @@
  */
 abstract readonly class Requirement
 {
-    private const string VERSION_COMPARISON = "/(?P<operator>!=|<|<=|<>|=|==|>|>=)?\s*(?P<version>[\d\.-]+(dev|(RC|alpha|beta)[\d\.])?)[ \t]*\r?$/m";
-
     /**
-     * @throws InvalidVersionOperatorException
+     * @param non-empty-string $versionRequirement
+     *
      * @throws InvalidVersionRequirementException
      */
     public static function from(string $versionRequirement): self
     {
         try {
-            return new ConstraintRequirement(
-                (new VersionConstraintParser)->parse(
-                    $versionRequirement,
+            $requirement = RequirementImplementation::from($versionRequirement);
+        } catch (Exception) {
+            throw new InvalidVersionRequirementException;
+        }
+
+        if ($requirement instanceof ComparisonRequirementImplementation) {
+            return new ComparisonRequirement(
+                $requirement->version(),
+                new VersionComparisonOperator(
+                    explode(' ', $requirement->asString(), 2)[0],
                 ),
             );
-        } catch (UnsupportedVersionConstraintException) {
-            if (preg_match(self::VERSION_COMPARISON, $versionRequirement, $matches) > 0) {
-                return new ComparisonRequirement(
-                    $matches['version'],
-                    new VersionComparisonOperator(
-                        $matches['operator'] !== '' ? $matches['operator'] : '>=',
-                    ),
-                );
-            }
         }
 
-        throw new InvalidVersionRequirementException;
-    }
+        assert($requirement instanceof ConstraintRequirementImplementation);
 
-    abstract public function isSatisfiedBy(string $version): bool;
+        return new ConstraintRequirement($requirement->asString());
+    }
 
     abstract public function asString(): string;
 }

src/Util/VersionComparisonOperator.php

@@ -9,7 +9,8 @@
  */
 namespace PHPUnit\Util;
 
-use function in_array;
+use SebastianBergmann\VersionRequirement\InvalidVersionOperatorException as InvalidVersionOperatorExceptionImplementation;
+use SebastianBergmann\VersionRequirement\VersionComparisonOperator as VersionComparisonOperatorImplementation;
 
 /**
  * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
@@ -24,15 +25,15 @@
     private string $operator;
 
     /**
-     * @param '!='|'<'|'<='|'<>'|'='|'=='|'>'|'>='|'eq'|'ge'|'gt'|'le'|'lt'|'ne' $operator
-     *
      * @throws InvalidVersionOperatorException
      */
     public function __construct(string $operator)
     {
-        $this->ensureOperatorIsValid($operator);
-
-        $this->operator = $operator;
+        try {
+            $this->operator = new VersionComparisonOperatorImplementation($operator)->asString();
+        } catch (InvalidVersionOperatorExceptionImplementation) {
+            throw new InvalidVersionOperatorException($operator);
+        }
     }
 
     /**
@@ -42,16 +43,4 @@ public function asString(): string
     {
         return $this->operator;
     }
-
-    /**
-     * @param '!='|'<'|'<='|'<>'|'='|'=='|'>'|'>='|'eq'|'ge'|'gt'|'le'|'lt'|'ne' $operator
-     *
-     * @throws InvalidVersionOperatorException
-     */
-    private function ensureOperatorIsValid(string $operator): void
-    {
-        if (!in_array($operator, ['<', 'lt', '<=', 'le', '>', 'gt', '>=', 'ge', '==', '=', 'eq', '!=', '<>', 'ne'], true)) {
-            throw new InvalidVersionOperatorException($operator);
-        }
-    }
 }