Package.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Core\Package;
 
use Composer\Util\Filesystem;
use ‪TYPO3\CMS\Core\Core\Environment;
use ‪TYPO3\CMS\Core\Package\Exception\InvalidPackageKeyException;
use ‪TYPO3\CMS\Core\Package\Exception\InvalidPackagePathException;
use ‪TYPO3\CMS\Core\Package\MetaData\PackageConstraint;
 
class ‪Package implements ‪PackageInterface
{
    protected bool ‪$partOfFactoryDefault = false;
 
    protected bool ‪$partOfMinimalUsableSystem = false;
 
    protected ?string ‪$serviceProvider;
 
    protected string ‪$packageKey;
 
    protected string ‪$packagePath;
 
    protected bool ‪$isRelativePackagePath = false;
 
    protected bool ‪$protected = false;
 
    protected ?\stdClass ‪$composerManifest;
 
    protected ‪MetaData ‪$packageMetaData;
 
    public function ‪__construct(PackageManager $packageManager, string ‪$packageKey, string ‪$packagePath, bool $ignoreExtEmConf = false)
    {
        if (!$packageManager->isPackageKeyValid(‪$packageKey)) {
            throw new ‪InvalidPackageKeyException('"' . ‪$packageKey . '" is not a valid package key.', 1217959511);
        }
        if (!(@is_dir(‪$packagePath) || (is_link(‪$packagePath) && is_dir(‪$packagePath)))) {
            throw new ‪InvalidPackagePathException(sprintf('Tried to instantiate a package object for package "%s" with a non-existing package path "%s". Either the package does not exist anymore, or the code creating this object contains an error.', ‪$packageKey, ‪$packagePath), 1166631890);
        }
        if (!str_ends_with(‪$packagePath, '/')) {
            throw new ‪InvalidPackagePathException(sprintf('The package path "%s" provided for package "%s" has no trailing forward slash.', ‪$packagePath, ‪$packageKey), 1166633722);
        }
        $this->packageKey = ‪$packageKey;
        $this->packagePath = ‪$packagePath;
        $this->composerManifest = $packageManager->getComposerManifest($this->packagePath, $ignoreExtEmConf);
        $this->‪loadFlagsFromComposerManifest();
        $this->‪createPackageMetaData($packageManager);
    }
 
    protected function ‪loadFlagsFromComposerManifest(): void
    {
        $extraFlags = $this->‪getValueFromComposerManifest('extra');
        if ($extraFlags !== null && isset($extraFlags->{'typo3/cms'}->{'Package'})) {
            foreach ($extraFlags->{'typo3/cms'}->{'Package'} as $flagName => $flagValue) {
                if (property_exists($this, $flagName)) {
                    $this->{$flagName} = $flagValue;
                }
            }
        }
    }
 
    protected function ‪createPackageMetaData(PackageManager $packageManager): void
    {
        $this->packageMetaData = new ‪MetaData($this->getPackageKey());
        $description = (string)$this->getValueFromComposerManifest('description');
        $this->packageMetaData->setDescription($description);
        $this->packageMetaData->setTitle($this->getValueFromComposerManifest('title') ?? $description);
        $this->packageMetaData->setVersion((string)$this->getValueFromComposerManifest('version'));
        $this->packageMetaData->setPackageType((string)$this->getValueFromComposerManifest('type'));
        $requirements = $this->getValueFromComposerManifest('require');
        if ($requirements !== null) {
            foreach ($requirements as $requirement => $version) {
                $packageKey = $packageManager->getPackageKeyFromComposerName($requirement);
                $constraint = new ‪PackageConstraint(MetaData::CONSTRAINT_TYPE_DEPENDS, $packageKey);
                $this->packageMetaData->addConstraint($constraint);
            }
        }
        $suggestions = $this->getValueFromComposerManifest('suggest');
        if ($suggestions !== null) {
            foreach ($suggestions as $suggestion => $version) {
                $packageKey = $packageManager->getPackageKeyFromComposerName($suggestion);
                $constraint = new ‪PackageConstraint(MetaData::CONSTRAINT_TYPE_SUGGESTS, $packageKey);
                $this->packageMetaData->addConstraint($constraint);
            }
        }
    }
 
    public function ‪getServiceProvider(): string
    {
        return $this->serviceProvider ?? PseudoServiceProvider::class;
    }
 
    public function ‪isPartOfFactoryDefault(): bool
    {
        return $this->partOfFactoryDefault;
    }
 
    public function ‪isPartOfMinimalUsableSystem(): bool
    {
        return $this->partOfMinimalUsableSystem;
    }
 
    public function ‪getPackageKey(): string
    {
        return $this->packageKey;
    }
 
    public function ‪isProtected(): bool
    {
        return $this->protected;
    }
 
    public function ‪setProtected(bool $protected): void
    {
        $this->protected = (bool)$protected;
    }
 
    public function ‪getPackagePath(): string
    {
        if (!$this->isRelativePackagePath) {
            return $this->packagePath;
        }
        $this->isRelativePackagePath = false;
 
        return $this->packagePath = Environment::getComposerRootPath() . '/' . $this->packagePath;
    }
 
    public function ‪makePathRelative(Filesystem $filesystem, string $composerRootPath): void
    {
        $this->isRelativePackagePath = true;
        $this->packagePath = ($composerRootPath . '/') === $this->packagePath ? '' : $filesystem->findShortestPath($composerRootPath, $this->packagePath, true) . '/';
    }
 
    public function ‪getPackageMetaData(): ‪MetaData
    {
        return $this->packageMetaData;
    }
 
    public function ‪getPackageReplacementKeys(): array
    {
        // The cast to array is required since the manifest returns data with type mixed
        return (array)$this->getValueFromComposerManifest('replace') ?: [];
    }
 
    public function ‪getValueFromComposerManifest($key = null): mixed
    {
        if ($key === null) {
            return $this->composerManifest;
        }
 
        if (isset($this->composerManifest->{$key})) {
            $value = $this->composerManifest->{$key};
        } else {
            $value = null;
        }
        return $value;
    }
 
    public function ‪getPackageIcon(): ?string
    {
        $resourcePath = 'Resources/Public/Icons/Extension.';
        foreach (['svg', 'png', 'gif'] as $fileExtension) {
            if (file_exists($this->getPackagePath() . $resourcePath . $fileExtension)) {
                return $resourcePath . $fileExtension;
            }
        }
        return null;
    }
}