PHP Pool::whatProvides方法代码示例

 /**
  * Check if CakePHP version matches against a version
  *
  * @param string $matcher
  * @param string $version
  * @return bool
  */
 protected function matchesCakeVersion($matcher, $version)
 {
     if (class_exists('Composer\\Semver\\Constraint\\MultiConstraint')) {
         $multiClass = 'Composer\\Semver\\Constraint\\MultiConstraint';
         $constraintClass = 'Composer\\Semver\\Constraint\\Constraint';
     } else {
         $multiClass = 'Composer\\Package\\LinkConstraint\\MultiConstraint';
         $constraintClass = 'Composer\\Package\\LinkConstraint\\VersionConstraint';
     }
     $repositoryManager = $this->composer->getRepositoryManager();
     if ($repositoryManager) {
         $repos = $repositoryManager->getLocalRepository();
         if (!$repos) {
             return false;
         }
         $cake3 = new $multiClass(array(new $constraintClass($matcher, $version), new $constraintClass('!=', '9999999-dev')));
         $pool = new Pool('dev');
         $pool->addRepository($repos);
         $packages = $pool->whatProvides('cakephp/cakephp');
         foreach ($packages as $package) {
             $installed = new $constraintClass('=', $package->getVersion());
             if ($cake3->matches($installed)) {
                 return true;
                 break;
             }
         }
     }
     return false;
 }

 /**
  * @param bool $ignorePlatformReqs
  */
 protected function checkForRootRequireProblems($ignorePlatformReqs)
 {
     foreach ($this->jobs as $job) {
         switch ($job['cmd']) {
             case 'update':
                 $packages = $this->pool->whatProvides($job['packageName'], $job['constraint']);
                 foreach ($packages as $package) {
                     if (isset($this->installedMap[$package->id])) {
                         $this->updateMap[$package->id] = true;
                     }
                 }
                 break;
             case 'update-all':
                 foreach ($this->installedMap as $package) {
                     $this->updateMap[$package->id] = true;
                 }
                 break;
             case 'install':
                 if ($ignorePlatformReqs && preg_match(PlatformRepository::PLATFORM_PACKAGE_REGEX, $job['packageName'])) {
                     break;
                 }
                 if (!$this->pool->whatProvides($job['packageName'], $job['constraint'])) {
                     $problem = new Problem($this->pool);
                     $problem->addRule(new Rule(array(), null, null, $job));
                     $this->problems[] = $problem;
                 }
                 break;
         }
     }
 }

    public function testSelectLocalReposFirst()
    {
        $repoImportant = new ArrayRepository;

        $this->repo->addPackage($packageA = $this->getPackage('A', 'dev-master'));
        $this->repo->addPackage($packageAAlias = new AliasPackage($packageA, '2.1.9999999.9999999-dev', '2.1.x-dev'));
        $repoImportant->addPackage($packageAImportant = $this->getPackage('A', 'dev-feature-a'));
        $repoImportant->addPackage($packageAAliasImportant = new AliasPackage($packageAImportant, '2.1.9999999.9999999-dev', '2.1.x-dev'));
        $repoImportant->addPackage($packageA2Important = $this->getPackage('A', 'dev-master'));
        $repoImportant->addPackage($packageA2AliasImportant = new AliasPackage($packageA2Important, '2.1.9999999.9999999-dev', '2.1.x-dev'));
        $packageAAliasImportant->setRootPackageAlias(true);

        $this->pool->addRepository($this->repoInstalled);
        $this->pool->addRepository($repoImportant);
        $this->pool->addRepository($this->repo);

        $packages = $this->pool->whatProvides('a', new Constraint('=', '2.1.9999999.9999999-dev'));
        $literals = array();
        foreach ($packages as $package) {
            $literals[] = $package->getId();
        }

        $expected = array($packageAAliasImportant->getId());

        $selected = $this->policy->selectPreferredPackages($this->pool, array(), $literals);

        $this->assertSame($expected, $selected);
    }

 /**
  * Execute the command.
  *
  * @param  InputInterface  $input
  * @param  OutputInterface $output
  * @param  bool            $inverted Whether to invert matching process (why-not vs why behaviour)
  * @return int|null        Exit code of the operation.
  */
 protected function doExecute(InputInterface $input, OutputInterface $output, $inverted = false)
 {
     // Emit command event on startup
     $composer = $this->getComposer();
     $commandEvent = new CommandEvent(PluginEvents::COMMAND, $this->getName(), $input, $output);
     $composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent);
     // Prepare repositories and set up a pool
     $platformOverrides = $composer->getConfig()->get('platform') ?: array();
     $repository = new CompositeRepository(array(new ArrayRepository(array($composer->getPackage())), $composer->getRepositoryManager()->getLocalRepository(), new PlatformRepository(array(), $platformOverrides)));
     $pool = new Pool();
     $pool->addRepository($repository);
     // Parse package name and constraint
     list($needle, $textConstraint) = array_pad(explode(':', $input->getArgument(self::ARGUMENT_PACKAGE)), 2, $input->getArgument(self::ARGUMENT_CONSTRAINT));
     // Find packages that are or provide the requested package first
     $packages = $pool->whatProvides($needle);
     if (empty($packages)) {
         throw new \InvalidArgumentException(sprintf('Could not find package "%s" in your project', $needle));
     }
     // If the version we ask for is not installed then we need to locate it in remote repos and add it.
     // This is needed for why-not to resolve conflicts from an uninstalled version against installed packages.
     if (!$repository->findPackage($needle, $textConstraint)) {
         $defaultRepos = new CompositeRepository(RepositoryFactory::defaultRepos($this->getIO()));
         if ($match = $defaultRepos->findPackage($needle, $textConstraint)) {
             $repository->addRepository(new ArrayRepository(array(clone $match)));
         }
     }
     // Include replaced packages for inverted lookups as they are then the actual starting point to consider
     $needles = array($needle);
     if ($inverted) {
         foreach ($packages as $package) {
             $needles = array_merge($needles, array_map(function (Link $link) {
                 return $link->getTarget();
             }, $package->getReplaces()));
         }
     }
     // Parse constraint if one was supplied
     if ('*' !== $textConstraint) {
         $versionParser = new VersionParser();
         $constraint = $versionParser->parseConstraints($textConstraint);
     } else {
         $constraint = null;
     }
     // Parse rendering options
     $renderTree = $input->getOption(self::OPTION_TREE);
     $recursive = $renderTree || $input->getOption(self::OPTION_RECURSIVE);
     // Resolve dependencies
     $results = $repository->getDependents($needles, $constraint, $inverted, $recursive);
     if (empty($results)) {
         $extra = null !== $constraint ? sprintf(' in versions %smatching %s', $inverted ? 'not ' : '', $textConstraint) : '';
         $this->getIO()->writeError(sprintf('<info>There is no installed package depending on "%s"%s</info>', $needle, $extra));
     } elseif ($renderTree) {
         $this->initStyles($output);
         $root = $packages[0];
         $this->getIO()->write(sprintf('<info>%s</info> %s %s', $root->getPrettyName(), $root->getPrettyVersion(), $root->getDescription()));
         $this->printTree($results);
     } else {
         $this->printTable($output, $results);
     }
     return 0;
 }

 protected function selectPackage(IOInterface $io, $packageName, $version = null)
 {
     $io->write('<info>Searching for the specified package.</info>');
     if ($composer = $this->getComposer(false)) {
         $localRepo = $composer->getRepositoryManager()->getLocalRepository();
         $repos = new CompositeRepository(array_merge(array($localRepo), $composer->getRepositoryManager()->getRepositories()));
     } else {
         $defaultRepos = Factory::createDefaultRepositories($this->getIO());
         $io->write('No composer.json found in the current directory, searching packages from ' . implode(', ', array_keys($defaultRepos)));
         $repos = new CompositeRepository($defaultRepos);
     }
     $pool = new Pool();
     $pool->addRepository($repos);
     $constraint = $version ? new VersionConstraint('>=', $version) : null;
     $packages = $pool->whatProvides($packageName, $constraint);
     if (count($packages) > 1) {
         $package = $packages[0];
         $io->write('<info>Found multiple matches, selected ' . $package->getPrettyString() . '.</info>');
         $io->write('Alternatives were ' . implode(', ', array_map(function ($p) {
             return $p->getPrettyString();
         }, $packages)) . '.');
         $io->write('<comment>Please use a more specific constraint to pick a different package.</comment>');
     } elseif ($packages) {
         $package = $packages[0];
         $io->write('<info>Found an exact match ' . $package->getPrettyString() . '.</info>');
     } else {
         $io->write('<error>Could not find a package matching ' . $packageName . '.</error>');
         return false;
     }
     return $package;
 }

 /**
  * Test that the core bundles get correctly injected.
  *
  * @return void
  */
 public function testInjectCoreBundles()
 {
     $inOut = $this->getMock('Composer\\IO\\IOInterface');
     $factory = new Factory();
     $composer = $factory->createComposer($inOut, $this->config);
     $plugin = new Plugin();
     $local = $composer->getRepositoryManager()->getLocalRepository();
     if ($core = $local->findPackages('contao/core')) {
         $this->fail('Contao core has already been injected, found version ' . $core[0]->getVersion());
     }
     $plugin->activate($composer, $inOut);
     if (!($core = $local->findPackages('contao/core'))) {
         $this->fail('Contao core has not been injected.');
     }
     $core = $core[0];
     $constraint = new Constraint('=', $core->getVersion());
     $pool = new Pool('dev');
     $pool->addRepository($local);
     $this->assertNotNull($core = $pool->whatProvides('contao/core', $constraint));
     // bundle names + 'contao-community-alliance/composer-client'
     $this->assertCount(8, $core[0]->getRequires());
     foreach (array('contao/calendar-bundle', 'contao/comments-bundle', 'contao/core-bundle', 'contao/faq-bundle', 'contao/listing-bundle', 'contao/news-bundle', 'contao/newsletter-bundle') as $bundleName) {
         $this->assertNotNull($matches = $pool->whatProvides($bundleName, $constraint));
         $this->assertCount(1, $matches);
         $this->assertEquals('metapackage', $matches[0]->getType());
     }
 }

 public function findUpdatePackages(Pool $pool, array $installedMap, PackageInterface $package, $mustMatchName = false)
 {
     $packages = array();
     foreach ($pool->whatProvides($package->getName(), null, $mustMatchName) as $candidate) {
         if ($candidate !== $package) {
             $packages[] = $candidate;
         }
     }
     return $packages;
 }

 public function findUpdatePackages(Solver $solver, Pool $pool, array $installedMap, PackageInterface $package)
 {
     $packages = array();
     foreach ($pool->whatProvides($package->getName()) as $candidate) {
         if ($candidate !== $package) {
             $packages[] = $candidate;
         }
     }
     return $packages;
 }

 private function getPackageMatches($repository, $name, $version = null)
 {
     $pool = new Pool('dev');
     $pool->addRepository($repository);
     $constraint = null;
     if ($version) {
         $parser = new VersionParser();
         $constraint = $parser->parseConstraints($version);
     }
     return $pool->whatProvides($name, $constraint);
 }

 /**
  * finds a package by name
  *
  * @param  RepositoryInterface $repos
  * @param  string              $name
  * @return CompletePackageInterface
  */
 protected function getPackage(RepositoryInterface $repos, $name)
 {
     $name = strtolower($name);
     $pool = new Pool('dev');
     $pool->addRepository($repos);
     $matches = $pool->whatProvides($name);
     foreach ($matches as $index => $package) {
         // skip providers/replacers
         if ($package->getName() !== $name) {
             unset($matches[$index]);
             continue;
         }
         return $package;
     }
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $composer = $this->getComposer();
     $commandEvent = new CommandEvent(PluginEvents::COMMAND, 'depends', $input, $output);
     $composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent);
     $repo = new CompositeRepository(array(new ArrayRepository(array($composer->getPackage())), $composer->getRepositoryManager()->getLocalRepository()));
     $needle = $input->getArgument('package');
     $pool = new Pool();
     $pool->addRepository($repo);
     $packages = $pool->whatProvides($needle);
     if (empty($packages)) {
         throw new \InvalidArgumentException('Could not find package "' . $needle . '" in your project.');
     }
     $linkTypes = $this->linkTypes;
     $types = array_map(function ($type) use($linkTypes) {
         $type = rtrim($type, 's');
         if (!isset($linkTypes[$type])) {
             throw new \InvalidArgumentException('Unexpected link type: ' . $type . ', valid types: ' . implode(', ', array_keys($linkTypes)));
         }
         return $type;
     }, $input->getOption('link-type'));
     $messages = array();
     $outputPackages = array();
     $io = $this->getIO();
     /** @var PackageInterface $package */
     foreach ($repo->getPackages() as $package) {
         foreach ($types as $type) {
             /** @var Link $link */
             foreach ($package->{'get' . $linkTypes[$type][0]}() as $link) {
                 if ($link->getTarget() === $needle) {
                     if (!isset($outputPackages[$package->getName()])) {
                         $messages[] = '<info>' . $package->getPrettyName() . '</info> ' . $linkTypes[$type][1] . ' ' . $needle . ' (<info>' . $link->getPrettyConstraint() . '</info>)';
                         $outputPackages[$package->getName()] = true;
                     }
                 }
             }
         }
     }
     if ($messages) {
         sort($messages);
         $io->write($messages);
     } else {
         $io->writeError('<info>There is no installed package depending on "' . $needle . '".</info>');
     }
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $repos = $this->getComposer()->getRepositoryManager()->getLocalRepositories();
     $needle = $input->getArgument('package');
     $pool = new Pool();
     foreach ($repos as $repo) {
         $pool->addRepository($repo);
     }
     $packages = $pool->whatProvides($needle);
     if (empty($packages)) {
         throw new \InvalidArgumentException('Could not find package "' . $needle . '" in your project.');
     }
     $linkTypes = $this->linkTypes;
     $verbose = (bool) $input->getOption('verbose');
     $types = array_map(function ($type) use($linkTypes) {
         $type = rtrim($type, 's');
         if (!isset($linkTypes[$type])) {
             throw new \InvalidArgumentException('Unexpected link type: ' . $type . ', valid types: ' . implode(', ', array_keys($linkTypes)));
         }
         return $type;
     }, $input->getOption('link-type'));
     $dependsOnPackages = false;
     foreach ($repos as $repo) {
         $repo->filterPackages(function ($package) use($needle, $types, $linkTypes, $output, $verbose, &$dependsOnPackages) {
             static $outputPackages = array();
             foreach ($types as $type) {
                 foreach ($package->{'get' . $linkTypes[$type]}() as $link) {
                     if ($link->getTarget() === $needle) {
                         $dependsOnPackages = true;
                         if ($verbose) {
                             $output->writeln($package->getPrettyName() . ' ' . $package->getPrettyVersion() . ' <info>' . $type . '</info> ' . $link->getPrettyConstraint());
                         } elseif (!isset($outputPackages[$package->getName()])) {
                             $output->writeln($package->getPrettyName());
                             $outputPackages[$package->getName()] = true;
                         }
                     }
                 }
             }
         });
     }
     if (!$dependsOnPackages) {
         $output->writeln('<info>There is no installed package depending on "' . $needle . '".</info>');
     }
 }

 /**
  * Check if CakePHP version matches against a version
  *
  * @param string $matcher
  * @param string $version
  * @return bool
  */
 protected function matchesCakeVersion($matcher, $version)
 {
     $repositoryManager = $this->composer->getRepositoryManager();
     if ($repositoryManager) {
         $repos = $repositoryManager->getLocalRepository();
         if (!$repos) {
             return false;
         }
         $cake3 = new MultiConstraint(array(new VersionConstraint($matcher, $version), new VersionConstraint('!=', '9999999-dev')));
         $pool = new Pool('dev');
         $pool->addRepository($repos);
         $packages = $pool->whatProvides('cakephp/cakephp');
         foreach ($packages as $package) {
             $installed = new VersionConstraint('=', $package->getVersion());
             if ($cake3->matches($installed)) {
                 return true;
                 break;
             }
         }
     }
     return false;
 }

 /**
  * Change the default plugin location when cakephp >= 3.0
  */
 public function getLocations()
 {
     $repositoryManager = $this->composer->getRepositoryManager();
     if ($repositoryManager) {
         $repos = $repositoryManager->getLocalRepository();
         if (!$repos) {
             return $this->locations;
         }
         $cake3 = new MultiConstraint(array(new VersionConstraint('>=', '3.0.0'), new VersionConstraint('!=', '9999999-dev')));
         $pool = new Pool('dev');
         $pool->addRepository($repos);
         $packages = $pool->whatProvides('cakephp/cakephp');
         foreach ($packages as $package) {
             $installed = new VersionConstraint('=', $package->getVersion());
             if ($cake3->matches($installed)) {
                 $this->locations['plugin'] = 'plugins/{$name}/';
                 break;
             }
         }
     }
     return $this->locations;
 }

 public function package($info)
 {
     preg_match('{^(?<name>.*)\\$(?<hash>.*)\\.json$}i', $info, $matches);
     $hash = $matches['hash'];
     $name = $matches['name'];
     $filename = 'p/hash/' . substr($hash, 0, 2) . '/' . substr($hash, 2, 2) . '/' . hash('sha256', $hash . $name) . '.json';
     if (!Storage::has($filename)) {
         $repos = $this->getRepos();
         $installedRepo = new CompositeRepository($repos);
         $pool = new Pool('dev');
         $pool->addRepository($installedRepo);
         $matches = $pool->whatProvides($name, null);
         if (!$matches) {
             return '{}';
         } else {
             $match = $matches[0];
             $repo = $match->getRepository();
             $ref = new \ReflectionProperty($repo, 'providersUrl');
             $ref->setAccessible(true);
             $providersUrl = $ref->getValue($repo);
             $ref = new \ReflectionProperty($repo, 'cache');
             $ref->setAccessible(true);
             $cache = $ref->getValue($repo);
             $url = str_replace(array('%package%', '%hash%'), array($name, $hash), $providersUrl);
             $cacheKey = 'provider-' . strtr($name, '/', '$') . '.json';
             if ($cache->sha256($cacheKey) === $hash) {
                 $packages = $cache->read($cacheKey);
             }
             if (!isset($packages) && empty($packages)) {
                 throw new Exception("Cache should exists, please report this issue on github", 1);
             }
             Storage::put($filename, $packages);
         }
     }
     return Storage::get($filename);
 }