Merge pull request #8873 from Seldaek/version_selector_platform

Use all PlatformRepo packages in VersionSelector checks

UPGRADE-2.0.md

@@ -27,6 +27,8 @@
   - packages now contain an `"installed-path"` key which lists where they were installed
   - there is a top level `"dev"` key which stores whether dev requirements were installed or not
 - `PreFileDownloadEvent` now receives an `HttpDownloader` instance instead of `RemoteFilesystem`, and that instance can not be overridden by listeners anymore
+- `VersionSelector::findBestCandidate`'s third argument (phpVersion) was removed in favor of passing in a complete PlatformRepository instance into the constructor
+- `InitCommand::determineRequirements`'s fourth argument (phpVersion) should now receive a complete PlatformRepository instance or null if platform requirements are to be ignored
 - `IOInterface` now extends PSR-3's `LoggerInterface`, and has new `writeRaw` + `writeErrorRaw` methods
 - `RepositoryInterface` changes:
   - A new `loadPackages(array $packageNameMap, array $acceptableStabilities, array $stabilityFlags)` function was added for use during pool building

src/Composer/Command/CreateProjectCommand.php

@@ -336,25 +336,20 @@ EOT
         $repositorySet = new RepositorySet($stability);
         $repositorySet->addRepository($sourceRepo);
 
-        $phpVersion = null;
+        $platformRepo = null;
-        $prettyPhpVersion = null;
         if (!$ignorePlatformReqs) {
             $platformOverrides = $config->get('platform') ?: array();
-            // initialize $this->repos as it is used by the parent InitCommand
+            $platformRepo = new PlatformRepository(array(), $platformOverrides);
-            $platform = new PlatformRepository(array(), $platformOverrides);
-            $phpPackage = $platform->findPackage('php', '*');
-            $phpVersion = $phpPackage->getVersion();
-            $prettyPhpVersion = $phpPackage->getPrettyVersion();
         }
 
         // find the latest version if there are multiple
-        $versionSelector = new VersionSelector($repositorySet);
+        $versionSelector = new VersionSelector($repositorySet, $platformRepo);
-        $package = $versionSelector->findBestCandidate($name, $packageVersion, $phpVersion, $stability);
+        $package = $versionSelector->findBestCandidate($name, $packageVersion, $stability);
 
         if (!$package) {
             $errorMessage = "Could not find package $name with " . ($packageVersion ? "version $packageVersion" : "stability $stability");
-            if ($phpVersion && $versionSelector->findBestCandidate($name, $packageVersion, null, $stability)) {
+            if ($platformRepo && $versionSelector->findBestCandidate($name, $packageVersion, $stability, true)) {
-                throw new \InvalidArgumentException($errorMessage .' in a version installable using your PHP version '.$prettyPhpVersion.'.');
+                throw new \InvalidArgumentException($errorMessage .' in a version installable using your PHP version, PHP extensions and Composer version.');
             }
 
             throw new \InvalidArgumentException($errorMessage .'.');

src/Composer/Command/InitCommand.php

@@ -345,13 +345,21 @@ EOT
         // prepare to resolve dependencies
         $repos = $this->getRepos();
         $preferredStability = $minimumStability ?: 'stable';
-        $phpVersion = $repos->findPackage('php', '*')->getPrettyVersion();
+        $platformRepo = null;
+        if ($repos instanceof CompositeRepository) {
+            foreach ($repos->getRepositories() as $candidateRepo) {
+                if ($candidateRepo instanceof PlatformRepository) {
+                    $platformRepo = $candidateRepo;
+                    break;
+                }
+            }
+        }
 
         $question = 'Would you like to define your dependencies (require) interactively [<comment>yes</comment>]? ';
         $require = $input->getOption('require');
         $requirements = array();
         if ($require || $io->askConfirmation($question, true)) {
-            $requirements = $this->determineRequirements($input, $output, $require, $phpVersion, $preferredStability);
+            $requirements = $this->determineRequirements($input, $output, $require, $platformRepo, $preferredStability);
         }
         $input->setOption('require', $requirements);
 
@@ -359,7 +367,7 @@ EOT
         $requireDev = $input->getOption('require-dev');
         $devRequirements = array();
         if ($requireDev || $io->askConfirmation($question, true)) {
-            $devRequirements = $this->determineRequirements($input, $output, $requireDev, $phpVersion, $preferredStability);
+            $devRequirements = $this->determineRequirements($input, $output, $requireDev, $platformRepo, $preferredStability);
         }
         $input->setOption('require-dev', $devRequirements);
     }
@@ -403,7 +411,7 @@ EOT
         return $this->repos;
     }
 
