Add the ability to find min required rr version

Author: msmakouz

composer.json

@@ -10,7 +10,9 @@
     "license": "MIT",
     "require": {
         "php": "^8.1",
-        "symfony/process": "^5.4 || ^6.0"
+        "symfony/process": "^5.4 || ^6.0",
+        "composer-runtime-api": "^2.0",
+        "composer/semver": "^3.3"
     },
     "require-dev": {
         "phpunit/phpunit": "^9.6 || ^10.0",

src/Exception/RequiredVersionException.php

@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RoadRunner\VersionChecker\Exception;
+
+final class RequiredVersionException extends VersionCheckerException
+{
+}

src/Version/Comparator.php

@@ -4,6 +4,8 @@
 
 namespace RoadRunner\VersionChecker\Version;
 
+use Composer\Semver\Comparator as SemverComparator;
+
 final class Comparator implements ComparatorInterface
 {
     /**
@@ -12,7 +14,7 @@ final class Comparator implements ComparatorInterface
      */
     public function greaterThan(string $requested, string $installed): bool
     {
-        return \version_compare($installed, $requested) >= 0;
+        return SemverComparator::greaterThanOrEqualTo($installed, $requested);
     }
 
     /**
@@ -21,7 +23,7 @@ public function greaterThan(string $requested, string $installed): bool
      */
     public function lessThan(string $requested, string $installed): bool
     {
-        return \version_compare($installed, $requested) <= 0;
+        return SemverComparator::lessThanOrEqualTo($installed, $requested);
     }
 
     /**
@@ -30,6 +32,6 @@ public function lessThan(string $requested, string $installed): bool
      */
     public function equal(string $requested, string $installed): bool
     {
-        return \version_compare($installed, $requested) === 0;
+        return SemverComparator::equalTo($installed, $requested);
     }
 }

src/Version/Required.php

@@ -4,13 +4,55 @@
 
 namespace RoadRunner\VersionChecker\Version;
 
+use Composer\InstalledVersions;
+use Composer\Semver\Comparator as SemverComparator;
+use Composer\Semver\VersionParser;
+
 final class Required implements RequiredInterface
 {
+    private const ROADRUNNER_PACKAGE = 'spiral/roadrunner';
+
     /**
+     * @return non-empty-string|null
+     */
+    public function getRequiredVersion(): ?string
+    {
+        $parser = new VersionParser();
+
+        $version = null;
+        foreach (InstalledVersions::getInstalledPackages() as $package) {
+            $path = InstalledVersions::getInstallPath($package);
+            if ($path !== null && \file_exists($path . '/composer.json')) {
+                /** @var array $composerJson */
+                $composerJson = \json_decode(\file_get_contents($path . '/composer.json'), true);
+
+                if (isset($composerJson['require']) && \is_array($composerJson['require'])) {
+                    /** @var non-empty-string $packageVersion */
+                    foreach ($composerJson['require'] as $package => $packageVersion) {
+                        if ($package === self::ROADRUNNER_PACKAGE) {
+                            /** @var non-empty-string $packageVersion */
+                            $packageVersion = $parser->normalize($packageVersion);
+                            $version = $this->getMinimumVersion($packageVersion, $version);
+                        }
+                    }
+                }
+            }
+        }
+
+        return $version;
+    }
+
+    /**
+     * @param non-empty-string $version
+     * @param non-empty-string|null $previous
      * @return non-empty-string
      */
-    public function getRequiredVersion(): string
+    private function getMinimumVersion(string $version, ?string $previous = null): string
     {
-        return '1.0'; // TODO need implementation
+        if ($previous === null) {
+            return $version;
+        }
+
+        return SemverComparator::lessThan($version, $previous) ? $version : $previous;
     }
 }

src/Version/RequiredInterface.php

@@ -7,7 +7,7 @@
 interface RequiredInterface
 {
     /**
-     * @return non-empty-string
+     * @return non-empty-string|null
      */
-    public function getRequiredVersion(): string;
+    public function getRequiredVersion(): ?string;
 }

src/VersionChecker.php

@@ -4,6 +4,7 @@
 
 namespace RoadRunner\VersionChecker;
 
+use RoadRunner\VersionChecker\Exception\RequiredVersionException;
 use RoadRunner\VersionChecker\Exception\RoadrunnerNotInstalledException;
 use RoadRunner\VersionChecker\Exception\UnsupportedVersionException;
 use RoadRunner\VersionChecker\Version\Comparator;
@@ -27,12 +28,21 @@ public function __construct(
      *
      * @throws UnsupportedVersionException
      * @throws RoadrunnerNotInstalledException
+     * @throws RequiredVersionException
      */
     public function greaterThan(?string $version = null): void
     {
         if (empty($version)) {
             $version = $this->requiredVersion->getRequiredVersion();
         }
+
+        if (empty($version)) {
+            throw new RequiredVersionException(
+                'Unable to determine required RoadRunner version.' .
+                ' Please specify the required version in the `$version` parameter.'
+            );
+        }
+
         $installedVersion = $this->installedVersion->getInstalledVersion();
 
         if (!$this->comparator->greaterThan($version, $installedVersion)) {

tests/src/Unit/Version/RequiredTest.php

@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RoadRunner\VersionChecker\Tests\Unit\Version;
+
+use PHPUnit\Framework\TestCase;
+use RoadRunner\VersionChecker\Version\Required;
+
+final class RequiredTest extends TestCase
+{
+    /**
+     * @dataProvider versionsDataProvider
+     */
+    public function testGetMinimumVersion(string $version, ?string $previous, string $expected): void
+    {
+        $required = new Required();
+        $ref = new \ReflectionMethod($required, 'getMinimumVersion');
+
+        $this->assertSame($expected, $ref->invoke($required, $version, $previous));
+    }
+
+    public static function versionsDataProvider(): \Traversable
+    {
+        // Test case with $previous === null
+        yield ['1.0.0', null, '1.0.0'];
+
+        // Test case with $version < $previous
+        yield ['1.0.0', '2.0.0', '1.0.0'];
+        yield ['1.0.0-alpha', '1.0.0', '1.0.0-alpha'];
+
+        // Test case with $version >= $previous
+        yield ['2.0.0', '1.0.0', '1.0.0'];
+        yield ['1.0.0', '1.0.0-alpha', '1.0.0-alpha'];
+        yield ['1.0.0', '1.0.0', '1.0.0'];
+    }
+}

tests/src/Unit/VersionCheckerTest.php

@@ -5,6 +5,7 @@
 namespace RoadRunner\VersionChecker\Tests\Unit;
 
 use PHPUnit\Framework\TestCase;
+use RoadRunner\VersionChecker\Exception\RequiredVersionException;
 use RoadRunner\VersionChecker\Exception\UnsupportedVersionException;
 use RoadRunner\VersionChecker\Version\ComparatorInterface;
 use RoadRunner\VersionChecker\Version\InstalledInterface;
@@ -61,6 +62,29 @@ public function testSuccessGreaterThanWithVersion(): void
         $checker->greaterThan('1.0');
     }
 
+    public function testGreaterThanWithoutVersionAndWithoutRoadRunnerPackage(): void
+    {
+        $comparator = $this->createMock(ComparatorInterface::class);
+        $comparator
+            ->expects($this->never())
+            ->method('greaterThan');
+
+        $requiredVersion = $this->createMock(RequiredInterface::class);
+        $requiredVersion
+            ->expects($this->once())
+            ->method('getRequiredVersion')
+            ->willReturn(null);
+
+        $checker = new VersionChecker(
+            $this->createMock(InstalledInterface::class),
+            $requiredVersion,
+            $comparator
+        );
+
+        $this->expectException(RequiredVersionException::class);
+        $checker->greaterThan();
+    }
+
     /**
      * @dataProvider invalidVersionsDataProvider
      */