PHP RepositoryManager::getLocalRepository方法代码示例

 public function mapContrib(InstallationManager $im, RepositoryManager $rm)
 {
     $typePathMap = $this->getTypePathMap();
     $typeInstallMap = [];
     $packages = $rm->getLocalRepository()->getCanonicalPackages();
     foreach ($packages as $package) {
         if ($drupalType = $this->getDrupalType($package)) {
             if (!isset($typePathMap[$drupalType])) {
                 continue;
             }
             $installPath = self::changeSlashes($im->getInstaller($package->getType())->getInstallPath($package));
             if (strpos($installPath, $root = $this->getRoot()) !== false) {
                 $installPath = self::changeSlashes($this->getFS()->makePathRelative($installPath, $root));
             }
             $name = explode('/', $package->getPrettyName())[1];
             $mapRef =& $typeInstallMap[$drupalType][rtrim($installPath, DIRECTORY_SEPARATOR)];
             if (in_array($drupalType, ['module', 'theme'])) {
                 $mapRef = sprintf($typePathMap[$drupalType] . DIRECTORY_SEPARATOR . '%s', 'contrib', $name);
             } else {
                 $mapRef = sprintf($typePathMap[$drupalType], $name);
             }
         }
     }
     return array_intersect_key($typeInstallMap, $typePathMap);
 }

 /**
  * Run installation (or update)
  */
 public function run()
 {
     if ($this->dryRun) {
         $this->verbose = true;
         $this->runScripts = false;
         $this->installationManager->addInstaller(new NoopInstaller());
     }
     if ($this->preferSource) {
         $this->downloadManager->setPreferSource(true);
     }
     // create installed repo, this contains all local packages + platform packages (php & extensions)
     $installedRootPackage = clone $this->package;
     $installedRootPackage->setRequires(array());
     $installedRootPackage->setDevRequires(array());
     $repos = array_merge($this->repositoryManager->getLocalRepositories(), array(new InstalledArrayRepository(array($installedRootPackage)), new PlatformRepository()));
     $installedRepo = new CompositeRepository($repos);
     if ($this->additionalInstalledRepository) {
         $installedRepo->addRepository($this->additionalInstalledRepository);
     }
     $aliases = $this->aliasPackages();
     if ($this->runScripts) {
         // dispatch pre event
         $eventName = $this->update ? ScriptEvents::PRE_UPDATE_CMD : ScriptEvents::PRE_INSTALL_CMD;
         $this->eventDispatcher->dispatchCommandEvent($eventName);
     }
     $this->suggestedPackages = array();
     if (!$this->doInstall($this->repositoryManager->getLocalRepository(), $installedRepo, $aliases)) {
         return false;
     }
     if ($this->devMode) {
         if (!$this->doInstall($this->repositoryManager->getLocalDevRepository(), $installedRepo, $aliases, true)) {
             return false;
         }
     }
     // output suggestions
     foreach ($this->suggestedPackages as $suggestion) {
         if (!$installedRepo->findPackages($suggestion['target'])) {
             $this->io->write($suggestion['source'] . ' suggests installing ' . $suggestion['target'] . ' (' . $suggestion['reason'] . ')');
         }
     }
     if (!$this->dryRun) {
         // write lock
         if ($this->update || !$this->locker->isLocked()) {
             $updatedLock = $this->locker->setLockData($this->repositoryManager->getLocalRepository()->getPackages(), $this->devMode ? $this->repositoryManager->getLocalDevRepository()->getPackages() : null, $aliases, $this->package->getMinimumStability(), $this->package->getStabilityFlags());
             if ($updatedLock) {
                 $this->io->write('<info>Writing lock file</info>');
             }
         }
         // write autoloader
         $this->io->write('<info>Generating autoload files</info>');
         $localRepos = new CompositeRepository($this->repositoryManager->getLocalRepositories());
         $this->autoloadGenerator->dump($localRepos, $this->package, $this->installationManager, $this->installationManager->getVendorPath() . '/composer', true);
         if ($this->runScripts) {
             // dispatch post event
             $eventName = $this->update ? ScriptEvents::POST_UPDATE_CMD : ScriptEvents::POST_INSTALL_CMD;
             $this->eventDispatcher->dispatchCommandEvent($eventName);
         }
     }
     return true;
 }

 public function mapContrib(InstallationManager $im, RepositoryManager $rm)
 {
     $typePathMap = $this->getTypePathMap();
     $typeInstallMap = [];
     $packages = $rm->getLocalRepository()->getCanonicalPackages();
     foreach ($packages as $package) {
         if ($drupalType = $this->getDrupalType($package)) {
             $installPath = $im->getInstaller($package->getType())->getInstallPath($package);
             if (strpos($installPath, $root = $this->getRoot()) !== false) {
                 $installPath = $this->getFS()->makePathRelative($installPath, $root);
             }
             $name = explode('/', $package->getPrettyName())[1];
             $typeInstallMap[$drupalType][rtrim($installPath, '/')] = sprintf($typePathMap[$drupalType] . '/%s', 'contrib', $name);
         }
     }
     return array_intersect_key($typeInstallMap, $typePathMap);
 }

 /**
  * Replace local repositories with InstalledArrayRepository instances
  *
  * This is to prevent any accidental modification of the existing repos on disk
  *
  * @param RepositoryManager $rm
  */
 private function mockLocalRepositories(RepositoryManager $rm)
 {
     $packages = array_map(function ($p) {
         return clone $p;
     }, $rm->getLocalRepository()->getPackages());
     foreach ($packages as $key => $package) {
         if ($package instanceof AliasPackage) {
             unset($packages[$key]);
         }
     }
     $rm->setLocalRepository(new InstalledArrayRepository($packages));
     $packages = array_map(function ($p) {
         return clone $p;
     }, $rm->getLocalDevRepository()->getPackages());
     foreach ($packages as $key => $package) {
         if ($package instanceof AliasPackage) {
             unset($packages[$key]);
         }
     }
     $rm->setLocalDevRepository(new InstalledArrayRepository($packages));
 }

 /**
  * Replace local repositories with InstalledArrayRepository instances
  *
  * This is to prevent any accidental modification of the existing repos on disk
  *
  * @param RepositoryManager $rm
  */
 private function mockLocalRepositories(RepositoryManager $rm)
 {
     $packages = array();
     foreach ($rm->getLocalRepository()->getPackages() as $package) {
         $packages[(string) $package] = clone $package;
     }
     foreach ($packages as $key => $package) {
         if ($package instanceof AliasPackage) {
             $alias = (string) $package->getAliasOf();
             $packages[$key] = new AliasPackage($packages[$alias], $package->getVersion(), $package->getPrettyVersion());
         }
     }
     $rm->setLocalRepository(new InstalledArrayRepository($packages));
 }

 /**
  * @param Repository\RepositoryManager  $rm
  * @param Installer\InstallationManager $im
  */
 protected function purgePackages(Repository\RepositoryManager $rm, Installer\InstallationManager $im)
 {
     $repo = $rm->getLocalRepository();
     foreach ($repo->getPackages() as $package) {
         if (!$im->isPackageInstalled($repo, $package)) {
             $repo->removePackage($package);
         }
     }
 }

 protected function createInstallationManager(Repository\RepositoryManager $rm, Downloader\DownloadManager $dm, $vendorDir, $binDir, IOInterface $io)
 {
     $im = new Installer\InstallationManager($vendorDir);
     $im->addInstaller(new Installer\LibraryInstaller($vendorDir, $binDir, $dm, $rm->getLocalRepository(), $io, null));
     $im->addInstaller(new Installer\InstallerInstaller($vendorDir, $binDir, $dm, $rm->getLocalRepository(), $io, $im));
     return $im;
 }

 /**
  * Run installation (or update)
  *
  * @param Boolean $preferSource
  * @param Boolean $dryRun
  * @param Boolean $verbose
  * @param Boolean $noInstallRecommends
  * @param Boolean $installSuggests
  * @param Boolean $update
  * @param RepositoryInterface $additionalInstalledRepository
  */
 public function run($preferSource = false, $dryRun = false, $verbose = false, $noInstallRecommends = false, $installSuggests = false, $update = false, RepositoryInterface $additionalInstalledRepository = null)
 {
     if ($dryRun) {
         $verbose = true;
     }
     if ($preferSource) {
         $this->downloadManager->setPreferSource(true);
     }
     $this->repositoryManager = $this->repositoryManager;
     // create local repo, this contains all packages that are installed in the local project
     $localRepo = $this->repositoryManager->getLocalRepository();
     // create installed repo, this contains all local packages + platform packages (php & extensions)
     $installedRepo = new CompositeRepository(array($localRepo, new PlatformRepository()));
     if ($additionalInstalledRepository) {
         $installedRepo->addRepository($additionalInstalledRepository);
     }
     // prepare aliased packages
     if (!$update && $this->locker->isLocked()) {
         $aliases = $this->locker->getAliases();
     } else {
         $aliases = $this->package->getAliases();
     }
     foreach ($aliases as $alias) {
         foreach ($this->repositoryManager->findPackages($alias['package'], $alias['version']) as $package) {
             $package->getRepository()->addPackage(new AliasPackage($package, $alias['alias_normalized'], $alias['alias']));
         }
         foreach ($this->repositoryManager->getLocalRepository()->findPackages($alias['package'], $alias['version']) as $package) {
             $this->repositoryManager->getLocalRepository()->addPackage(new AliasPackage($package, $alias['alias_normalized'], $alias['alias']));
             $this->repositoryManager->getLocalRepository()->removePackage($package);
         }
     }
     // creating repository pool
     $pool = new Pool();
     $pool->addRepository($installedRepo);
     foreach ($this->repositoryManager->getRepositories() as $repository) {
         $pool->addRepository($repository);
     }
     // dispatch pre event
     if (!$dryRun) {
         $eventName = $update ? ScriptEvents::PRE_UPDATE_CMD : ScriptEvents::PRE_INSTALL_CMD;
         $this->eventDispatcher->dispatchCommandEvent($eventName);
     }
     // creating requirements request
     $installFromLock = false;
     $request = new Request($pool);
     if ($update) {
         $this->io->write('<info>Updating dependencies</info>');
         $request->updateAll();
         $links = $this->collectLinks($noInstallRecommends, $installSuggests);
         foreach ($links as $link) {
             $request->install($link->getTarget(), $link->getConstraint());
         }
     } elseif ($this->locker->isLocked()) {
         $installFromLock = true;
         $this->io->write('<info>Installing from lock file</info>');
         if (!$this->locker->isFresh()) {
             $this->io->write('<warning>Your lock file is out of sync with your composer.json, run "composer.phar update" to update dependencies</warning>');
         }
         foreach ($this->locker->getLockedPackages() as $package) {
             $version = $package->getVersion();
             foreach ($aliases as $alias) {
                 if ($alias['package'] === $package->getName() && $alias['version'] === $package->getVersion()) {
                     $version = $alias['alias'];
                     break;
                 }
             }
             $constraint = new VersionConstraint('=', $version);
             $request->install($package->getName(), $constraint);
         }
     } else {
         $this->io->write('<info>Installing dependencies</info>');
         $links = $this->collectLinks($noInstallRecommends, $installSuggests);
         foreach ($links as $link) {
             $request->install($link->getTarget(), $link->getConstraint());
         }
     }
     // prepare solver
     $policy = new DefaultPolicy();
     $solver = new Solver($policy, $pool, $installedRepo);
     // solve dependencies
     $operations = $solver->solve($request);
     // force dev packages to be updated to latest reference on update
     if ($update) {
         foreach ($localRepo->getPackages() as $package) {
             if ($package instanceof AliasPackage) {
                 $package = $package->getAliasOf();
             }
             // skip non-dev packages
             if (!$package->isDev()) {
//.........这里部分代码省略.........