Total Complexity | 184 |
Total Lines | 1506 |
Duplicated Lines | 0 % |
Changes | 0 |
Complex classes like Configuration often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use Configuration, and based on these observations, apply Extract Interface, too.
1 | <?php |
||
62 | final class Configuration |
||
63 | { |
||
64 | private const DEFAULT_ALIAS = 'test.phar'; |
||
65 | private const DEFAULT_MAIN_SCRIPT = 'index.php'; |
||
66 | private const DEFAULT_DATETIME_FORMAT = 'Y-m-d H:i:s'; |
||
67 | private const DEFAULT_REPLACEMENT_SIGIL = '@'; |
||
68 | private const DEFAULT_SHEBANG = '#!/usr/bin/env php'; |
||
69 | private const DEFAULT_BANNER = <<<'BANNER' |
||
70 | Generated by Humbug Box. |
||
71 | |||
72 | @link https://github.com/humbug/box |
||
73 | BANNER; |
||
74 | private const FILES_SETTINGS = [ |
||
75 | 'files', |
||
76 | 'files-bin', |
||
77 | 'directories', |
||
78 | 'directories-bin', |
||
79 | 'finder', |
||
80 | 'finder-bin', |
||
81 | ]; |
||
82 | private const PHP_SCOPER_CONFIG = 'scoper.inc.php'; |
||
83 | |||
84 | private $file; |
||
85 | private $fileMode; |
||
86 | private $alias; |
||
87 | private $basePath; |
||
88 | private $composerJson; |
||
89 | private $composerLock; |
||
90 | private $files; |
||
91 | private $binaryFiles; |
||
92 | private $compactors; |
||
93 | private $compressionAlgorithm; |
||
94 | private $mainScriptPath; |
||
95 | private $mainScriptContents; |
||
96 | private $map; |
||
97 | private $fileMapper; |
||
98 | private $metadata; |
||
99 | private $tmpOutputPath; |
||
100 | private $outputPath; |
||
101 | private $privateKeyPassphrase; |
||
102 | private $privateKeyPath; |
||
103 | private $isPrivateKeyPrompt; |
||
104 | private $processedReplacements; |
||
105 | private $shebang; |
||
106 | private $signingAlgorithm; |
||
107 | private $stubBannerContents; |
||
108 | private $stubBannerPath; |
||
109 | private $stubPath; |
||
110 | private $isInterceptFileFuncs; |
||
111 | private $isStubGenerated; |
||
112 | private $checkRequirements; |
||
113 | |||
114 | /** |
||
115 | * @param null|string $file |
||
116 | * @param null|string $alias |
||
117 | * @param string $basePath Utility to private the base path used and be able to retrieve a path relative to it (the base path) |
||
118 | * @param null[]|string[] $composerJson |
||
119 | * @param null[]|string[] $composerLock |
||
120 | * @param SplFileInfo[] $files List of files |
||
121 | * @param SplFileInfo[] $binaryFiles List of binary files |
||
122 | * @param Compactor[] $compactors List of file contents compactors |
||
123 | * @param null|int $compressionAlgorithm Compression algorithm constant value. See the \Phar class constants |
||
124 | * @param null|int $fileMode File mode in octal form |
||
125 | * @param string $mainScriptPath The main script file path |
||
126 | * @param string $mainScriptContents The processed content of the main script file |
||
127 | * @param MapFile $fileMapper Utility to map the files from outside and inside the PHAR |
||
128 | * @param mixed $metadata The PHAR Metadata |
||
129 | * @param string $tmpOutputPath |
||
130 | * @param string $outputPath |
||
131 | * @param null|string $privateKeyPassphrase |
||
132 | * @param null|string $privateKeyPath |
||
133 | * @param bool $isPrivateKeyPrompt If the user should be prompted for the private key passphrase |
||
134 | * @param array $processedReplacements The processed list of replacement placeholders and their values |
||
135 | * @param null|string $shebang The shebang line |
||
136 | * @param int $signingAlgorithm The PHAR siging algorithm. See \Phar constants |
||
137 | * @param null|string $stubBannerContents The stub banner comment |
||
138 | * @param null|string $stubBannerPath The path to the stub banner comment file |
||
139 | * @param null|string $stubPath The PHAR stub file path |
||
140 | * @param bool $isInterceptFileFuncs Whether or not Phar::interceptFileFuncs() should be used |
||
141 | * @param bool $isStubGenerated Whether or not if the PHAR stub should be generated |
||
142 | * @param bool $checkRequirements Whether the PHAR will check the application requirements before running |
||
143 | */ |
||
144 | private function __construct( |
||
145 | ?string $file, |
||
146 | string $alias, |
||
147 | string $basePath, |
||
148 | array $composerJson, |
||
149 | array $composerLock, |
||
150 | array $files, |
||
151 | array $binaryFiles, |
||
152 | array $compactors, |
||
153 | ?int $compressionAlgorithm, |
||
154 | ?int $fileMode, |
||
155 | string $mainScriptPath, |
||
156 | string $mainScriptContents, |
||
157 | MapFile $fileMapper, |
||
158 | $metadata, |
||
159 | string $tmpOutputPath, |
||
160 | string $outputPath, |
||
161 | ?string $privateKeyPassphrase, |
||
162 | ?string $privateKeyPath, |
||
163 | bool $isPrivateKeyPrompt, |
||
164 | array $processedReplacements, |
||
165 | ?string $shebang, |
||
166 | int $signingAlgorithm, |
||
167 | ?string $stubBannerContents, |
||
168 | ?string $stubBannerPath, |
||
169 | ?string $stubPath, |
||
170 | bool $isInterceptFileFuncs, |
||
171 | bool $isStubGenerated, |
||
172 | bool $checkRequirements |
||
173 | ) { |
||
174 | Assertion::nullOrInArray( |
||
175 | $compressionAlgorithm, |
||
176 | get_phar_compression_algorithms(), |
||
177 | sprintf( |
||
178 | 'Invalid compression algorithm "%%s", use one of "%s" instead.', |
||
179 | implode('", "', array_keys(get_phar_compression_algorithms())) |
||
180 | ) |
||
181 | ); |
||
182 | |||
183 | $this->file = $file; |
||
184 | $this->alias = $alias; |
||
185 | $this->basePath = $basePath; |
||
186 | $this->composerJson = $composerJson; |
||
187 | $this->composerLock = $composerLock; |
||
188 | $this->files = $files; |
||
189 | $this->binaryFiles = $binaryFiles; |
||
190 | $this->compactors = $compactors; |
||
191 | $this->compressionAlgorithm = $compressionAlgorithm; |
||
192 | $this->fileMode = $fileMode; |
||
193 | $this->mainScriptPath = $mainScriptPath; |
||
194 | $this->mainScriptContents = $mainScriptContents; |
||
195 | $this->fileMapper = $fileMapper; |
||
196 | $this->metadata = $metadata; |
||
197 | $this->tmpOutputPath = $tmpOutputPath; |
||
198 | $this->outputPath = $outputPath; |
||
199 | $this->privateKeyPassphrase = $privateKeyPassphrase; |
||
200 | $this->privateKeyPath = $privateKeyPath; |
||
201 | $this->isPrivateKeyPrompt = $isPrivateKeyPrompt; |
||
202 | $this->processedReplacements = $processedReplacements; |
||
203 | $this->shebang = $shebang; |
||
204 | $this->signingAlgorithm = $signingAlgorithm; |
||
205 | $this->stubBannerContents = $stubBannerContents; |
||
206 | $this->stubBannerPath = $stubBannerPath; |
||
207 | $this->stubPath = $stubPath; |
||
208 | $this->isInterceptFileFuncs = $isInterceptFileFuncs; |
||
209 | $this->isStubGenerated = $isStubGenerated; |
||
210 | $this->checkRequirements = $checkRequirements; |
||
211 | } |
||
212 | |||
213 | public static function create(?string $file, stdClass $raw): self |
||
214 | { |
||
215 | $alias = self::retrieveAlias($raw); |
||
216 | |||
217 | $basePath = self::retrieveBasePath($file, $raw); |
||
218 | |||
219 | $composerFiles = self::retrieveComposerFiles($basePath); |
||
220 | |||
221 | $mainScriptPath = self::retrieveMainScriptPath($raw, $basePath, $composerFiles[0][1]); |
||
222 | $mainScriptContents = self::retrieveMainScriptContents($mainScriptPath); |
||
223 | |||
224 | [$tmpOutputPath, $outputPath] = self::retrieveOutputPath($raw, $basePath, $mainScriptPath); |
||
225 | |||
226 | $composerJson = $composerFiles[0]; |
||
227 | $composerLock = $composerFiles[1]; |
||
228 | |||
229 | $devPackages = ComposerConfiguration::retrieveDevPackages($basePath, $composerJson[1], $composerLock[1]); |
||
230 | |||
231 | [$excludedPaths, $blacklistFilter] = self::retrieveBlacklistFilter($raw, $basePath, $tmpOutputPath, $outputPath); |
||
232 | |||
233 | if (self::shouldRetrieveAllFiles($file, $raw)) { |
||
234 | $filesAggregate = self::retrieveAllFiles($basePath, $mainScriptPath, $blacklistFilter, $excludedPaths, $devPackages); |
||
235 | $binaryFilesAggregate = []; |
||
236 | } else { |
||
237 | $files = self::retrieveFiles($raw, 'files', $basePath, $composerFiles); |
||
238 | |||
239 | $directories = self::retrieveDirectories($raw, 'directories', $basePath, $blacklistFilter, $excludedPaths); |
||
240 | $filesFromFinders = self::retrieveFilesFromFinders($raw, 'finder', $basePath, $blacklistFilter, $devPackages); |
||
241 | |||
242 | $filesAggregate = array_unique(iterator_to_array(chain($files, $directories, ...$filesFromFinders))); |
||
243 | |||
244 | $binaryFiles = self::retrieveFiles($raw, 'files-bin', $basePath); |
||
245 | $binaryDirectories = self::retrieveDirectories($raw, 'directories-bin', $basePath, $blacklistFilter, $excludedPaths); |
||
246 | $binaryFilesFromFinders = self::retrieveFilesFromFinders($raw, 'finder-bin', $basePath, $blacklistFilter, $devPackages); |
||
247 | |||
248 | $binaryFilesAggregate = array_unique(iterator_to_array(chain($binaryFiles, $binaryDirectories, ...$binaryFilesFromFinders))); |
||
249 | } |
||
250 | |||
251 | $compactors = self::retrieveCompactors($raw, $basePath); |
||
252 | $compressionAlgorithm = self::retrieveCompressionAlgorithm($raw); |
||
253 | |||
254 | $fileMode = self::retrieveFileMode($raw); |
||
255 | |||
256 | $map = self::retrieveMap($raw); |
||
257 | $fileMapper = new MapFile($map); |
||
258 | |||
259 | $metadata = self::retrieveMetadata($raw); |
||
260 | |||
261 | $privateKeyPassphrase = self::retrievePrivateKeyPassphrase($raw); |
||
262 | $privateKeyPath = self::retrievePrivateKeyPath($raw); |
||
263 | $isPrivateKeyPrompt = self::retrieveIsPrivateKeyPrompt($raw); |
||
264 | |||
265 | $replacements = self::retrieveReplacements($raw); |
||
266 | $processedReplacements = self::retrieveProcessedReplacements($replacements, $raw, $file); |
||
267 | |||
268 | $shebang = self::retrieveShebang($raw); |
||
269 | |||
270 | $signingAlgorithm = self::retrieveSigningAlgorithm($raw); |
||
271 | |||
272 | $stubBannerContents = self::retrieveStubBannerContents($raw); |
||
273 | $stubBannerPath = self::retrieveStubBannerPath($raw, $basePath); |
||
274 | |||
275 | if (null !== $stubBannerPath) { |
||
276 | $stubBannerContents = file_contents($stubBannerPath); |
||
277 | } |
||
278 | |||
279 | $stubBannerContents = self::normalizeStubBannerContents($stubBannerContents); |
||
280 | |||
281 | $stubPath = self::retrieveStubPath($raw, $basePath); |
||
282 | |||
283 | $isInterceptFileFuncs = self::retrieveIsInterceptFileFuncs($raw); |
||
284 | $isStubGenerated = self::retrieveIsStubGenerated($raw, $stubPath); |
||
285 | |||
286 | $checkRequirements = self::retrieveCheckRequirements( |
||
287 | $raw, |
||
288 | null !== $composerLock[0], |
||
289 | $isStubGenerated |
||
290 | ); |
||
291 | |||
292 | return new self( |
||
293 | $file, |
||
294 | $alias, |
||
295 | $basePath, |
||
296 | $composerJson, |
||
297 | $composerLock, |
||
298 | $filesAggregate, |
||
299 | $binaryFilesAggregate, |
||
300 | $compactors, |
||
301 | $compressionAlgorithm, |
||
302 | $fileMode, |
||
303 | $mainScriptPath, |
||
304 | $mainScriptContents, |
||
305 | $fileMapper, |
||
306 | $metadata, |
||
307 | $tmpOutputPath, |
||
308 | $outputPath, |
||
309 | $privateKeyPassphrase, |
||
310 | $privateKeyPath, |
||
311 | $isPrivateKeyPrompt, |
||
312 | $processedReplacements, |
||
313 | $shebang, |
||
314 | $signingAlgorithm, |
||
315 | $stubBannerContents, |
||
316 | $stubBannerPath, |
||
317 | $stubPath, |
||
318 | $isInterceptFileFuncs, |
||
319 | $isStubGenerated, |
||
320 | $checkRequirements |
||
321 | ); |
||
322 | } |
||
323 | |||
324 | public function getFile(): ?string |
||
325 | { |
||
326 | return $this->file; |
||
327 | } |
||
328 | |||
329 | public function getAlias(): string |
||
330 | { |
||
331 | return $this->alias; |
||
332 | } |
||
333 | |||
334 | public function getBasePath(): string |
||
335 | { |
||
336 | return $this->basePath; |
||
337 | } |
||
338 | |||
339 | public function getComposerJson(): ?string |
||
340 | { |
||
341 | return $this->composerJson[0]; |
||
342 | } |
||
343 | |||
344 | public function getComposerJsonDecodedContents(): ?array |
||
345 | { |
||
346 | return $this->composerJson[1]; |
||
347 | } |
||
348 | |||
349 | public function getComposerLock(): ?string |
||
350 | { |
||
351 | return $this->composerLock[0]; |
||
352 | } |
||
353 | |||
354 | public function getComposerLockDecodedContents(): ?array |
||
355 | { |
||
356 | return $this->composerLock[1]; |
||
357 | } |
||
358 | |||
359 | /** |
||
360 | * @return string[] |
||
361 | */ |
||
362 | public function getFiles(): array |
||
363 | { |
||
364 | return $this->files; |
||
365 | } |
||
366 | |||
367 | /** |
||
368 | * @return string[] |
||
369 | */ |
||
370 | public function getBinaryFiles(): array |
||
371 | { |
||
372 | return $this->binaryFiles; |
||
373 | } |
||
374 | |||
375 | /** |
||
376 | * @return Compactor[] the list of compactors |
||
377 | */ |
||
378 | public function getCompactors(): array |
||
379 | { |
||
380 | return $this->compactors; |
||
381 | } |
||
382 | |||
383 | public function getCompressionAlgorithm(): ?int |
||
384 | { |
||
385 | return $this->compressionAlgorithm; |
||
386 | } |
||
387 | |||
388 | public function getFileMode(): ?int |
||
389 | { |
||
390 | return $this->fileMode; |
||
391 | } |
||
392 | |||
393 | public function getMainScriptPath(): string |
||
394 | { |
||
395 | return $this->mainScriptPath; |
||
396 | } |
||
397 | |||
398 | public function getMainScriptContents(): string |
||
399 | { |
||
400 | return $this->mainScriptContents; |
||
401 | } |
||
402 | |||
403 | public function checkRequirements(): bool |
||
404 | { |
||
405 | return $this->checkRequirements; |
||
406 | } |
||
407 | |||
408 | public function getTmpOutputPath(): string |
||
409 | { |
||
410 | return $this->tmpOutputPath; |
||
411 | } |
||
412 | |||
413 | public function getOutputPath(): string |
||
414 | { |
||
415 | return $this->outputPath; |
||
416 | } |
||
417 | |||
418 | /** |
||
419 | * @return string[] |
||
420 | */ |
||
421 | public function getMap(): array |
||
422 | { |
||
423 | return $this->fileMapper->getMap(); |
||
424 | } |
||
425 | |||
426 | public function getFileMapper(): MapFile |
||
427 | { |
||
428 | return $this->fileMapper; |
||
429 | } |
||
430 | |||
431 | /** |
||
432 | * @return mixed |
||
433 | */ |
||
434 | public function getMetadata() |
||
437 | } |
||
438 | |||
439 | public function getPrivateKeyPassphrase(): ?string |
||
440 | { |
||
441 | return $this->privateKeyPassphrase; |
||
442 | } |
||
443 | |||
444 | public function getPrivateKeyPath(): ?string |
||
445 | { |
||
446 | return $this->privateKeyPath; |
||
447 | } |
||
448 | |||
449 | public function isPrivateKeyPrompt(): bool |
||
450 | { |
||
451 | return $this->isPrivateKeyPrompt; |
||
452 | } |
||
453 | |||
454 | public function getProcessedReplacements(): array |
||
455 | { |
||
456 | return $this->processedReplacements; |
||
457 | } |
||
458 | |||
459 | public function getShebang(): ?string |
||
460 | { |
||
461 | return $this->shebang; |
||
462 | } |
||
463 | |||
464 | public function getSigningAlgorithm(): int |
||
465 | { |
||
466 | return $this->signingAlgorithm; |
||
467 | } |
||
468 | |||
469 | public function getStubBannerContents(): ?string |
||
470 | { |
||
471 | return $this->stubBannerContents; |
||
472 | } |
||
473 | |||
474 | public function getStubBannerPath(): ?string |
||
475 | { |
||
476 | return $this->stubBannerPath; |
||
477 | } |
||
478 | |||
479 | public function getStubPath(): ?string |
||
480 | { |
||
481 | return $this->stubPath; |
||
482 | } |
||
483 | |||
484 | public function isInterceptFileFuncs(): bool |
||
485 | { |
||
486 | return $this->isInterceptFileFuncs; |
||
487 | } |
||
488 | |||
489 | public function isStubGenerated(): bool |
||
490 | { |
||
491 | return $this->isStubGenerated; |
||
492 | } |
||
493 | |||
494 | private static function retrieveAlias(stdClass $raw): string |
||
495 | { |
||
496 | if (false === isset($raw->alias)) { |
||
497 | return uniqid('box-auto-generated-alias-', false).'.phar'; |
||
498 | } |
||
499 | |||
500 | $alias = trim($raw->alias); |
||
501 | |||
502 | Assertion::notEmpty($alias, 'A PHAR alias cannot be empty when provided.'); |
||
503 | |||
504 | return $alias; |
||
505 | } |
||
506 | |||
507 | private static function retrieveBasePath(?string $file, stdClass $raw): string |
||
508 | { |
||
509 | if (null === $file) { |
||
510 | return getcwd(); |
||
511 | } |
||
512 | |||
513 | if (false === isset($raw->{'base-path'})) { |
||
514 | return realpath(dirname($file)); |
||
515 | } |
||
516 | |||
517 | $basePath = trim($raw->{'base-path'}); |
||
518 | |||
519 | Assertion::directory( |
||
520 | $basePath, |
||
521 | 'The base path "%s" is not a directory or does not exist.' |
||
522 | ); |
||
523 | |||
524 | return realpath($basePath); |
||
525 | } |
||
526 | |||
527 | private static function shouldRetrieveAllFiles(?string $file, stdClass $raw): bool |
||
528 | { |
||
529 | if (null === $file) { |
||
530 | return true; |
||
531 | } |
||
532 | |||
533 | // TODO: config should be casted into an array: it is easier to do and we need an array in several places now |
||
534 | $rawConfig = (array) $raw; |
||
535 | |||
536 | foreach (self::FILES_SETTINGS as $key) { |
||
537 | if (array_key_exists($key, $rawConfig)) { |
||
538 | return false; |
||
539 | } |
||
540 | } |
||
541 | |||
542 | return true; |
||
543 | } |
||
544 | |||
545 | private static function retrieveBlacklistFilter(stdClass $raw, string $basePath, string ...$excludedPaths): array |
||
546 | { |
||
547 | $blacklist = self::retrieveBlacklist($raw, $basePath, ...$excludedPaths); |
||
548 | |||
549 | $blacklistFilter = function (SplFileInfo $file) use ($blacklist): ?bool { |
||
550 | if ($file->isLink()) { |
||
551 | return false; |
||
552 | } |
||
553 | |||
554 | if (false === $file->getRealPath()) { |
||
555 | return false; |
||
556 | } |
||
557 | |||
558 | if (in_array($file->getRealPath(), $blacklist, true)) { |
||
559 | return false; |
||
560 | } |
||
561 | |||
562 | return null; |
||
563 | }; |
||
564 | |||
565 | return [$blacklist, $blacklistFilter]; |
||
566 | } |
||
567 | |||
568 | /** |
||
569 | * @param stdClass $raw |
||
570 | * @param string $basePath |
||
571 | * @param string[] $excludedPaths |
||
572 | * |
||
573 | * @return string[] |
||
574 | */ |
||
575 | private static function retrieveBlacklist(stdClass $raw, string $basePath, string ...$excludedPaths): array |
||
576 | { |
||
577 | /** @var string[] $blacklist */ |
||
578 | $blacklist = array_merge($excludedPaths, $raw->blacklist ?? []); |
||
579 | |||
580 | $normalizedBlacklist = []; |
||
581 | |||
582 | foreach ($blacklist as $file) { |
||
583 | $normalizedBlacklist[] = self::normalizePath($file, $basePath); |
||
584 | $normalizedBlacklist[] = canonicalize(make_path_relative(trim($file), $basePath)); |
||
585 | } |
||
586 | |||
587 | return array_unique($normalizedBlacklist); |
||
588 | } |
||
589 | |||
590 | /** |
||
591 | * @return SplFileInfo[] |
||
592 | */ |
||
593 | private static function retrieveFiles(stdClass $raw, string $key, string $basePath, array $composerFiles = []): array |
||
594 | { |
||
595 | $files = []; |
||
596 | |||
597 | if (isset($composerFiles[0][0])) { |
||
598 | $files[] = $composerFiles[0][0]; |
||
599 | } |
||
600 | |||
601 | if (isset($composerFiles[1][1])) { |
||
602 | $files[] = $composerFiles[1][0]; |
||
603 | } |
||
604 | |||
605 | if (false === isset($raw->{$key})) { |
||
606 | return []; |
||
607 | } |
||
608 | |||
609 | $files = array_merge((array) $raw->{$key}, $files); |
||
610 | |||
611 | Assertion::allString($files); |
||
612 | |||
613 | $normalizePath = function (string $file) use ($basePath, $key): SplFileInfo { |
||
614 | $file = self::normalizePath($file, $basePath); |
||
615 | |||
616 | if (is_link($file)) { |
||
617 | // TODO: add this to baberlei/assert |
||
618 | throw new InvalidArgumentException( |
||
619 | sprintf( |
||
620 | 'Cannot add the link "%s": links are not supported.', |
||
621 | $file |
||
622 | ) |
||
623 | ); |
||
624 | } |
||
625 | |||
626 | Assertion::file( |
||
627 | $file, |
||
628 | sprintf( |
||
629 | '"%s" must contain a list of existing files. Could not find "%%s".', |
||
630 | $key |
||
631 | ) |
||
632 | ); |
||
633 | |||
634 | return new SplFileInfo($file); |
||
635 | }; |
||
636 | |||
637 | return array_map($normalizePath, $files); |
||
638 | } |
||
639 | |||
640 | /** |
||
641 | * @param stdClass $raw |
||
642 | * @param string $key Config property name |
||
643 | * @param string $basePath |
||
644 | * @param Closure $blacklistFilter |
||
645 | * @param string[] $excludedPaths |
||
646 | * |
||
647 | * @return iterable|SplFileInfo[] |
||
648 | */ |
||
649 | private static function retrieveDirectories( |
||
650 | stdClass $raw, |
||
651 | string $key, |
||
652 | string $basePath, |
||
653 | Closure $blacklistFilter, |
||
654 | array $excludedPaths |
||
655 | ): iterable { |
||
656 | $directories = self::retrieveDirectoryPaths($raw, $key, $basePath); |
||
657 | |||
658 | if ([] !== $directories) { |
||
659 | $finder = Finder::create() |
||
660 | ->files() |
||
661 | ->filter($blacklistFilter) |
||
662 | ->ignoreVCS(true) |
||
663 | ->in($directories) |
||
664 | ; |
||
665 | |||
666 | foreach ($excludedPaths as $excludedPath) { |
||
667 | $finder->notPath($excludedPath); |
||
668 | } |
||
669 | |||
670 | return $finder; |
||
1 ignored issue
–
show
|
|||
671 | } |
||
672 | |||
673 | return []; |
||
674 | } |
||
675 | |||
676 | /** |
||
677 | * @param stdClass $raw |
||
678 | * @param string $key |
||
679 | * @param string $basePath |
||
680 | * @param Closure $blacklistFilter |
||
681 | * @param string[] $devPackages |
||
682 | * |
||
683 | * @return iterable[]|SplFileInfo[][] |
||
684 | */ |
||
685 | private static function retrieveFilesFromFinders( |
||
686 | stdClass $raw, |
||
687 | string $key, |
||
688 | string $basePath, |
||
689 | Closure $blacklistFilter, |
||
690 | array $devPackages |
||
691 | ): array { |
||
692 | if (isset($raw->{$key})) { |
||
693 | return self::processFinders($raw->{$key}, $basePath, $blacklistFilter, $devPackages); |
||
694 | } |
||
695 | |||
696 | return []; |
||
697 | } |
||
698 | |||
699 | /** |
||
700 | * @param array $findersConfig |
||
701 | * @param string $basePath |
||
702 | * @param Closure $blacklistFilter |
||
703 | * @param string[] $devPackages |
||
704 | * |
||
705 | * @return Finder[]|SplFileInfo[][] |
||
706 | */ |
||
707 | private static function processFinders( |
||
708 | array $findersConfig, |
||
709 | string $basePath, |
||
710 | Closure $blacklistFilter, |
||
711 | array $devPackages |
||
712 | ): array { |
||
713 | $processFinderConfig = function (stdClass $config) use ($basePath, $blacklistFilter, $devPackages) { |
||
714 | return self::processFinder($config, $basePath, $blacklistFilter, $devPackages); |
||
715 | }; |
||
716 | |||
717 | return array_map($processFinderConfig, $findersConfig); |
||
718 | } |
||
719 | |||
720 | /** |
||
721 | * @param stdClass $config |
||
722 | * @param string $basePath |
||
723 | * @param Closure $blacklistFilter |
||
724 | * @param string[] $devPackages |
||
725 | * |
||
726 | * @return Finder|SplFileInfo[] |
||
727 | */ |
||
728 | private static function processFinder( |
||
729 | stdClass $config, |
||
730 | string $basePath, |
||
731 | Closure $blacklistFilter, |
||
732 | array $devPackages |
||
733 | ): Finder { |
||
734 | $finder = Finder::create() |
||
735 | ->files() |
||
736 | ->filter($blacklistFilter) |
||
737 | ->filter( |
||
738 | function (SplFileInfo $fileInfo) use ($devPackages): bool { |
||
739 | foreach ($devPackages as $devPackage) { |
||
740 | if ($devPackage === longest_common_base_path([$devPackage, $fileInfo->getRealPath()])) { |
||
741 | // File belongs to the dev package |
||
742 | return false; |
||
743 | } |
||
744 | } |
||
745 | |||
746 | return true; |
||
747 | } |
||
748 | ) |
||
749 | ->ignoreVCS(true) |
||
750 | ; |
||
751 | |||
752 | $normalizedConfig = (function (array $config, Finder $finder): array { |
||
753 | $normalizedConfig = []; |
||
754 | |||
755 | foreach ($config as $method => $arguments) { |
||
756 | $method = trim($method); |
||
757 | $arguments = (array) $arguments; |
||
758 | |||
759 | Assertion::methodExists( |
||
760 | $method, |
||
761 | $finder, |
||
762 | 'The method "Finder::%s" does not exist.' |
||
763 | ); |
||
764 | |||
765 | $normalizedConfig[$method] = $arguments; |
||
766 | } |
||
767 | |||
768 | krsort($normalizedConfig); |
||
769 | |||
770 | return $normalizedConfig; |
||
771 | })((array) $config, $finder); |
||
772 | |||
773 | $createNormalizedDirectories = function (string $directory) use ($basePath): ?string { |
||
774 | $directory = self::normalizePath($directory, $basePath); |
||
775 | |||
776 | if (is_link($directory)) { |
||
777 | // TODO: add this to baberlei/assert |
||
778 | throw new InvalidArgumentException( |
||
779 | sprintf( |
||
780 | 'Cannot append the link "%s" to the Finder: links are not supported.', |
||
781 | $directory |
||
782 | ) |
||
783 | ); |
||
784 | } |
||
785 | |||
786 | Assertion::directory($directory); |
||
787 | |||
788 | return $directory; |
||
789 | }; |
||
790 | |||
791 | $normalizeFileOrDirectory = function (string &$fileOrDirectory) use ($basePath): void { |
||
792 | $fileOrDirectory = self::normalizePath($fileOrDirectory, $basePath); |
||
793 | |||
794 | if (is_link($fileOrDirectory)) { |
||
795 | // TODO: add this to baberlei/assert |
||
796 | throw new InvalidArgumentException( |
||
797 | sprintf( |
||
798 | 'Cannot append the link "%s" to the Finder: links are not supported.', |
||
799 | $fileOrDirectory |
||
800 | ) |
||
801 | ); |
||
802 | } |
||
803 | |||
804 | // TODO: add this to baberlei/assert |
||
805 | if (false === file_exists($fileOrDirectory)) { |
||
806 | throw new InvalidArgumentException( |
||
807 | sprintf( |
||
808 | 'Path "%s" was expected to be a file or directory. It may be a symlink (which are unsupported).', |
||
809 | $fileOrDirectory |
||
810 | ) |
||
811 | ); |
||
812 | } |
||
813 | |||
814 | // TODO: add fileExists (as file or directory) to Assert |
||
815 | if (false === is_file($fileOrDirectory)) { |
||
816 | Assertion::directory($fileOrDirectory); |
||
817 | } else { |
||
818 | Assertion::file($fileOrDirectory); |
||
819 | } |
||
820 | }; |
||
821 | |||
822 | foreach ($normalizedConfig as $method => $arguments) { |
||
823 | if ('in' === $method) { |
||
824 | $normalizedConfig[$method] = $arguments = array_map($createNormalizedDirectories, $arguments); |
||
825 | } |
||
826 | |||
827 | if ('exclude' === $method) { |
||
828 | $arguments = array_unique(array_map('trim', $arguments)); |
||
829 | } |
||
830 | |||
831 | if ('append' === $method) { |
||
832 | array_walk($arguments, $normalizeFileOrDirectory); |
||
833 | |||
834 | $arguments = [$arguments]; |
||
835 | } |
||
836 | |||
837 | foreach ($arguments as $argument) { |
||
838 | $finder->$method($argument); |
||
839 | } |
||
840 | } |
||
841 | |||
842 | return $finder; |
||
843 | } |
||
844 | |||
845 | /** |
||
846 | * @param string $basePath |
||
847 | * @param string $mainScriptPath |
||
848 | * @param Closure $blacklistFilter |
||
849 | * @param string[] $excludedPaths |
||
850 | * @param string[] $devPackages |
||
851 | * |
||
852 | * @return SplFileInfo[] |
||
853 | */ |
||
854 | private static function retrieveAllFiles( |
||
855 | string $basePath, |
||
856 | string $mainScriptPath, |
||
857 | Closure $blacklistFilter, |
||
858 | array $excludedPaths, |
||
859 | array $devPackages |
||
860 | ): array { |
||
861 | $relativeDevPackages = array_map( |
||
862 | function (string $packagePath) use ($basePath): string { |
||
863 | return make_path_relative($packagePath, $basePath); |
||
864 | }, |
||
865 | $devPackages |
||
866 | ); |
||
867 | |||
868 | $finder = Finder::create() |
||
869 | ->files() |
||
870 | ->in($basePath) |
||
871 | ->notPath(make_path_relative($mainScriptPath, $basePath)) |
||
872 | ->filter($blacklistFilter) |
||
873 | ->exclude($relativeDevPackages) |
||
874 | ->ignoreVCS(true) |
||
875 | ; |
||
876 | |||
877 | $excludedPaths = array_unique( |
||
878 | array_filter( |
||
879 | array_map( |
||
880 | function (string $path) use ($basePath): string { |
||
881 | return make_path_relative($path, $basePath); |
||
882 | }, |
||
883 | $excludedPaths |
||
884 | ), |
||
885 | function (string $path): bool { |
||
886 | return '..' !== substr($path, 0, 2); |
||
887 | } |
||
888 | ) |
||
889 | ); |
||
890 | |||
891 | foreach ($excludedPaths as $excludedPath) { |
||
892 | $finder->notPath($excludedPath); |
||
893 | } |
||
894 | |||
895 | return array_unique( |
||
896 | toArray( |
||
897 | map( |
||
898 | method('getRealPath'), |
||
899 | $finder |
||
900 | ) |
||
901 | ) |
||
902 | ); |
||
903 | } |
||
904 | |||
905 | /** |
||
906 | * @param stdClass $raw |
||
907 | * @param string $key Config property name |
||
908 | * @param string $basePath |
||
909 | * |
||
910 | * @return string[] |
||
911 | */ |
||
912 | private static function retrieveDirectoryPaths(stdClass $raw, string $key, string $basePath): array |
||
913 | { |
||
914 | if (false === isset($raw->{$key})) { |
||
915 | return []; |
||
916 | } |
||
917 | |||
918 | $directories = $raw->{$key}; |
||
919 | |||
920 | $normalizeDirectory = function (string $directory) use ($basePath, $key): string { |
||
921 | $directory = self::normalizePath($directory, $basePath); |
||
922 | |||
923 | if (is_link($directory)) { |
||
924 | // TODO: add this to baberlei/assert |
||
925 | throw new InvalidArgumentException( |
||
926 | sprintf( |
||
927 | 'Cannot add the link "%s": links are not supported.', |
||
928 | $directory |
||
929 | ) |
||
930 | ); |
||
931 | } |
||
932 | |||
933 | Assertion::directory( |
||
934 | $directory, |
||
935 | sprintf( |
||
936 | '"%s" must contain a list of existing directories. Could not find "%%s".', |
||
937 | $key |
||
938 | ) |
||
939 | ); |
||
940 | |||
941 | return $directory; |
||
942 | }; |
||
943 | |||
944 | return array_map($normalizeDirectory, $directories); |
||
945 | } |
||
946 | |||
947 | private static function normalizePath(string $file, string $basePath): string |
||
948 | { |
||
949 | return make_path_absolute(trim($file), $basePath); |
||
950 | } |
||
951 | |||
952 | /** |
||
953 | * @return Compactor[] |
||
954 | */ |
||
955 | private static function retrieveCompactors(stdClass $raw, string $basePath): array |
||
956 | { |
||
957 | if (false === isset($raw->compactors)) { |
||
958 | return []; |
||
959 | } |
||
960 | |||
961 | $compactorClasses = array_unique((array) $raw->compactors); |
||
962 | |||
963 | return array_map( |
||
964 | function (string $class) use ($raw, $basePath): Compactor { |
||
965 | Assertion::classExists($class, 'The compactor class "%s" does not exist.'); |
||
966 | Assertion::implementsInterface($class, Compactor::class, 'The class "%s" is not a compactor class.'); |
||
967 | |||
968 | if (Php::class === $class || LegacyPhp::class === $class) { |
||
969 | return self::createPhpCompactor($raw); |
||
970 | } |
||
971 | |||
972 | if (PhpScoperCompactor::class === $class) { |
||
973 | $phpScoperConfig = self::retrievePhpScoperConfig($raw, $basePath); |
||
974 | |||
975 | return new PhpScoperCompactor( |
||
976 | new SimpleScoper( |
||
977 | create_scoper(), |
||
978 | uniqid('_HumbugBox', false), |
||
979 | $phpScoperConfig->getWhitelist(), |
||
980 | $phpScoperConfig->getPatchers() |
||
981 | ) |
||
982 | ); |
||
983 | } |
||
984 | |||
985 | return new $class(); |
||
986 | }, |
||
987 | $compactorClasses |
||
988 | ); |
||
989 | } |
||
990 | |||
991 | private static function retrieveCompressionAlgorithm(stdClass $raw): ?int |
||
992 | { |
||
993 | if (false === isset($raw->compression)) { |
||
994 | return null; |
||
995 | } |
||
996 | |||
997 | $knownAlgorithmNames = array_keys(get_phar_compression_algorithms()); |
||
998 | |||
999 | Assertion::inArray( |
||
1000 | $raw->compression, |
||
1001 | $knownAlgorithmNames, |
||
1002 | sprintf( |
||
1003 | 'Invalid compression algorithm "%%s", use one of "%s" instead.', |
||
1004 | implode('", "', $knownAlgorithmNames) |
||
1005 | ) |
||
1006 | ); |
||
1007 | |||
1008 | $value = get_phar_compression_algorithms()[$raw->compression]; |
||
1009 | |||
1010 | // Phar::NONE is not valid for compressFiles() |
||
1011 | if (Phar::NONE === $value) { |
||
1012 | return null; |
||
1013 | } |
||
1014 | |||
1015 | return $value; |
||
1016 | } |
||
1017 | |||
1018 | private static function retrieveFileMode(stdClass $raw): ?int |
||
1019 | { |
||
1020 | if (isset($raw->chmod)) { |
||
1021 | return intval($raw->chmod, 8); |
||
1022 | } |
||
1023 | |||
1024 | return null; |
||
1025 | } |
||
1026 | |||
1027 | private static function retrieveMainScriptPath(stdClass $raw, string $basePath, ?array $decodedJsonContents): string |
||
1028 | { |
||
1029 | if (isset($raw->main)) { |
||
1030 | $main = $raw->main; |
||
1031 | } else { |
||
1032 | if (null === $decodedJsonContents |
||
1033 | || false === array_key_exists('bin', $decodedJsonContents) |
||
1034 | || false === $main = current($decodedJsonContents['bin']) |
||
1035 | ) { |
||
1036 | $main = self::DEFAULT_MAIN_SCRIPT; |
||
1037 | } |
||
1038 | } |
||
1039 | |||
1040 | return self::normalizePath($main, $basePath); |
||
1041 | } |
||
1042 | |||
1043 | private static function retrieveMainScriptContents(string $mainScriptPath): string |
||
1044 | { |
||
1045 | $contents = file_contents($mainScriptPath); |
||
1046 | |||
1047 | // Remove the shebang line: the shebang line in a PHAR should be located in the stub file which is the real |
||
1048 | // PHAR entry point file. |
||
1049 | return preg_replace('/^#!.*\s*/', '', $contents); |
||
1050 | } |
||
1051 | |||
1052 | private static function retrieveComposerFiles(string $basePath): array |
||
1053 | { |
||
1054 | $retrieveFileAndContents = function (string $file): array { |
||
1055 | $json = new Json(); |
||
1056 | |||
1057 | if (false === file_exists($file) || false === is_file($file) || false === is_readable($file)) { |
||
1058 | return [null, null]; |
||
1059 | } |
||
1060 | |||
1061 | try { |
||
1062 | $contents = $json->decodeFile($file, true); |
||
1063 | } catch (ParsingException $exception) { |
||
1064 | throw new InvalidArgumentException( |
||
1065 | sprintf( |
||
1066 | 'Expected the file "%s" to be a valid composer.json file but an error has been found: %s', |
||
1067 | $file, |
||
1068 | $exception->getMessage() |
||
1069 | ), |
||
1070 | 0, |
||
1071 | $exception |
||
1072 | ); |
||
1073 | } |
||
1074 | |||
1075 | return [$file, $contents]; |
||
1076 | }; |
||
1077 | |||
1078 | [$composerJson, $composerJsonContents] = $retrieveFileAndContents(canonicalize($basePath.'/composer.json')); |
||
1079 | [$composerLock, $composerLockContents] = $retrieveFileAndContents(canonicalize($basePath.'/composer.lock')); |
||
1080 | |||
1081 | return [ |
||
1082 | [$composerJson, $composerJsonContents], |
||
1083 | [$composerLock, $composerLockContents], |
||
1084 | ]; |
||
1085 | } |
||
1086 | |||
1087 | /** |
||
1088 | * @return string[][] |
||
1089 | */ |
||
1090 | private static function retrieveMap(stdClass $raw): array |
||
1091 | { |
||
1092 | if (false === isset($raw->map)) { |
||
1093 | return []; |
||
1094 | } |
||
1095 | |||
1096 | $map = []; |
||
1097 | |||
1098 | foreach ((array) $raw->map as $item) { |
||
1099 | $processed = []; |
||
1100 | |||
1101 | foreach ($item as $match => $replace) { |
||
1102 | $processed[canonicalize(trim($match))] = canonicalize(trim($replace)); |
||
1103 | } |
||
1104 | |||
1105 | if (isset($processed['_empty_'])) { |
||
1106 | $processed[''] = $processed['_empty_']; |
||
1107 | |||
1108 | unset($processed['_empty_']); |
||
1109 | } |
||
1110 | |||
1111 | $map[] = $processed; |
||
1112 | } |
||
1113 | |||
1114 | return $map; |
||
1115 | } |
||
1116 | |||
1117 | /** |
||
1118 | * @return mixed |
||
1119 | */ |
||
1120 | private static function retrieveMetadata(stdClass $raw) |
||
1121 | { |
||
1122 | if (isset($raw->metadata)) { |
||
1123 | if (is_object($raw->metadata)) { |
||
1124 | return (array) $raw->metadata; |
||
1125 | } |
||
1126 | |||
1127 | return $raw->metadata; |
||
1128 | } |
||
1129 | |||
1130 | return null; |
||
1131 | } |
||
1132 | |||
1133 | /** |
||
1134 | * @return string[] The first element is the temporary output path and the second the real one |
||
1135 | */ |
||
1136 | private static function retrieveOutputPath(stdClass $raw, string $basePath, string $mainScriptPath): array |
||
1137 | { |
||
1138 | if (isset($raw->output)) { |
||
1139 | $path = $raw->output; |
||
1140 | } else { |
||
1141 | if (1 === preg_match('/^(?<main>.*?)(?:\.[\p{L}\d]+)?$/', $mainScriptPath, $matches)) { |
||
1142 | $path = $matches['main'].'.phar'; |
||
1143 | } else { |
||
1144 | // Last resort, should not happen |
||
1145 | $path = self::DEFAULT_ALIAS; |
||
1146 | } |
||
1147 | } |
||
1148 | |||
1149 | $tmp = $real = self::normalizePath($path, $basePath); |
||
1150 | |||
1151 | if ('.phar' !== substr($real, -5)) { |
||
1152 | $tmp .= '.phar'; |
||
1153 | } |
||
1154 | |||
1155 | return [$tmp, $real]; |
||
1156 | } |
||
1157 | |||
1158 | private static function retrievePrivateKeyPassphrase(stdClass $raw): ?string |
||
1159 | { |
||
1160 | // TODO: add check to not allow this setting without the private key path |
||
1161 | if (isset($raw->{'key-pass'}) |
||
1162 | && is_string($raw->{'key-pass'}) |
||
1163 | ) { |
||
1164 | return $raw->{'key-pass'}; |
||
1165 | } |
||
1166 | |||
1167 | return null; |
||
1168 | } |
||
1169 | |||
1170 | private static function retrievePrivateKeyPath(stdClass $raw): ?string |
||
1171 | { |
||
1172 | // TODO: If passed need to check its existence |
||
1173 | // Also need |
||
1174 | |||
1175 | if (isset($raw->key)) { |
||
1176 | return $raw->key; |
||
1177 | } |
||
1178 | |||
1179 | return null; |
||
1180 | } |
||
1181 | |||
1182 | private static function retrieveReplacements(stdClass $raw): array |
||
1183 | { |
||
1184 | // TODO: add exmample in the doc |
||
1185 | // Add checks against the values |
||
1186 | if (isset($raw->replacements)) { |
||
1187 | return (array) $raw->replacements; |
||
1188 | } |
||
1189 | |||
1190 | return []; |
||
1191 | } |
||
1192 | |||
1193 | private static function retrieveProcessedReplacements( |
||
1194 | array $replacements, |
||
1195 | stdClass $raw, |
||
1196 | ?string $file |
||
1197 | ): array { |
||
1198 | if (null === $file) { |
||
1199 | return []; |
||
1200 | } |
||
1201 | |||
1202 | if (null !== ($git = self::retrieveGitHashPlaceholder($raw))) { |
||
1203 | $replacements[$git] = self::retrieveGitHash($file); |
||
1204 | } |
||
1205 | |||
1206 | if (null !== ($git = self::retrieveGitShortHashPlaceholder($raw))) { |
||
1207 | $replacements[$git] = self::retrieveGitHash($file, true); |
||
1208 | } |
||
1209 | |||
1210 | if (null !== ($git = self::retrieveGitTagPlaceholder($raw))) { |
||
1211 | $replacements[$git] = self::retrieveGitTag($file); |
||
1212 | } |
||
1213 | |||
1214 | if (null !== ($git = self::retrieveGitVersionPlaceholder($raw))) { |
||
1215 | $replacements[$git] = self::retrieveGitVersion($file); |
||
1216 | } |
||
1217 | |||
1218 | if (null !== ($date = self::retrieveDatetimeNowPlaceHolder($raw))) { |
||
1219 | $replacements[$date] = self::retrieveDatetimeNow( |
||
1220 | self::retrieveDatetimeFormat($raw) |
||
1221 | ); |
||
1222 | } |
||
1223 | |||
1224 | $sigil = self::retrieveReplacementSigil($raw); |
||
1225 | |||
1226 | foreach ($replacements as $key => $value) { |
||
1227 | unset($replacements[$key]); |
||
1228 | $replacements["$sigil$key$sigil"] = $value; |
||
1229 | } |
||
1230 | |||
1231 | return $replacements; |
||
1232 | } |
||
1233 | |||
1234 | private static function retrieveGitHashPlaceholder(stdClass $raw): ?string |
||
1235 | { |
||
1236 | if (isset($raw->{'git-commit'})) { |
||
1237 | return $raw->{'git-commit'}; |
||
1238 | } |
||
1239 | |||
1240 | return null; |
||
1241 | } |
||
1242 | |||
1243 | /** |
||
1244 | * @param string $file |
||
1245 | * @param bool $short Use the short version |
||
1246 | * |
||
1247 | * @return string the commit hash |
||
1248 | */ |
||
1249 | private static function retrieveGitHash(string $file, bool $short = false): string |
||
1250 | { |
||
1251 | return self::runGitCommand( |
||
1252 | sprintf( |
||
1253 | 'git log --pretty="%s" -n1 HEAD', |
||
1254 | $short ? '%h' : '%H' |
||
1255 | ), |
||
1256 | $file |
||
1257 | ); |
||
1258 | } |
||
1259 | |||
1260 | private static function retrieveGitShortHashPlaceholder(stdClass $raw): ?string |
||
1261 | { |
||
1262 | if (isset($raw->{'git-commit-short'})) { |
||
1263 | return $raw->{'git-commit-short'}; |
||
1264 | } |
||
1265 | |||
1266 | return null; |
||
1267 | } |
||
1268 | |||
1269 | private static function retrieveGitTagPlaceholder(stdClass $raw): ?string |
||
1270 | { |
||
1271 | if (isset($raw->{'git-tag'})) { |
||
1272 | return $raw->{'git-tag'}; |
||
1273 | } |
||
1274 | |||
1275 | return null; |
||
1276 | } |
||
1277 | |||
1278 | private static function retrieveGitTag(string $file): ?string |
||
1279 | { |
||
1280 | return self::runGitCommand('git describe --tags HEAD', $file); |
||
1281 | } |
||
1282 | |||
1283 | private static function retrieveGitVersionPlaceholder(stdClass $raw): ?string |
||
1284 | { |
||
1285 | if (isset($raw->{'git-version'})) { |
||
1286 | return $raw->{'git-version'}; |
||
1287 | } |
||
1288 | |||
1289 | return null; |
||
1290 | } |
||
1291 | |||
1292 | private static function retrieveGitVersion(string $file): ?string |
||
1293 | { |
||
1294 | // TODO: check if is still relevant as IMO we are better off using OcramiusVersionPackage |
||
1295 | // to avoid messing around with that |
||
1296 | |||
1297 | try { |
||
1298 | return self::retrieveGitTag($file); |
||
1299 | } catch (RuntimeException $exception) { |
||
1300 | try { |
||
1301 | return self::retrieveGitHash($file, true); |
||
1302 | } catch (RuntimeException $exception) { |
||
1303 | throw new RuntimeException( |
||
1304 | sprintf( |
||
1305 | 'The tag or commit hash could not be retrieved from "%s": %s', |
||
1306 | dirname($file), |
||
1307 | $exception->getMessage() |
||
1308 | ), |
||
1309 | 0, |
||
1310 | $exception |
||
1311 | ); |
||
1312 | } |
||
1313 | } |
||
1314 | } |
||
1315 | |||
1316 | private static function retrieveDatetimeNowPlaceHolder(stdClass $raw): ?string |
||
1317 | { |
||
1318 | // TODO: double check why this is done and how it is used it's not completely clear to me. |
||
1319 | // Also make sure the documentation is up to date after. |
||
1320 | // Instead of having two sistinct doc entries for `datetime` and `datetime-format`, it would |
||
1321 | // be better to have only one element IMO like: |
||
1322 | // |
||
1323 | // "datetime": { |
||
1324 | // "value": "val", |
||
1325 | // "format": "Y-m-d" |
||
1326 | // } |
||
1327 | // |
||
1328 | // Also add a check that one cannot be provided without the other. Or maybe it should? I guess |
||
1329 | // if the datetime format is the default one it's ok; but in any case the format should not |
||
1330 | // be added without the datetime value... |
||
1331 | |||
1332 | if (isset($raw->{'datetime'})) { |
||
1333 | return $raw->{'datetime'}; |
||
1334 | } |
||
1335 | |||
1336 | return null; |
||
1337 | } |
||
1338 | |||
1339 | private static function retrieveDatetimeNow(string $format) |
||
1340 | { |
||
1341 | $now = new DateTimeImmutable('now'); |
||
1342 | |||
1343 | $datetime = $now->format($format); |
||
1344 | |||
1345 | if (!$datetime) { |
||
1346 | throw new InvalidArgumentException( |
||
1347 | sprintf( |
||
1348 | '""%s" is not a valid PHP date format', |
||
1349 | $format |
||
1350 | ) |
||
1351 | ); |
||
1352 | } |
||
1353 | |||
1354 | return $datetime; |
||
1355 | } |
||
1356 | |||
1357 | private static function retrieveDatetimeFormat(stdClass $raw): string |
||
1364 | } |
||
1365 | |||
1366 | private static function retrieveReplacementSigil(stdClass $raw) |
||
1367 | { |
||
1368 | if (isset($raw->{'replacement-sigil'})) { |
||
1369 | return $raw->{'replacement-sigil'}; |
||
1370 | } |
||
1371 | |||
1372 | return self::DEFAULT_REPLACEMENT_SIGIL; |
||
1373 | } |
||
1374 | |||
1375 | private static function retrieveShebang(stdClass $raw): ?string |
||
1376 | { |
||
1377 | if (false === array_key_exists('shebang', (array) $raw)) { |
||
1378 | return self::DEFAULT_SHEBANG; |
||
1379 | } |
||
1380 | |||
1381 | if (null === $raw->shebang) { |
||
1382 | return null; |
||
1383 | } |
||
1384 | |||
1385 | $shebang = trim($raw->shebang); |
||
1386 | |||
1387 | Assertion::notEmpty($shebang, 'The shebang should not be empty.'); |
||
1388 | Assertion::true( |
||
1389 | '#!' === substr($shebang, 0, 2), |
||
1390 | sprintf( |
||
1391 | 'The shebang line must start with "#!". Got "%s" instead', |
||
1392 | $shebang |
||
1393 | ) |
||
1394 | ); |
||
1395 | |||
1396 | return $shebang; |
||
1397 | } |
||
1398 | |||
1399 | private static function retrieveSigningAlgorithm(stdClass $raw): int |
||
1400 | { |
||
1401 | // TODO: trigger warning: if no signing algorithm is given provided we are not in dev mode |
||
1402 | // TODO: trigger a warning if the signing algorithm used is weak |
||
1403 | // TODO: no longer accept strings & document BC break |
||
1404 | if (false === isset($raw->algorithm)) { |
||
1405 | return Phar::SHA1; |
||
1406 | } |
||
1407 | |||
1408 | if (false === defined('Phar::'.$raw->algorithm)) { |
||
1409 | throw new InvalidArgumentException( |
||
1410 | sprintf( |
||
1411 | 'The signing algorithm "%s" is not supported.', |
||
1412 | $raw->algorithm |
||
1413 | ) |
||
1414 | ); |
||
1415 | } |
||
1416 | |||
1417 | return constant('Phar::'.$raw->algorithm); |
||
1418 | } |
||
1419 | |||
1420 | private static function retrieveStubBannerContents(stdClass $raw): ?string |
||
1437 | } |
||
1438 | |||
1439 | private static function retrieveStubBannerPath(stdClass $raw, string $basePath): ?string |
||
1440 | { |
||
1441 | if (false === isset($raw->{'banner-file'})) { |
||
1442 | return null; |
||
1443 | } |
||
1444 | |||
1445 | $bannerFile = make_path_absolute($raw->{'banner-file'}, $basePath); |
||
1446 | |||
1447 | Assertion::file($bannerFile); |
||
1448 | |||
1449 | return $bannerFile; |
||
1450 | } |
||
1451 | |||
1452 | private static function normalizeStubBannerContents(?string $contents): ?string |
||
1453 | { |
||
1454 | if (null === $contents) { |
||
1455 | return null; |
||
1456 | } |
||
1457 | |||
1458 | $banner = explode("\n", $contents); |
||
1459 | $banner = array_map('trim', $banner); |
||
1460 | |||
1461 | return implode("\n", $banner); |
||
1462 | } |
||
1463 | |||
1464 | private static function retrieveStubPath(stdClass $raw, string $basePath): ?string |
||
1465 | { |
||
1466 | if (isset($raw->stub) && is_string($raw->stub)) { |
||
1467 | $stubPath = make_path_absolute($raw->stub, $basePath); |
||
1468 | |||
1469 | Assertion::file($stubPath); |
||
1470 | |||
1471 | return $stubPath; |
||
1472 | } |
||
1473 | |||
1474 | return null; |
||
1475 | } |
||
1476 | |||
1477 | private static function retrieveIsInterceptFileFuncs(stdClass $raw): bool |
||
1478 | { |
||
1479 | if (isset($raw->intercept)) { |
||
1480 | return $raw->intercept; |
||
1481 | } |
||
1482 | |||
1483 | return false; |
||
1484 | } |
||
1485 | |||
1486 | private static function retrieveIsPrivateKeyPrompt(stdClass $raw): bool |
||
1487 | { |
||
1488 | return isset($raw->{'key-pass'}) && (true === $raw->{'key-pass'}); |
||
1489 | } |
||
1490 | |||
1491 | private static function retrieveIsStubGenerated(stdClass $raw, ?string $stubPath): bool |
||
1492 | { |
||
1493 | return null === $stubPath && (false === isset($raw->stub) || false !== $raw->stub); |
||
1494 | } |
||
1495 | |||
1496 | private static function retrieveCheckRequirements(stdClass $raw, bool $hasComposerLock, bool $generateStub): bool |
||
1497 | { |
||
1498 | // TODO: emit warning when stub is not generated and check requirements is explicitly set to true |
||
1499 | // TODO: emit warning when no composer lock is found but check requirements is explicitely set to true |
||
1500 | if (false === $hasComposerLock) { |
||
1501 | return false; |
||
1502 | } |
||
1503 | |||
1504 | return $raw->{'check-requirements'} ?? true; |
||
1505 | } |
||
1506 | |||
1507 | private static function retrievePhpScoperConfig(stdClass $raw, string $basePath): PhpScoperConfiguration |
||
1508 | { |
||
1509 | if (!isset($raw->{'php-scoper'})) { |
||
1510 | $configFilePath = make_path_absolute(self::PHP_SCOPER_CONFIG, $basePath); |
||
1511 | |||
1512 | return file_exists($configFilePath) |
||
1513 | ? PhpScoperConfiguration::load($configFilePath) |
||
1514 | : PhpScoperConfiguration::load() |
||
1515 | ; |
||
1516 | } |
||
1517 | |||
1518 | $configFile = $raw->phpScoper; |
||
1519 | |||
1520 | Assertion::string($configFile); |
||
1521 | |||
1522 | $configFilePath = make_path_absolute($configFile, $basePath); |
||
1523 | |||
1524 | Assertion::file($configFilePath); |
||
1525 | Assertion::readable($configFilePath); |
||
1526 | |||
1527 | return PhpScoperConfiguration::load($configFilePath); |
||
1528 | } |
||
1529 | |||
1530 | /** |
||
1531 | * Runs a Git command on the repository. |
||
1532 | * |
||
1533 | * @param string $command the command |
||
1534 | * |
||
1535 | * @return string the trimmed output from the command |
||
1536 | */ |
||
1537 | private static function runGitCommand(string $command, string $file): string |
||
1538 | { |
||
1539 | $path = dirname($file); |
||
1540 | |||
1541 | $process = new Process($command, $path); |
||
1542 | |||
1543 | if (0 === $process->run()) { |
||
1544 | return trim($process->getOutput()); |
||
1545 | } |
||
1546 | |||
1547 | throw new RuntimeException( |
||
1548 | sprintf( |
||
1549 | 'The tag or commit hash could not be retrieved from "%s": %s', |
||
1550 | $path, |
||
1551 | $process->getErrorOutput() |
||
1552 | ) |
||
1553 | ); |
||
1554 | } |
||
1555 | |||
1556 | private static function createPhpCompactor(stdClass $raw): Compactor |
||
1568 | } |
||
1569 | } |
||
1570 |