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