Package.php

Go to the documentation of this file.

<?php
namespace TYPO3\Flow\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!                         *
 *                                                                        */

use TYPO3\Flow\Utility\Files;

class Package implements PackageInterface {

    protected $packageKey;

    protected $manifestPath;

    protected $packagePath;

    protected $classesPath;

    protected $protected = FALSE;

    protected $composerManifest;

    protected $packageMetaData;

    protected $classFiles;

    protected $namespace;

    protected $objectManagementEnabled = TRUE;

    protected $packageManager;

    public function __construct(\TYPO3\Flow\Package\PackageManager $packageManager, $packageKey, $packagePath, $classesPath = NULL, $manifestPath = '') {
        if (preg_match(self::PATTERN_MATCH_PACKAGEKEY, $packageKey) !== 1) {
            throw new \TYPO3\Flow\Package\Exception\InvalidPackageKeyException('"' . $packageKey . '" is not a valid package key.', 1217959510);
        }
        if (!(is_dir($packagePath) || (Files::is_link($packagePath) && is_dir(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), 1166631889);
        }
        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), 1166633720);
        }
        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), 1334841320);
        }
        if (!file_exists($packagePath . $manifestPath . 'composer.json')) {
            throw new \TYPO3\Flow\Package\Exception\InvalidPackageManifestException(sprintf('No composer manifest file found for package "%s". Please create one at "%scomposer.json".', $packageKey, $manifestPath), 1349776393);
        }

        $this->packageManager = $packageManager;
        $this->manifestPath = $manifestPath;
        $this->packageKey = $packageKey;
        $this->packagePath = Files::getNormalizedPath($packagePath);
        if (isset($this->getComposerManifest()->autoload->{'psr-0'})) {
            $this->classesPath = Files::getNormalizedPath($this->packagePath . $this->getComposerManifest()->autoload->{'psr-0'}->{$this->getNamespace()});
        } else {
            $this->classesPath = Files::getNormalizedPath($this->packagePath . $classesPath);
        }
    }

    public function boot(\TYPO3\Flow\Core\Bootstrap $bootstrap) {
    }

    public function getPackageMetaData() {
        if ($this->packageMetaData === NULL) {
            $this->packageMetaData = new MetaData($this->getPackageKey());
            $this->packageMetaData->setDescription($this->getComposerManifest('description'));
            $this->packageMetaData->setVersion($this->getComposerManifest('version'));
            $requirements = $this->getComposerManifest('require');
            if ($requirements !== NULL) {
                foreach ($requirements as $requirement => $version) {
                    if ($this->packageRequirementIsComposerPackage($requirement) === FALSE) {
                            // Skip non-package requirements
                        continue;
                    }
                    $packageKey = $this->packageManager->getPackageKeyFromComposerName($requirement);
                    $constraint = new MetaData\PackageConstraint(MetaDataInterface::CONSTRAINT_TYPE_DEPENDS, $packageKey);
                    $this->packageMetaData->addConstraint($constraint);
                }
            }

        }
        return $this->packageMetaData;
    }

    protected function packageRequirementIsComposerPackage($requirement) {
        return (strpos($requirement, '/') !== FALSE);
    }

    public function getClassFiles() {
        if (!is_array($this->classFiles)) {
            $this->classFiles = $this->buildArrayOfClassFiles($this->classesPath);
        }
        return $this->classFiles;
    }

    public function getFunctionalTestsClassFiles() {
        return $this->buildArrayOfClassFiles($this->packagePath . self::DIRECTORY_TESTS_FUNCTIONAL, $this->getNamespace() . '\\Tests\\Functional\\');
    }

    public function getPackageKey() {
        return $this->packageKey;
    }

    public function getNamespace() {
        if (!$this->namespace) {
            $manifest = $this->getComposerManifest();
            if (isset($manifest->autoload->{'psr-0'})) {
                $namespaces = (array)$manifest->autoload->{'psr-0'};
                if (count($namespaces) === 1) {
                    $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), 1348053245);
                }
            } else {
                $namespace = str_replace('.', '\\', $this->getPackageKey());
            }
            $this->namespace = $namespace;
        }
        return $this->namespace;
    }

    public function isProtected() {
        return $this->protected;
    }

    public function isObjectManagementEnabled() {
        return $this->objectManagementEnabled;
    }

    public function setProtected($protected) {
        $this->protected = (boolean)$protected;
    }

    public function getPackagePath() {
        return $this->packagePath;
    }

    public function getManifestPath() {
        return $this->packagePath . $this->manifestPath;
    }

    public function getClassesPath() {
        return $this->classesPath;
    }

    public function getClassesNamespaceEntryPath() {
        $pathifiedNamespace = str_replace('\\', '/', $this->getNamespace());
        return Files::getNormalizedPath($this->classesPath . trim($pathifiedNamespace, '/'));
    }

    public function getFunctionalTestsPath() {
        return $this->packagePath . self::DIRECTORY_TESTS_FUNCTIONAL;
    }

    public function getResourcesPath() {
        return $this->packagePath . self::DIRECTORY_RESOURCES;
    }

    public function getConfigurationPath() {
        return $this->packagePath . self::DIRECTORY_CONFIGURATION;
    }

    public function getMetaPath() {
        return $this->packagePath . self::DIRECTORY_METADATA;
    }

    public function getDocumentationPath() {
        return $this->packagePath . self::DIRECTORY_DOCUMENTATION;
    }

    public function getPackageDocumentations() {
        $documentations = array();
        $documentationPath = $this->getDocumentationPath();
        if (is_dir($documentationPath)) {
            $documentationsDirectoryIterator = new \DirectoryIterator($documentationPath);
            $documentationsDirectoryIterator->rewind();
            while ($documentationsDirectoryIterator->valid()) {
                $filename = $documentationsDirectoryIterator->getFilename();
                if ($filename[0] != '.' && $documentationsDirectoryIterator->isDir()) {
                    $filename = $documentationsDirectoryIterator->getFilename();
                    $documentation = new \TYPO3\Flow\Package\Documentation($this, $filename, $documentationPath . $filename . '/');
                    $documentations[$filename] = $documentation;
                }
                $documentationsDirectoryIterator->next();
            }
        }
        return $documentations;
    }

    public function getComposerManifest($key = NULL) {
        if (!isset($this->composerManifest)) {
            $this->composerManifest = PackageManager::getComposerManifest($this->getManifestPath());
        }

        return PackageManager::getComposerManifest($this->getManifestPath(), $key, $this->composerManifest);
    }

    protected function buildArrayOfClassFiles($classesPath, $extraNamespaceSegment = '', $subDirectory = '', $recursionLevel = 0) {
        $classFiles = array();
        $currentPath = $classesPath . $subDirectory;
        $currentRelativePath = substr($currentPath, strlen($this->packagePath));

        if (!is_dir($currentPath)) {
            return array();
        }
        if ($recursionLevel > 100) {
            throw new \TYPO3\Flow\Package\Exception('Recursion too deep.', 1166635495);
        }

        try {
            $classesDirectoryIterator = new \DirectoryIterator($currentPath);
            while ($classesDirectoryIterator->valid()) {
                $filename = $classesDirectoryIterator->getFilename();
                if ($filename[0] != '.') {
                    if (is_dir($currentPath . $filename)) {
                        $classFiles = array_merge($classFiles, $this->buildArrayOfClassFiles($classesPath, $extraNamespaceSegment, $subDirectory . $filename . '/', ($recursionLevel + 1)));
                    } else {
                        if (substr($filename, -4, 4) === '.php') {
                            $className = (str_replace('/', '\\', ($extraNamespaceSegment . substr($currentPath, strlen($classesPath)) . substr($filename, 0, -4))));
                            $classFiles[$className] = $currentRelativePath . $filename;
                        }
                    }
                }
                $classesDirectoryIterator->next();
            }

        } catch (\Exception $exception) {
            throw new \TYPO3\Flow\Package\Exception($exception->getMessage(), 1166633721);
        }
        return $classFiles;
    }

    public function __sleep() {
        $properties = get_class_vars(get_class($this));
        unset($properties['packageManager']);
        return array_keys($properties);
    }

    public function __wakeup() {
        if (isset($GLOBALS['TYPO3_currentPackageManager'])) {
            $this->packageManager = $GLOBALS['TYPO3_currentPackageManager'];
        }
    }
}

?>