Package.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Package;

/*                                                                        *
 * This script belongs to the TYPO3 Flow framework.                       *
 *                                                                        *
 * It is free software; you can redistribute it and/or modify it under    *
 * the terms of the GNU Lesser General Public License, either version 3   *
 * of the License, or (at your option) any later version.                 *
 *                                                                        *
 * The TYPO3 project - inspiring people to share!                         *
 *                                                                        */

class Package extends \TYPO3\Flow\Package\Package implements PackageInterface {

    const PATTERN_MATCH_EXTENSIONKEY = '/^[0-9a-z_-]+$/i';

    protected $extensionManagerConfiguration = array();

    protected $classAliases;

    protected $objectManagementEnabled = NULL;

    protected $ignoredClassNames = array();

    protected $partOfFactoryDefault = FALSE;

    protected $partOfMinimalUsableSystem = FALSE;

    public function __construct(\TYPO3\Flow\Package\PackageManager $packageManager, $packageKey, $packagePath, $classesPath = NULL, $manifestPath = '') {
        if (!$packageManager->isPackageKeyValid($packageKey)) {
            throw new \TYPO3\Flow\Package\Exception\InvalidPackageKeyException('"' . $packageKey . '" is not a valid package key.', 1217959511);
        }
        if (!(@is_dir($packagePath) || (\TYPO3\Flow\Utility\Files::is_link($packagePath) && is_dir(\TYPO3\Flow\Utility\Files::getNormalizedPath($packagePath))))) {
            throw new \TYPO3\Flow\Package\Exception\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 (substr($packagePath, -1, 1) !== '/') {
            throw new \TYPO3\Flow\Package\Exception\InvalidPackagePathException(sprintf('The package path "%s" provided for package "%s" has no trailing forward slash.', $packagePath, $packageKey), 1166633722);
        }
        if ($classesPath[1] === '/') {
            throw new \TYPO3\Flow\Package\Exception\InvalidPackagePathException(sprintf('The package classes path provided for package "%s" has a leading forward slash.', $packageKey), 1334841321);
        }
        if (!@file_exists($packagePath . $manifestPath . 'ext_emconf.php')) {
            throw new \TYPO3\Flow\Package\Exception\InvalidPackageManifestException(sprintf('No ext_emconf file found for package "%s". Please create one at "%sext_emconf.php".', $packageKey, $manifestPath), 1360403545);
        }
        $this->packageManager = $packageManager;
        $this->manifestPath = $manifestPath;
        $this->packageKey = $packageKey;
        $this->packagePath = \TYPO3\Flow\Utility\Files::getNormalizedPath($packagePath);
        $this->classesPath = \TYPO3\Flow\Utility\Files::getNormalizedPath(\TYPO3\Flow\Utility\Files::concatenatePaths(array($this->packagePath, self::DIRECTORY_CLASSES)));
        try {
            $this->getComposerManifest();
        } catch (\TYPO3\Flow\Package\Exception\MissingPackageManifestException $exception) {
            $this->getExtensionEmconf($packageKey, $this->packagePath);
        }
        $this->loadFlagsFromComposerManifest();
        if ($this->objectManagementEnabled === NULL) {
            $this->objectManagementEnabled = FALSE;
        }
    }

    protected function loadFlagsFromComposerManifest() {
        $extraFlags = $this->getComposerManifest('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;
                }
            }
        }
    }

    public function isPartOfFactoryDefault() {
        return $this->partOfFactoryDefault;
    }

    public function isPartOfMinimalUsableSystem() {
        return $this->partOfMinimalUsableSystem;
    }

    protected function getExtensionEmconf() {
        $_EXTKEY = $this->packageKey;
        $path = $this->packagePath . '/ext_emconf.php';
        $EM_CONF = NULL;
        if (@file_exists($path)) {
            include $path;
            if (is_array($EM_CONF[$_EXTKEY])) {
                $this->extensionManagerConfiguration = $EM_CONF[$_EXTKEY];
                $this->mapExtensionManagerConfigurationToComposerManifest();
            }
        }
        return FALSE;
    }

    protected function mapExtensionManagerConfigurationToComposerManifest() {
        if (is_array($this->extensionManagerConfiguration)) {
            $extensionManagerConfiguration = $this->extensionManagerConfiguration;
            $composerManifest = $this->composerManifest = new \stdClass();
            $composerManifest->name = $this->getPackageKey();
            $composerManifest->type = 'typo3-cms-extension';
            $composerManifest->description = $extensionManagerConfiguration['title'];
            $composerManifest->version = $extensionManagerConfiguration['version'];
            if (isset($extensionManagerConfiguration['constraints']['depends']) && is_array($extensionManagerConfiguration['constraints']['depends'])) {
                $composerManifest->require = new \stdClass();
                foreach ($extensionManagerConfiguration['constraints']['depends'] as $requiredPackageKey => $requiredPackageVersion) {
                    if (!empty($requiredPackageKey)) {
                        $composerManifest->require->$requiredPackageKey = $requiredPackageVersion;
                    } else {
                        // TODO: throw meaningful exception or fail silently?
                    }
                }
            }
            if (isset($extensionManagerConfiguration['constraints']['conflicts']) && is_array($extensionManagerConfiguration['constraints']['conflicts'])) {
                $composerManifest->conflict = new \stdClass();
                foreach ($extensionManagerConfiguration['constraints']['conflicts'] as $conflictingPackageKey => $conflictingPackageVersion) {
                    if (!empty($conflictingPackageKey)) {
                        $composerManifest->conflict->$conflictingPackageKey = $conflictingPackageVersion;
                    } else {
                        // TODO: throw meaningful exception or fail silently?
                    }
                }
            }
            if (isset($extensionManagerConfiguration['constraints']['suggests']) && is_array($extensionManagerConfiguration['constraints']['suggests'])) {
                $composerManifest->suggest = new \stdClass();
                foreach ($extensionManagerConfiguration['constraints']['suggests'] as $suggestedPackageKey => $suggestedPackageVersion) {
                    if (!empty($suggestedPackageKey)) {
                        $composerManifest->suggest->$suggestedPackageKey = $suggestedPackageVersion;
                    } else {
                        // TODO: throw meaningful exception or fail silently?
                    }
                }
            }
        }
    }

    public function getPackageMetaData() {
        if ($this->packageMetaData === NULL) {
            parent::getPackageMetaData();

            // Fallback to retrieve the version number from ext_emconf.php
            // in case no version was found in the composer.json manifest.
            $version = $this->packageMetaData->getVersion();
            if (empty($version)) {
                $_EXTKEY = $this->packageKey; // required to resolve $EM_CONF[$_EXTKEY] in ext_emconf.php
                $path = $this->packagePath . 'ext_emconf.php';
                if (@file_exists($path)) {
                    include $path;
                    if (isset($EM_CONF[$_EXTKEY]['version'])) {
                        $this->packageMetaData->setVersion($EM_CONF[$_EXTKEY]['version']);
                    }
                }
            }

            $suggestions = $this->getComposerManifest('suggest');
            if ($suggestions !== NULL) {
                foreach ($suggestions as $suggestion => $version) {
                    if ($this->packageRequirementIsComposerPackage($suggestion) === FALSE) {
                        // Skip non-package requirements
                        continue;
                    }
                    $packageKey = $this->packageManager->getPackageKeyFromComposerName($suggestion);
                    $constraint = new \TYPO3\Flow\Package\MetaData\PackageConstraint(\TYPO3\Flow\Package\MetaDataInterface::CONSTRAINT_TYPE_SUGGESTS, $packageKey);
                    $this->packageMetaData->addConstraint($constraint);
                }
            }
        }
        return $this->packageMetaData;
    }

    public function getPackageReplacementKeys() {
        // The cast to array is required since the manifest returns data with type mixed
        return (array)$this->getComposerManifest('replace') ?: array();
    }

    public function getNamespace() {
        if(!$this->namespace) {
            $manifest = $this->getComposerManifest();
            if (isset($manifest->autoload->{'psr-0'})) {
                $namespaces = $manifest->autoload->{'psr-0'};
                if (count($namespaces) === 1) {
                    $this->namespace = key($namespaces);
                } else {
                    throw new \TYPO3\Flow\Package\Exception\InvalidPackageStateException(sprintf('The Composer manifest of package "%s" contains multiple namespace definitions in its autoload section but Flow does only support one namespace per package.', $this->packageKey), 1348053246);
                }
            } else {
                $packageKey = $this->getPackageKey();
                if (strpos($packageKey, '.') === FALSE) {
                    // Old school with unknown vendor name
                    $this->namespace =  '*\\' . \TYPO3\CMS\Core\Utility\GeneralUtility::underscoredToUpperCamelCase($packageKey);
                } else {
                    $this->namespace = str_replace('.', '\\', $packageKey);
                }
            }
        }
        return $this->namespace;
    }

    public function getClassFiles() {
        if (!is_array($this->classFiles)) {
            $this->classFiles = $this->filterClassFiles($this->buildArrayOfClassFiles($this->classesPath . '/', $this->namespace . '\\'));
        }
        return $this->classFiles;
    }

    protected function filterClassFiles(array $classFiles) {
        $classesNotMatchingClassRule = array_filter(array_keys($classFiles), function($className) {
            return preg_match('/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\\\x7f-\xff]*$/', $className) !== 1;
        });
        foreach ($classesNotMatchingClassRule as $forbiddenClassName) {
            unset($classFiles[$forbiddenClassName]);
        }
        foreach ($this->ignoredClassNames as $ignoredClassName) {
            if (isset($classFiles[$ignoredClassName])) {
                unset($classFiles[$ignoredClassName]);
            }
        }
        return $classFiles;
    }

    public function getClassFilesFromAutoloadRegistry() {
        $autoloadRegistryPath = $this->packagePath . 'ext_autoload.php';
        if (@file_exists($autoloadRegistryPath)) {
            return require $autoloadRegistryPath;
        }
        return array();
    }

    public function getClassAliases() {
        if (!is_array($this->classAliases)) {
            try {
                $extensionClassAliasMapPathAndFilename = \TYPO3\Flow\Utility\Files::concatenatePaths(array(
                    $this->getPackagePath(),
                    'Migrations/Code/ClassAliasMap.php'
                ));
                if (@file_exists($extensionClassAliasMapPathAndFilename)) {
                    $this->classAliases = require $extensionClassAliasMapPathAndFilename;
                }
            } catch (\BadFunctionCallException $e) {
            }
            if (!is_array($this->classAliases)) {
                $this->classAliases = array();
            }
        }
        return $this->classAliases;
    }

    protected function packageRequirementIsComposerPackage($requirement) {
        // According to http://getcomposer.org/doc/02-libraries.md#platform-packages
        // the following regex should capture all non composer requirements.
        // typo3 is included in the list because it's a meta package and not supported for now.
        // typo3/cms is included since it's basically a container and cannot be detected at runtime.
        // composer/installers is included until extensionmanager can handle composer packages natively
        return preg_match('/^(php(-64bit)?|ext-[^\/]+|lib-(curl|iconv|libxml|openssl|pcre|uuid|xsl)|typo3|typo3\/cms|composer\/installers)$/', $requirement) !== 1;
    }


}