composer · naderman · Feb 21, 2014 · Feb 21, 2014 · Feb 21, 2014 · Feb 21, 2014
diff --git a/src/Composer/DependencyResolver/DefaultPolicy.php b/src/Composer/DependencyResolver/DefaultPolicy.php
@@ -42,11 +42,11 @@ public function versionCompare(PackageInterface $a, PackageInterface $b, $operat
         return $constraint->matchSpecific($version, true);
     }
 
-    public function findUpdatePackages(Pool $pool, array $installedMap, PackageInterface $package)
+    public function findUpdatePackages(Pool $pool, array $installedMap, PackageInterface $package, $mustMatchName = false)
     {
         $packages = array();
 
-        foreach ($pool->whatProvides($package->getName()) as $candidate) {
+        foreach ($pool->whatProvides($package->getName(), null, $mustMatchName) as $candidate) {
             if ($candidate !== $package) {
                 $packages[] = $candidate;
             }

diff --git a/src/Composer/DependencyResolver/Pool.php b/src/Composer/DependencyResolver/Pool.php
@@ -50,6 +50,7 @@ class Pool
     protected $versionParser;
     protected $providerCache = array();
     protected $filterRequires;
+    protected $whitelist = null;
     protected $id = 1;
 
     public function __construct($minimumStability = 'stable', array $stabilityFlags = array(), array $filterRequires = array())
@@ -66,6 +67,11 @@ public function __construct($minimumStability = 'stable', array $stabilityFlags
         $this->filterRequires = $filterRequires;
     }
 
+    public function setWhitelist($whitelist)
+    {
+        $this->whitelist = $whitelist;
+    }
+
     /**
      * Adds a repository and its packages to this package pool
      *
@@ -223,21 +229,24 @@ public function packageById($id)
      * @param string                  $name       The package name to be searched for
      * @param LinkConstraintInterface $constraint A constraint that all returned
      *                                            packages must match or null to return all
+     * @param bool                    $mustMatchName Whether the name of returned packages
+     *                                            must match the given name
      * @return array A set of packages
      */
-    public function whatProvides($name, LinkConstraintInterface $constraint = null)
+    public function whatProvides($name, LinkConstraintInterface $constraint = null, $mustMatchName = false)
     {
-        if (isset($this->providerCache[$name][(string) $constraint])) {
-            return $this->providerCache[$name][(string) $constraint];
+        $key = ((string) (int) $mustMatchName).((string) $constraint);
+        if (isset($this->providerCache[$name][$key])) {
+            return $this->providerCache[$name][$key];
         }
 
-        return $this->providerCache[$name][(string) $constraint] = $this->computeWhatProvides($name, $constraint);
+        return $this->providerCache[$name][$key] = $this->computeWhatProvides($name, $constraint, $mustMatchName);
     }
 
     /**
      * @see whatProvides
      */
-    private function computeWhatProvides($name, $constraint)
+    private function computeWhatProvides($name, $constraint, $mustMatchName = false)
     {
         $candidates = array();
 
@@ -259,6 +268,9 @@ private function computeWhatProvides($name, $constraint)
         $nameMatch = false;
 
         foreach ($candidates as $candidate) {
+            if ($this->whitelist !== null && !isset($this->whitelist[$candidate->getId()])) {
+                continue;
+            }
             switch ($this->match($candidate, $name, $constraint)) {
                 case self::MATCH_NONE:
                     break;
@@ -288,6 +300,12 @@ private function computeWhatProvides($name, $constraint)
             }
         }
 
+        if ($mustMatchName) {
+            return array_filter($matches, function ($match) use ($name) {
+                return $match->getName() == $name;
+            });
+        }
+
         // if a package with the required name exists, we ignore providers
         if ($nameMatch) {
             return $matches;

diff --git a/src/Composer/DependencyResolver/Problem.php b/src/Composer/DependencyResolver/Problem.php
@@ -80,7 +80,13 @@ public function getPrettyString(array $installedMap = array())
             $rule = $reason['rule'];
             $job = $reason['job'];
 
-            if ($job && $job['cmd'] === 'install' && empty($job['packages'])) {
+            if (isset($job['constraint'])) {
+                $packages = $this->pool->whatProvides($job['packageName'], $job['constraint']);
+            } else {
+                $packages = array();
+            }
+
+            if ($job && $job['cmd'] === 'install' && empty($packages)) {
                 // handle php extensions
                 if (0 === stripos($job['packageName'], 'ext-')) {
                     $ext = substr($job['packageName'], 4);
@@ -161,18 +167,25 @@ protected function jobToText($job)
     {
         switch ($job['cmd']) {
             case 'install':
-                if (!$job['packages']) {
+                $packages = $this->pool->whatProvides($job['packageName'], $job['constraint']);
+                if (!$packages) {
                     return 'No package found to satisfy install request for '.$job['packageName'].$this->constraintToText($job['constraint']);
                 }
 
-                return 'Installation request for '.$job['packageName'].$this->constraintToText($job['constraint']).' -> satisfiable by '.$this->getPackageList($job['packages']).'.';
+                return 'Installation request for '.$job['packageName'].$this->constraintToText($job['constraint']).' -> satisfiable by '.$this->getPackageList($packages).'.';
             case 'update':
                 return 'Update request for '.$job['packageName'].$this->constraintToText($job['constraint']).'.';
             case 'remove':
                 return 'Removal request for '.$job['packageName'].$this->constraintToText($job['constraint']).'';
         }
 
-        return 'Job(cmd='.$job['cmd'].', target='.$job['packageName'].', packages=['.$this->getPackageList($job['packages']).'])';
+        if (isset($job['constraint'])) {
+            $packages = $this->pool->whatProvides($job['packageName'], $job['constraint']);
+        } else {
+            $packages = array();
+        }
+
+        return 'Job(cmd='.$job['cmd'].', target='.$job['packageName'].', packages=['.$this->getPackageList($packages).'])';
     }
 
     protected function getPackageList($packages)

diff --git a/src/Composer/DependencyResolver/Request.php b/src/Composer/DependencyResolver/Request.php
@@ -46,10 +46,8 @@ public function remove($packageName, LinkConstraintInterface $constraint = null)
     protected function addJob($packageName, $cmd, LinkConstraintInterface $constraint = null)
     {
         $packageName = strtolower($packageName);
-        $packages = $this->pool->whatProvides($packageName, $constraint);
 
         $this->jobs[] = array(
-            'packages' => $packages,
             'cmd' => $cmd,
             'packageName' => $packageName,
             'constraint' => $constraint,
@@ -58,7 +56,7 @@ protected function addJob($packageName, $cmd, LinkConstraintInterface $constrain
 
     public function updateAll()
     {
-        $this->jobs[] = array('cmd' => 'update-all', 'packages' => array());
+        $this->jobs[] = array('cmd' => 'update-all');
     }
 
     public function getJobs()

diff --git a/src/Composer/DependencyResolver/RuleSetGenerator.php b/src/Composer/DependencyResolver/RuleSetGenerator.php
@@ -25,6 +25,8 @@ class RuleSetGenerator
     protected $rules;
     protected $jobs;
     protected $installedMap;
+    protected $whitelistedMap;
+    protected $addedMap;
 
     public function __construct(PolicyInterface $policy, Pool $pool)
     {
@@ -141,6 +143,41 @@ private function addRule($type, Rule $newRule = null)
         $this->rules->add($newRule, $type);
     }
 
+    protected function whitelistFromPackage(PackageInterface $package)
+    {
+        $workQueue = new \SplQueue;
+        $workQueue->enqueue($package);
+
+        while (!$workQueue->isEmpty()) {
+            $package = $workQueue->dequeue();
+            if (isset($this->whitelistedMap[$package->getId()])) {
+                continue;
+            }
+
+            $this->whitelistedMap[$package->getId()] = true;
+
+            foreach ($package->getRequires() as $link) {
+                $possibleRequires = $this->pool->whatProvides($link->getTarget(), $link->getConstraint(), true);
+
                foreach ($possibleRequires as $require) {
+                    $workQueue->enqueue($require);
+                }
+            }
+
+            $obsoleteProviders = $this->pool->whatProvides($package->getName(), null, true);
+
+            foreach ($obsoleteProviders as $provider) {
+                if ($provider === $package) {
+                    continue;
+                }
+
+                if (($package instanceof AliasPackage) && $package->getAliasOf() === $provider) {
+                    $workQueue->enqueue($provider);
+                }
+            }
+        }
+    }
+
     protected function addRulesForPackage(PackageInterface $package)
     {
         $workQueue = new \SplQueue;
@@ -236,26 +273,51 @@ private function addRulesForUpdatePackages(PackageInterface $package)
         }
     }
 
+    private function whitelistFromUpdatePackages(PackageInterface $package)
+    {
+        $updates = $this->policy->findUpdatePackages($this->pool, $this->installedMap, $package, true);
+
+        foreach ($updates as $update) {
+            $this->whitelistFromPackage($update);
+        }
+    }
+
+    protected function whitelistFromJobs()
+    {
+        foreach ($this->jobs as $job) {
+            switch ($job['cmd']) {
+                case 'install':
+                    $packages = $this->pool->whatProvides($job['packageName'], $job['constraint'], true);
+                    foreach ($packages as $package) {
+                        $this->whitelistFromPackage($package);
+                    }
+                    break;
+            }
+        }
+    }
+
     protected function addRulesForJobs()
     {
         foreach ($this->jobs as $job) {
             switch ($job['cmd']) {
                 case 'install':
-                    if ($job['packages']) {
-                        foreach ($job['packages'] as $package) {
+                    $packages = $this->pool->whatProvides($job['packageName'], $job['constraint']);
+                    if ($packages) {
+                        foreach ($packages as $package) {
                             if (!isset($this->installedMap[$package->getId()])) {
                                 $this->addRulesForPackage($package);
                             }
                         }
 
-                        $rule = $this->createInstallOneOfRule($job['packages'], Rule::RULE_JOB_INSTALL, $job);
+                        $rule = $this->createInstallOneOfRule($packages, Rule::RULE_JOB_INSTALL, $job);
                         $this->addRule(RuleSet::TYPE_JOB, $rule);
                     }
                     break;
                 case 'remove':
                     // remove all packages with this name including uninstalled
                     // ones to make sure none of them are picked as replacements
-                    foreach ($job['packages'] as $package) {
+                    $packages = $this->pool->whatProvides($job['packageName'], $job['constraint']);
+                    foreach ($packages as $package) {
                         $rule = $this->createRemoveRule($package, Rule::RULE_JOB_REMOVE, $job);
                         $this->addRule(RuleSet::TYPE_JOB, $rule);
                     }
@@ -270,6 +332,16 @@ public function getRulesFor($jobs, $installedMap)
         $this->rules = new RuleSet;
         $this->installedMap = $installedMap;
 
+        $this->whitelistedNames = array();
+        foreach ($this->installedMap as $package) {
+            $this->whitelistFromPackage($package);
+            $this->whitelistFromUpdatePackages($package);
+        }
+        $this->whitelistFromJobs();
+
+        $this->pool->setWhitelist($this->whitelistedMap);
+
+        $this->addedMap = array();
         foreach ($this->installedMap as $package) {
             $this->addRulesForPackage($package);
             $this->addRulesForUpdatePackages($package);

diff --git a/src/Composer/DependencyResolver/Solver.php b/src/Composer/DependencyResolver/Solver.php
@@ -131,7 +131,8 @@ protected function setupInstalledMap()
         foreach ($this->jobs as $job) {
             switch ($job['cmd']) {
                 case 'update':
-                    foreach ($job['packages'] as $package) {
+                    $packages = $this->pool->whatProvides($job['packageName'], $job['constraint']);
+                    foreach ($packages as $package) {
                         if (isset($this->installedMap[$package->getId()])) {
                             $this->updateMap[$package->getId()] = true;
                         }
@@ -145,7 +146,7 @@ protected function setupInstalledMap()
                     break;
 
                 case 'install':
-                    if (!$job['packages']) {
+                    if (!$this->pool->whatProvides($job['packageName'], $job['constraint'])) {
                         $problem = new Problem($this->pool);
                         $problem->addRule(new Rule($this->pool, array(), null, null, $job));
                         $this->problems[] = $problem;

diff --git a/tests/Composer/Test/DependencyResolver/RequestTest.php b/tests/Composer/Test/DependencyResolver/RequestTest.php
@@ -39,9 +39,9 @@ public function testRequestInstallAndRemove()
 
         $this->assertEquals(
             array(
-                array('packages' => array($foo), 'cmd' => 'install', 'packageName' => 'foo', 'constraint' => null),
-                array('packages' => array($bar), 'cmd' => 'install', 'packageName' => 'bar', 'constraint' => null),
-                array('packages' => array($foobar), 'cmd' => 'remove', 'packageName' => 'foobar', 'constraint' => null),
+                array('cmd' => 'install', 'packageName' => 'foo', 'constraint' => null),
+                array('cmd' => 'install', 'packageName' => 'bar', 'constraint' => null),
+                array('cmd' => 'remove', 'packageName' => 'foobar', 'constraint' => null),
             ),
             $request->getJobs());
     }
@@ -66,7 +66,7 @@ public function testRequestInstallSamePackageFromDifferentRepositories()
 
         $this->assertEquals(
             array(
-                    array('packages' => array($foo1, $foo2), 'cmd' => 'install', 'packageName' => 'foo', 'constraint' => $constraint),
+                    array('cmd' => 'install', 'packageName' => 'foo', 'constraint' => $constraint),
             ),
             $request->getJobs()
         );
@@ -80,7 +80,7 @@ public function testUpdateAll()
         $request->updateA
10000
ll();
 
         $this->assertEquals(
-            array(array('cmd' => 'update-all', 'packages' => array())),
+            array(array('cmd' => 'update-all')),
             $request->getJobs());
     }
 }
diff --git a/tests/Composer/Test/DependencyResolver/SolverTest.php b/tests/Composer/Test/DependencyResolver/SolverTest.php
@@ -441,10 +441,9 @@ public function testInstallProvider()
 
         $this->request->install('A');
 
-        $this->checkSolverResult(array(
-            array('job' => 'install', 'package' => $packageQ),
-            array('job' => 'install', 'package' => $packageA),
-        ));
+        // must explicitly pick the provider, so error in this case
+        $this->setExpectedException('Composer\DependencyResolver\SolverProblemsException');
+        $this->solver->solve($this->request);
     }
 
     public function testSkipReplacerOfExistingPackage()
@@ -465,7 +464,7 @@ public function testSkipReplacerOfExistingPackage()
         ));
     }
 
-    public function testInstallReplacerOfMissingPackage()
+    public function testNoInstallReplacerOfMissingPackage()
     {
         $this->repo->addPackage($packageA = $this->getPackage('A', '1.0'));
         $this->repo->addPackage($packageQ = $this->getPackage('Q', '1.0'));
@@ -476,10 +475,8 @@ public function testInstallReplacerOfMissingPackage()
 
         $this->request->install('A');
 
-        $this->checkSolverResult(array(
-            array('job' => 'install', 'package' => $packageQ),
-            array('job' => 'install', 'package' => $packageA),
-        ));
+        $this->setExpectedException('Composer\DependencyResolver\SolverProblemsException');
+        $this->solver->solve($this->request);
     }
 
     public function testSkipReplacedPackageIfReplacerIsSelected()
@@ -574,11 +571,12 @@ public function testInstallAlternativeWithCircularRequire()
         $this->reposComplete();
 
         $this->request->install('A');
+        $this->request->install('C');
 
         $this->checkSolverResult(array(
-            array('job' => 'install', 'package' => $packageB),
             array('job' => 'install', 'package' => $packageA),
             array('job' => 'install', 'package' => $packageC),
+            array('job' => 'install', 'package' => $packageB),
         ));
     }
 
@@ -611,6 +609,7 @@ public function testUseReplacerIfNecessary()
         $this->reposComplete();
 
         $this->request->install('A');
+        $this->request->install('D');
 
         $this->checkSolverResult(array(
             array('job' => 'install', 'package' => $packageD2),