[ Index ]

PHP Cross Reference of DokuWiki

title

Body

[close]

/vendor/composer/ -> InstalledVersions.php (source)

   1  <?php
   2  
   3  /*
   4   * This file is part of Composer.
   5   *
   6   * (c) Nils Adermann <naderman@naderman.de>
   7   *     Jordi Boggiano <j.boggiano@seld.be>
   8   *
   9   * For the full copyright and license information, please view the LICENSE
  10   * file that was distributed with this source code.
  11   */
  12  
  13  namespace Composer;
  14  
  15  use Composer\Autoload\ClassLoader;
  16  use Composer\Semver\VersionParser;
  17  
  18  /**
  19   * This class is copied in every Composer installed project and available to all
  20   *
  21   * See also https://getcomposer.org/doc/07-runtime.md#installed-versions
  22   *
  23   * To require its presence, you can require `composer-runtime-api ^2.0`
  24   *
  25   * @final
  26   */
  27  class InstalledVersions
  28  {
  29      /**
  30       * @var mixed[]|null
  31       * @psalm-var array{root: array{name: string, version: string, reference: string, pretty_version: string, aliases: string[], dev: bool, install_path: string, type: string}, versions: array<string, array{dev_requirement: bool, pretty_version?: string, version?: string, aliases?: string[], reference?: string, replaced?: string[], provided?: string[], install_path?: string, type?: string}>}|array{}|null
  32       */
  33      private static $installed;
  34  
  35      /**
  36       * @var bool|null
  37       */
  38      private static $canGetVendors;
  39  
  40      /**
  41       * @var array[]
  42       * @psalm-var array<string, array{root: array{name: string, version: string, reference: string, pretty_version: string, aliases: string[], dev: bool, install_path: string, type: string}, versions: array<string, array{dev_requirement: bool, pretty_version?: string, version?: string, aliases?: string[], reference?: string, replaced?: string[], provided?: string[], install_path?: string, type?: string}>}>
  43       */
  44      private static $installedByVendor = array();
  45  
  46      /**
  47       * Returns a list of all package names which are present, either by being installed, replaced or provided
  48       *
  49       * @return string[]
  50       * @psalm-return list<string>
  51       */
  52      public static function getInstalledPackages()
  53      {
  54          $packages = array();
  55          foreach (self::getInstalled() as $installed) {
  56              $packages[] = array_keys($installed['versions']);
  57          }
  58  
  59          if (1 === \count($packages)) {
  60              return $packages[0];
  61          }
  62  
  63          return array_keys(array_flip(\call_user_func_array('array_merge', $packages)));
  64      }
  65  
  66      /**
  67       * Returns a list of all package names with a specific type e.g. 'library'
  68       *
  69       * @param  string   $type
  70       * @return string[]
  71       * @psalm-return list<string>
  72       */
  73      public static function getInstalledPackagesByType($type)
  74      {
  75          $packagesByType = array();
  76  
  77          foreach (self::getInstalled() as $installed) {
  78              foreach ($installed['versions'] as $name => $package) {
  79                  if (isset($package['type']) && $package['type'] === $type) {
  80                      $packagesByType[] = $name;
  81                  }
  82              }
  83          }
  84  
  85          return $packagesByType;
  86      }
  87  
  88      /**
  89       * Checks whether the given package is installed
  90       *
  91       * This also returns true if the package name is provided or replaced by another package
  92       *
  93       * @param  string $packageName
  94       * @param  bool   $includeDevRequirements
  95       * @return bool
  96       */
  97      public static function isInstalled($packageName, $includeDevRequirements = true)
  98      {
  99          foreach (self::getInstalled() as $installed) {
 100              if (isset($installed['versions'][$packageName])) {
 101                  return $includeDevRequirements || empty($installed['versions'][$packageName]['dev_requirement']);
 102              }
 103          }
 104  
 105          return false;
 106      }
 107  
 108      /**
 109       * Checks whether the given package satisfies a version constraint
 110       *
 111       * e.g. If you want to know whether version 2.3+ of package foo/bar is installed, you would call:
 112       *
 113       *   Composer\InstalledVersions::satisfies(new VersionParser, 'foo/bar', '^2.3')
 114       *
 115       * @param  VersionParser $parser      Install composer/semver to have access to this class and functionality
 116       * @param  string        $packageName
 117       * @param  string|null   $constraint  A version constraint to check for, if you pass one you have to make sure composer/semver is required by your package
 118       * @return bool
 119       */
 120      public static function satisfies(VersionParser $parser, $packageName, $constraint)
 121      {
 122          $constraint = $parser->parseConstraints($constraint);
 123          $provided = $parser->parseConstraints(self::getVersionRanges($packageName));
 124  
 125          return $provided->matches($constraint);
 126      }
 127  
 128      /**
 129       * Returns a version constraint representing all the range(s) which are installed for a given package
 130       *
 131       * It is easier to use this via isInstalled() with the $constraint argument if you need to check
 132       * whether a given version of a package is installed, and not just whether it exists
 133       *
 134       * @param  string $packageName
 135       * @return string Version constraint usable with composer/semver
 136       */
 137      public static function getVersionRanges($packageName)
 138      {
 139          foreach (self::getInstalled() as $installed) {
 140              if (!isset($installed['versions'][$packageName])) {
 141                  continue;
 142              }
 143  
 144              $ranges = array();
 145              if (isset($installed['versions'][$packageName]['pretty_version'])) {
 146                  $ranges[] = $installed['versions'][$packageName]['pretty_version'];
 147              }
 148              if (array_key_exists('aliases', $installed['versions'][$packageName])) {
 149                  $ranges = array_merge($ranges, $installed['versions'][$packageName]['aliases']);
 150              }
 151              if (array_key_exists('replaced', $installed['versions'][$packageName])) {
 152                  $ranges = array_merge($ranges, $installed['versions'][$packageName]['replaced']);
 153              }
 154              if (array_key_exists('provided', $installed['versions'][$packageName])) {
 155                  $ranges = array_merge($ranges, $installed['versions'][$packageName]['provided']);
 156              }
 157  
 158              return implode(' || ', $ranges);
 159          }
 160  
 161          throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
 162      }
 163  
 164      /**
 165       * @param  string      $packageName
 166       * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as version, use satisfies or getVersionRanges if you need to know if a given version is present
 167       */
 168      public static function getVersion($packageName)
 169      {
 170          foreach (self::getInstalled() as $installed) {
 171              if (!isset($installed['versions'][$packageName])) {
 172                  continue;
 173              }
 174  
 175              if (!isset($installed['versions'][$packageName]['version'])) {
 176                  return null;
 177              }
 178  
 179              return $installed['versions'][$packageName]['version'];
 180          }
 181  
 182          throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
 183      }
 184  
 185      /**
 186       * @param  string      $packageName
 187       * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as version, use satisfies or getVersionRanges if you need to know if a given version is present
 188       */
 189      public static function getPrettyVersion($packageName)
 190      {
 191          foreach (self::getInstalled() as $installed) {
 192              if (!isset($installed['versions'][$packageName])) {
 193                  continue;
 194              }
 195  
 196              if (!isset($installed['versions'][$packageName]['pretty_version'])) {
 197                  return null;
 198              }
 199  
 200              return $installed['versions'][$packageName]['pretty_version'];
 201          }
 202  
 203          throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
 204      }
 205  
 206      /**
 207       * @param  string      $packageName
 208       * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as reference
 209       */
 210      public static function getReference($packageName)
 211      {
 212          foreach (self::getInstalled() as $installed) {
 213              if (!isset($installed['versions'][$packageName])) {
 214                  continue;
 215              }
 216  
 217              if (!isset($installed['versions'][$packageName]['reference'])) {
 218                  return null;
 219              }
 220  
 221              return $installed['versions'][$packageName]['reference'];
 222          }
 223  
 224          throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
 225      }
 226  
 227      /**
 228       * @param  string      $packageName
 229       * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as install path. Packages of type metapackages also have a null install path.
 230       */
 231      public static function getInstallPath($packageName)
 232      {
 233          foreach (self::getInstalled() as $installed) {
 234              if (!isset($installed['versions'][$packageName])) {
 235                  continue;
 236              }
 237  
 238              return isset($installed['versions'][$packageName]['install_path']) ? $installed['versions'][$packageName]['install_path'] : null;
 239          }
 240  
 241          throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
 242      }
 243  
 244      /**
 245       * @return array
 246       * @psalm-return array{name: string, version: string, reference: string, pretty_version: string, aliases: string[], dev: bool, install_path: string, type: string}
 247       */
 248      public static function getRootPackage()
 249      {
 250          $installed = self::getInstalled();
 251  
 252          return $installed[0]['root'];
 253      }
 254  
 255      /**
 256       * Returns the raw installed.php data for custom implementations
 257       *
 258       * @deprecated Use getAllRawData() instead which returns all datasets for all autoloaders present in the process. getRawData only returns the first dataset loaded, which may not be what you expect.
 259       * @return array[]
 260       * @psalm-return array{root: array{name: string, version: string, reference: string, pretty_version: string, aliases: string[], dev: bool, install_path: string, type: string}, versions: array<string, array{dev_requirement: bool, pretty_version?: string, version?: string, aliases?: string[], reference?: string, replaced?: string[], provided?: string[], install_path?: string, type?: string}>}
 261       */
 262      public static function getRawData()
 263      {
 264          @trigger_error('getRawData only returns the first dataset loaded, which may not be what you expect. Use getAllRawData() instead which returns all datasets for all autoloaders present in the process.', E_USER_DEPRECATED);
 265  
 266          if (null === self::$installed) {
 267              // only require the installed.php file if this file is loaded from its dumped location,
 268              // and not from its source location in the composer/composer package, see https://github.com/composer/composer/issues/9937
 269              if (substr(__DIR__, -8, 1) !== 'C') {
 270                  self::$installed = include  __DIR__ . '/installed.php';
 271              } else {
 272                  self::$installed = array();
 273              }
 274          }
 275  
 276          return self::$installed;
 277      }
 278  
 279      /**
 280       * Returns the raw data of all installed.php which are currently loaded for custom implementations
 281       *
 282       * @return array[]
 283       * @psalm-return list<array{root: array{name: string, version: string, reference: string, pretty_version: string, aliases: string[], dev: bool, install_path: string, type: string}, versions: array<string, array{dev_requirement: bool, pretty_version?: string, version?: string, aliases?: string[], reference?: string, replaced?: string[], provided?: string[], install_path?: string, type?: string}>}>
 284       */
 285      public static function getAllRawData()
 286      {
 287          return self::getInstalled();
 288      }
 289  
 290      /**
 291       * Lets you reload the static array from another file
 292       *
 293       * This is only useful for complex integrations in which a project needs to use
 294       * this class but then also needs to execute another project's autoloader in process,
 295       * and wants to ensure both projects have access to their version of installed.php.
 296       *
 297       * A typical case would be PHPUnit, where it would need to make sure it reads all
 298       * the data it needs from this class, then call reload() with
 299       * `require $CWD/vendor/composer/installed.php` (or similar) as input to make sure
 300       * the project in which it runs can then also use this class safely, without
 301       * interference between PHPUnit's dependencies and the project's dependencies.
 302       *
 303       * @param  array[] $data A vendor/composer/installed.php data set
 304       * @return void
 305       *
 306       * @psalm-param array{root: array{name: string, version: string, reference: string, pretty_version: string, aliases: string[], dev: bool, install_path: string, type: string}, versions: array<string, array{dev_requirement: bool, pretty_version?: string, version?: string, aliases?: string[], reference?: string, replaced?: string[], provided?: string[], install_path?: string, type?: string}>} $data
 307       */
 308      public static function reload($data)
 309      {
 310          self::$installed = $data;
 311          self::$installedByVendor = array();
 312      }
 313  
 314      /**
 315       * @return array[]
 316       * @psalm-return list<array{root: array{name: string, version: string, reference: string, pretty_version: string, aliases: string[], dev: bool, install_path: string, type: string}, versions: array<string, array{dev_requirement: bool, pretty_version?: string, version?: string, aliases?: string[], reference?: string, replaced?: string[], provided?: string[], install_path?: string, type?: string}>}>
 317       */
 318      private static function getInstalled()
 319      {
 320          if (null === self::$canGetVendors) {
 321              self::$canGetVendors = method_exists('Composer\Autoload\ClassLoader', 'getRegisteredLoaders');
 322          }
 323  
 324          $installed = array();
 325  
 326          if (self::$canGetVendors) {
 327              foreach (ClassLoader::getRegisteredLoaders() as $vendorDir => $loader) {
 328                  if (isset(self::$installedByVendor[$vendorDir])) {
 329                      $installed[] = self::$installedByVendor[$vendorDir];
 330                  } elseif (is_file($vendorDir.'/composer/installed.php')) {
 331                      $installed[] = self::$installedByVendor[$vendorDir] = require $vendorDir.'/composer/installed.php';
 332                      if (null === self::$installed && strtr($vendorDir.'/composer', '\\', '/') === strtr(__DIR__, '\\', '/')) {
 333                          self::$installed = $installed[count($installed) - 1];
 334                      }
 335                  }
 336              }
 337          }
 338  
 339          if (null === self::$installed) {
 340              // only require the installed.php file if this file is loaded from its dumped location,
 341              // and not from its source location in the composer/composer package, see https://github.com/composer/composer/issues/9937
 342              if (substr(__DIR__, -8, 1) !== 'C') {
 343                  self::$installed = require  __DIR__ . '/installed.php';
 344              } else {
 345                  self::$installed = array();
 346              }
 347          }
 348          $installed[] = self::$installed;
 349  
 350          return $installed;
 351      }
 352  }