-    final protected function determineRequirements(InputInterface $input, OutputInterface $output, $requires = array(), $phpVersion = null, $preferredStability = 'stable', $checkProvidedVersions = true, $fixed = false)
+    final protected function determineRequirements(InputInterface $input, OutputInterface $output, $requires = array(), PlatformRepository $platformRepo = null, $preferredStability = 'stable', $checkProvidedVersions = true, $fixed = false)
     {
         if ($requires) {
             $requires = $this->normalizeRequirements($requires);
@@ -413,7 +421,7 @@ EOT
             foreach ($requires as $requirement) {
                 if (!isset($requirement['version'])) {
                     // determine the best version automatically
-                    list($name, $version) = $this->findBestVersionAndNameForPackage($input, $requirement['name'], $phpVersion, $preferredStability, null, null, $fixed);
+                    list($name, $version) = $this->findBestVersionAndNameForPackage($input, $requirement['name'], $platformRepo, $preferredStability, null, null, $fixed);
                     $requirement['version'] = $version;
 
                     // replace package name from packagist.org
@@ -426,7 +434,7 @@ EOT
                     ));
                 } else {
                     // check that the specified version/constraint exists before we proceed
-                    list($name, $version) = $this->findBestVersionAndNameForPackage($input, $requirement['name'], $phpVersion, $preferredStability, $checkProvidedVersions ? $requirement['version'] : null, 'dev', $fixed);
+                    list($name, $version) = $this->findBestVersionAndNameForPackage($input, $requirement['name'], $platformRepo, $preferredStability, $checkProvidedVersions ? $requirement['version'] : null, 'dev', $fixed);
 
                     // replace package name from packagist.org
                     $requirement['name'] = $name;
@@ -550,7 +558,7 @@ EOT
                     );
 
                     if (false === $constraint) {
-                        list($name, $constraint) = $this->findBestVersionAndNameForPackage($input, $package, $phpVersion, $preferredStability);
+                        list($name, $constraint) = $this->findBestVersionAndNameForPackage($input, $package, $platformRepo, $preferredStability);
 
                         $io->writeError(sprintf(
                             'Using version <info>%s</info> for <info>%s</info>',
@@ -723,7 +731,7 @@ EOT
      *
      * @param  InputInterface            $input
      * @param  string                    $name
-     * @param  string|null               $phpVersion
+     * @param  PlatformRepository|null   $platformRepo
      * @param  string                    $preferredStability
      * @param  string|null               $requiredVersion
      * @param  string                    $minimumStability
@@ -731,18 +739,18 @@ EOT
      * @throws \InvalidArgumentException
      * @return array                     name version
      */
-    private function findBestVersionAndNameForPackage(InputInterface $input, $name, $phpVersion, $preferredStability = 'stable', $requiredVersion = null, $minimumStability = null, $fixed = null)
+    private function findBestVersionAndNameForPackage(InputInterface $input, $name, PlatformRepository $platformRepo = null, $preferredStability = 'stable', $requiredVersion = null, $minimumStability = null, $fixed = null)
     {
-        // find the latest version allowed in this repo set
+        // ignore platform repo if platform requirements are ignored
-        $versionSelector = new VersionSelector($this->getRepositorySet($input, $minimumStability));
         $ignorePlatformReqs = $input->hasOption('ignore-platform-reqs') && $input->getOption('ignore-platform-reqs');
-
-        // ignore phpVersion if platform requirements are ignored
         if ($ignorePlatformReqs) {
-            $phpVersion = null;
+            $platformRepo = null;
         }
 
-        $package = $versionSelector->findBestCandidate($name, $requiredVersion, $phpVersion, $preferredStability);
+        // find the latest version allowed in this repo set
+        $versionSelector = new VersionSelector($this->getRepositorySet($input, $minimumStability), $platformRepo);
+
+        $package = $versionSelector->findBestCandidate($name, $requiredVersion, $preferredStability);
 
         if (!$package) {
             // platform packages can not be found in the pool in versions other than the local platform's has
@@ -752,28 +760,26 @@ EOT
             }
 
             // Check whether the PHP version was the problem
-            if ($phpVersion && $versionSelector->findBestCandidate($name, $requiredVersion, null, $preferredStability)) {
+            if ($platformRepo && $versionSelector->findBestCandidate($name, $requiredVersion, $preferredStability, true)) {
                 throw new \InvalidArgumentException(sprintf(
-                    'Package %s at version %s has a PHP requirement incompatible with your PHP version (%s)',
+                    'Package %s at version %s has a PHP requirement incompatible with your PHP version, PHP extensions and Composer version',
                     $name,
-                    $requiredVersion,
+                    $requiredVersion
-                    $phpVersion
                 ));
             }
             // Check whether the required version was the problem
-            if ($requiredVersion && $versionSelector->findBestCandidate($name, null, $phpVersion, $preferredStability)) {
+            if ($requiredVersion && $versionSelector->findBestCandidate($name, null, $preferredStability)) {
                 throw new \InvalidArgumentException(sprintf(
                     'Could not find package %s in a version matching %s',
                     $name,
                     $requiredVersion
                 ));
             }
-            // Check whether the PHP version was the problem
+            // Check whether the PHP version was the problem for all versions
-            if ($phpVersion && $versionSelector->findBestCandidate($name)) {
+            if ($platformRepo && $versionSelector->findBestCandidate($name, null, $preferredStability, true)) {
                 throw new \InvalidArgumentException(sprintf(
-                    'Could not find package %s in any version matching your PHP version (%s)',
+                    'Could not find package %s in any version matching your PHP version, PHP extensions and Composer version',
-                    $name,
+                    $name
-                    $phpVersion
                 ));
             }
 

src/Composer/Command/RequireCommand.php

@@ -166,7 +166,7 @@ EOT
         $platformOverrides = $composer->getConfig()->get('platform') ?: array();
         // initialize $this->repos as it is used by the parent InitCommand
         $this->repos = new CompositeRepository(array_merge(
-            array(new PlatformRepository(array(), $platformOverrides)),
+            array($platformRepo = new PlatformRepository(array(), $platformOverrides)),
             $repos
         ));
 
@@ -176,9 +176,16 @@ EOT
             $preferredStability = $composer->getPackage()->getMinimumStability();
         }
 
-        $phpVersion = $this->repos->findPackage('php', '*')->getPrettyVersion();
         try {
-            $requirements = $this->determineRequirements($input, $output, $input->getArgument('packages'), $phpVersion, $preferredStability, !$input->getOption('no-update'), $input->getOption('fixed'));
+            $requirements = $this->determineRequirements(
+                $input,
+                $output,
+                $input->getArgument('packages'),
+                $input->getOption('ignore-platform-reqs') ? null : $platformRepo,
+                $preferredStability,
+                !$input->getOption('no-update'),
+                $input->getOption('fixed')
+            );
         } catch (\Exception $e) {
             if ($this->newlyCreated) {
                 throw new \RuntimeException('No composer.json present in the current directory, this may be the cause of the following exception.', 0, $e);

src/Composer/Command/ShowCommand.php

@@ -151,7 +151,6 @@ EOT
         }
         $platformRepo = new PlatformRepository(array(), $platformOverrides);
         $lockedRepo = null;
-        $phpVersion = $platformRepo->findPackage('php', '*')->getVersion();
 
         if ($input->getOption('self')) {
             $package = $this->getComposer()->getPackage();
@@ -249,7 +248,7 @@ EOT
             } else {
                 $latestPackage = null;
                 if ($input->getOption('latest')) {
-                    $latestPackage = $this->findLatestPackage($package, $composer, $phpVersion);
+                    $latestPackage = $this->findLatestPackage($package, $composer, $platformRepo);
                 }
                 if ($input->getOption('outdated') && $input->getOption('strict') && $latestPackage && $latestPackage->getFullPrettyVersion() !== $package->getFullPrettyVersion() && !$latestPackage->isAbandoned()) {
                     $exitCode = 1;
@@ -382,7 +381,7 @@ EOT
                 if ($showLatest && $showVersion) {
                     foreach ($packages[$type] as $package) {
                         if (is_object($package)) {
-                            $latestPackage = $this->findLatestPackage($package, $composer, $phpVersion, $showMinorOnly);
+                            $latestPackage = $this->findLatestPackage($package, $composer, $platformRepo, $showMinorOnly);
                             if ($latestPackage === false) {
                                 continue;
                             }
@@ -1182,16 +1181,16 @@ EOT
      *
      * @param PackageInterface   $package
      * @param Composer           $composer
-     * @param string           $phpVersion
+     * @param PlatformRepository $platformRepo
      * @param bool               $minorOnly
      *
      * @return PackageInterface|false
      */
-    private function findLatestPackage(PackageInterface $package, Composer $composer, $phpVersion, $minorOnly = false)
+    private function findLatestPackage(PackageInterface $package, Composer $composer, PlatformRepository $platformRepo, $minorOnly = false)
     {
         // find the latest version allowed in this repo set
         $name = $package->getName();
-        $versionSelector = new VersionSelector($this->getRepositorySet($composer));
+        $versionSelector = new VersionSelector($this->getRepositorySet($composer), $platformRepo);
         $stability = $composer->getPackage()->getMinimumStability();
         $flags = $composer->getPackage()->getStabilityFlags();
         if (isset($flags[$name])) {
@@ -1212,7 +1211,7 @@ EOT
             $targetVersion = '^' . $package->getVersion();
         }
 
-        return $versionSelector->findBestCandidate($name, $targetVersion, $phpVersion, $bestStability);
+        return $versionSelector->findBestCandidate($name, $targetVersion, $bestStability);
     }
 
     private function getRepositorySet(Composer $composer)

src/Composer/Package/Version/VersionSelector.php

@@ -20,6 +20,7 @@ use Composer\Composer;
 use Composer\Package\Loader\ArrayLoader;
 use Composer\Package\Dumper\ArrayDumper;
 use Composer\Repository\RepositorySet;
+use Composer\Repository\PlatformRepository;
 use Composer\Semver\Constraint\Constraint;
 
 /**
@@ -32,11 +33,22 @@ class VersionSelector
 {
     private $repositorySet;
 
+    private $platformConstraints;
+
     private $parser;
 
-    public function __construct(RepositorySet $repositorySet)
+    /**
+     * @param PlatformRepository $platformRepo If passed in, the versions found will be filtered against their requirements to eliminate any not matching the current platform packages
+     */
+    public function __construct(RepositorySet $repositorySet, PlatformRepository $platformRepo = null)
     {
         $this->repositorySet = $repositorySet;
+        if ($platformRepo) {
+            $this->platformConstraints = array();
+            foreach ($platformRepo->getPackages() as $package) {
+                $this->platformConstraints[$package->getName()][] = new Constraint('==', $package->getVersion());
+            }
+        }
     }
 
     /**
@@ -45,25 +57,38 @@ class VersionSelector
      *
      * @param  string                $packageName
      * @param  string                $targetPackageVersion
-     * @param  string                $targetPhpVersion
      * @param  string                $preferredStability
+     * @param  bool                  $ignorePlatformReqs
      * @return PackageInterface|false
      */
-    public function findBestCandidate($packageName, $targetPackageVersion = null, $targetPhpVersion = null, $preferredStability = 'stable')
+    public function findBestCandidate($packageName, $targetPackageVersion = null, $preferredStability = 'stable', $ignorePlatformReqs = false)
     {
+        if (!isset(BasePackage::$stabilities[$preferredStability])) {
+            // If you get this, maybe you are still relying on the Composer 1.x signature where the 3rd arg was the php version
+            throw new \UnexpectedValueException('Expected a valid stability name as 3rd argument, got '.$preferredStability);
+        }
+
         $constraint = $targetPackageVersion ? $this->getParser()->parseConstraints($targetPackageVersion) : null;
         $candidates = $this->repositorySet->findPackages(strtolower($packageName), $constraint);
 
-        if ($targetPhpVersion) {
+        if ($this->platformConstraints && !$ignorePlatformReqs) {
-            $phpConstraint = new Constraint('==', $this->getParser()->normalize($targetPhpVersion));
+            $platformConstraints = $this->platformConstraints;
-            $composerRuntimeConstraint = new Constraint('==', $this->getParser()->normalize(Composer::RUNTIME_API_VERSION));
+            $candidates = array_filter($candidates, function ($pkg) use ($platformConstraints) {
-            $composerPluginConstraint = new Constraint('==', $this->getParser()->normalize(PluginInterface::PLUGIN_API_VERSION));
-            $candidates = array_filter($candidates, function ($pkg) use ($phpConstraint, $composerPluginConstraint, $composerRuntimeConstraint) {
                 $reqs = $pkg->getRequires();
 
-                return (!isset($reqs['php']) || $reqs['php']->getConstraint()->matches($phpConstraint))
+                foreach ($reqs as $name => $link) {
-                    && (!isset($reqs['composer-plugin-api']) || $reqs['composer-plugin-api']->getConstraint()->matches($composerPluginConstraint))
+                    if (isset($platformConstraints[$name])) {
-                    && (!isset($reqs['composer-runtime-api']) || $reqs['composer-runtime-api']->getConstraint()->matches($composerRuntimeConstraint));
+                        foreach ($platformConstraints[$name] as $constraint) {
+                            if ($link->getConstraint()->matches($constraint)) {
+                                continue 2;
+                            }
+                        }
+
+                        return false;
+                    }
+                }
+
+                return true;
             });
         }
 

tests/Composer/Test/Package/Version/VersionSelectorTest.php

@@ -15,6 +15,7 @@ namespace Composer\Test\Package\Version;
 use Composer\Package\Version\VersionSelector;
 use Composer\Package\Package;
 use Composer\Package\Link;
+use Composer\Repository\PlatformRepository;
 use Composer\Semver\VersionParser;
 use Composer\Test\TestCase;
 
@@ -46,27 +47,82 @@ class VersionSelectorTest extends TestCase
         $this->assertSame($package2, $best, 'Latest version should be 1.2.2');
     }
 
-    public function testLatestVersionIsReturnedThatMatchesPhpRequirement()
+    public function testLatestVersionIsReturnedThatMatchesPhpRequirements()
     {
         $packageName = 'foobar';
 
+        $platform = new PlatformRepository(array(), array('php' => '5.5.0'));
+        $repositorySet = $this->createMockRepositorySet();
+        $versionSelector = new VersionSelector($repositorySet, $platform);
+
         $parser = new VersionParser;
         $package1 = $this->createPackage('1.0.0');
-        $package2 = $this->createPackage('2.0.0');
         $package1->setRequires(array('php' => new Link($packageName, 'php', $parser->parseConstraints('>=5.4'), 'requires', '>=5.4')));
+        $package2 = $this->createPackage('2.0.0');
         $package2->setRequires(array('php' => new Link($packageName, 'php', $parser->parseConstraints('>=5.6'), 'requires', '>=5.6')));
         $packages = array($package1, $package2);
 
-        $repositorySet = $this->createMockRepositorySet();
+        $repositorySet->expects($this->any())
-        $repositorySet->expects($this->once())
             ->method('findPackages')
             ->with($packageName, null)
             ->will($this->returnValue($packages));
 
-        $versionSelector = new VersionSelector($repositorySet);
+        $best = $versionSelector->findBestCandidate($packageName);
-        $best = $versionSelector->findBestCandidate($packageName, null, '5.5.0');
-
         $this->assertSame($package1, $best, 'Latest version supporting php 5.5 should be returned (1.0.0)');
+        $best = $versionSelector->findBestCandidate($packageName, null, 'stable', true);
+        $this->assertSame($package2, $best, 'Latest version should be returned when ignoring platform reqs (2.0.0)');
+    }
+
+    public function testLatestVersionIsReturnedThatMatchesExtRequirements()
+    {
+        $packageName = 'foobar';
+
+        $platform = new PlatformRepository(array(), array('ext-zip' => '5.3.0'));
+        $repositorySet = $this->createMockRepositorySet();
+        $versionSelector = new VersionSelector($repositorySet, $platform);
+
+        $parser = new VersionParser;
+        $package1 = $this->createPackage('1.0.0');
+        $package1->setRequires(array('ext-zip' => new Link($packageName, 'ext-zip', $parser->parseConstraints('^5.2'), 'requires', '^5.2')));
+        $package2 = $this->createPackage('2.0.0');
+        $package2->setRequires(array('ext-zip' => new Link($packageName, 'ext-zip', $parser->parseConstraints('^5.4'), 'requires', '^5.4')));
+        $packages = array($package1, $package2);
+
+        $repositorySet->expects($this->any())
+            ->method('findPackages')
+            ->with($packageName, null)
+            ->will($this->returnValue($packages));
+
+        $best = $versionSelector->findBestCandidate($packageName);
+        $this->assertSame($package1, $best, 'Latest version supporting ext-zip 5.3.0 should be returned (1.0.0)');
+        $best = $versionSelector->findBestCandidate($packageName, null, 'stable', true);
+        $this->assertSame($package2, $best, 'Latest version should be returned when ignoring platform reqs (2.0.0)');
+    }
+
+    public function testLatestVersionIsReturnedThatMatchesComposerRequirements()
+    {
+        $packageName = 'foobar';
+
+        $platform = new PlatformRepository(array(), array('composer-runtime-api' => '1.0.0'));
+        $repositorySet = $this->createMockRepositorySet();
+        $versionSelector = new VersionSelector($repositorySet, $platform);
+
+        $parser = new VersionParser;
+        $package1 = $this->createPackage('1.0.0');
+        $package1->setRequires(array('composer-runtime-api' => new Link($packageName, 'composer-runtime-api', $parser->parseConstraints('^1.0'), 'requires', '^1.0')));
+        $package2 = $this->createPackage('1.1.0');
+        $package2->setRequires(array('composer-runtime-api' => new Link($packageName, 'composer-runtime-api', $parser->parseConstraints('^2.0'), 'requires', '^2.0')));
+        $packages = array($package1, $package2);
+
+        $repositorySet->expects($this->any())
+            ->method('findPackages')
+            ->with($packageName, null)
+            ->will($this->returnValue($packages));
+
+        $best = $versionSelector->findBestCandidate($packageName);
+        $this->assertSame($package1, $best, 'Latest version supporting composer 1 should be returned (1.0.0)');
+        $best = $versionSelector->findBestCandidate($packageName, null, 'stable', true);
+        $this->assertSame($package2, $best, 'Latest version should be returned when ignoring platform reqs (1.1.0)');
     }
 
     public function testMostStableVersionIsReturned()
@@ -109,10 +165,10 @@ class VersionSelectorTest extends TestCase
             ->will($this->returnValue(array_reverse($packages)));
 
         $versionSelector = new VersionSelector($repositorySet);
-        $best = $versionSelector->findBestCandidate($packageName, null, null);
+        $best = $versionSelector->findBestCandidate($packageName);
         $this->assertSame($package2, $best, 'Expecting 2.0.0-beta3, cause beta is more stable than dev');
 
-        $best = $versionSelector->findBestCandidate($packageName, null, null);
+        $best = $versionSelector->findBestCandidate($packageName);
         $this->assertSame($package2, $best, 'Expecting 2.0.0-beta3, cause beta is more stable than dev');
     }
 
@@ -131,7 +187,7 @@ class VersionSelectorTest extends TestCase
             ->will($this->returnValue($packages));
 
         $versionSelector = new VersionSelector($repositorySet);
-        $best = $versionSelector->findBestCandidate($packageName, null, null, 'dev');
+        $best = $versionSelector->findBestCandidate($packageName, null, 'dev');
 
         $this->assertSame($package2, $best, 'Latest version should be returned (1.1.0-beta)');
     }
@@ -152,7 +208,7 @@ class VersionSelectorTest extends TestCase
             ->will($this->returnValue($packages));
 
         $versionSelector = new VersionSelector($repositorySet);
-        $best = $versionSelector->findBestCandidate($packageName, null, null, 'beta');
+        $best = $versionSelector->findBestCandidate($packageName, null, 'beta');
 
         $this->assertSame($package2, $best, 'Latest version should be returned (1.1.0-beta)');
     }
@@ -172,7 +228,7 @@ class VersionSelectorTest extends TestCase
             ->will($this->returnValue($packages));
 
         $versionSelector = new VersionSelector($repositorySet);
-        $best = $versionSelector->findBestCandidate($packageName, null, null, 'stable');
+        $best = $versionSelector->findBestCandidate($packageName, null, 'stable');
 
         $this->assertSame($package2, $best, 'Latest version should be returned (1.1.0-beta)');
     }