Puli\Manager\Installer\ModuleFileInstallerManager

Complexity

Total Complexity

74

Size/Duplication

Total Lines	487
Duplicated Lines	16.63 %

Coupling/Cohesion

Components	1
Dependencies	11

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

24 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
B	addRootInstallerDescriptor()	6	33	6
C	removeRootInstallerDescriptor()	7	33	7
B	removeRootInstallerDescriptors()	0	24	4
A	clearRootInstallerDescriptors()	0	4	1
A	getRootInstallerDescriptor()	0	10	2
A	getRootInstallerDescriptors()	0	6	1
A	findRootInstallerDescriptors()	14	14	3
A	hasRootInstallerDescriptor()	0	6	1
A	hasRootInstallerDescriptors()	16	16	4
A	getInstallerDescriptor()	0	10	2
A	getInstallerDescriptors()	0	6	1
A	findInstallerDescriptors()	14	14	3
A	hasInstallerDescriptor()	0	6	1
A	hasInstallerDescriptors()	16	16	4
A	assertInstallersLoaded()	0	16	4
A	persistInstallersData()	0	14	3
C	loadInstallers()	8	43	7
A	dataToInstaller()	0	15	3
A	dataToParameters()	0	10	2
B	dataToParameter()	0	11	5
A	installerToData()	0	16	3
A	parametersToData()	0	10	2
A	parameterToData()	0	18	4

<?php

/*
 * This file is part of the puli/manager package.
 *
 * (c) Bernhard Schussek <bschussek@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Puli\Manager\Installer;

use Exception;
use Puli\Manager\Api\Installer\InstallerDescriptor;
use Puli\Manager\Api\Installer\InstallerManager;
use Puli\Manager\Api\Installer\InstallerParameter;
use Puli\Manager\Api\Installer\NoSuchInstallerException;
use Puli\Manager\Api\Module\Module;
use Puli\Manager\Api\Module\ModuleCollection;
use Puli\Manager\Api\Module\RootModule;
use Puli\Manager\Api\Module\RootModuleFileManager;
use RuntimeException;
use stdClass;
use Webmozart\Expression\Expr;
use Webmozart\Expression\Expression;
use Webmozart\Json\JsonValidator;
use Webmozart\Json\ValidationFailedException;

/**
 * An installer manager that stores the installers in the module file.
 *
 * @since  1.0
 *
 * @author Bernhard Schussek <bschussek@gmail.com>
 */
class ModuleFileInstallerManager implements InstallerManager
{
    /**
     * The extra key that stores the installer data.
     */
    const INSTALLERS_KEY = 'installers';

    /**
     * @var array
     */
    private static $builtinInstallers = array(
        'copy' => array(
            'class' => 'Puli\Manager\Installer\CopyInstaller',
            'description' => 'Copies assets to a target directory',
        ),
        'symlink' => array(
            'class' => 'Puli\Manager\Installer\SymlinkInstaller',
            'description' => 'Creates asset symlinks in a target directory',
            'parameters' => array(
                'relative' => array(
                    'default' => true,
                    'description' => 'Whether to create relative or absolute links',
                ),
            ),
        ),
    );

    /**
     * @var RootModuleFileManager
     */
    private $rootModuleFileManager;

    /**
     * @var ModuleCollection
     */
    private $modules;

    /**
     * @var RootModule
     */
    private $rootModule;

    /**
     * @var InstallerDescriptor[]
     */
    private $installerDescriptors;

    /**
     * @var InstallerDescriptor[]
     */
    private $rootInstallerDescriptors;

    public function __construct(RootModuleFileManager $rootModuleFileManager, ModuleCollection $modules)
    {
        $this->rootModuleFileManager = $rootModuleFileManager;
        $this->modules = $modules;
        $this->rootModule = $modules->getRootModule();
    }

    /**
     * {@inheritdoc}
     */
    public function addRootInstallerDescriptor(InstallerDescriptor $descriptor)
    {
        $this->assertInstallersLoaded();

        $name = $descriptor->getName();

        $previouslySetInRoot = isset($this->rootInstallerDescriptors[$name]);
        $previousInstaller = $previouslySetInRoot ? $this->rootInstallerDescriptors[$name] : null;

        if (isset($this->installerDescriptors[$name]) && !$previouslySetInRoot) {

This code seems to be duplicated across your project.

            throw new RuntimeException(sprintf(
                'An installer with the name "%s" exists already.',
                $name
            ));
        }

        try {
            $this->installerDescriptors[$name] = $descriptor;
            $this->rootInstallerDescriptors[$name] = $descriptor;

            $this->persistInstallersData();
        } catch (Exception $e) {
            if ($previouslySetInRoot) {
                $this->installerDescriptors[$name] = $previousInstaller;
                $this->rootInstallerDescriptors[$name] = $previousInstaller;
            } else {
                unset($this->installerDescriptors[$name]);
                unset($this->rootInstallerDescriptors[$name]);
            }

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function removeRootInstallerDescriptor($name)
    {
        $this->assertInstallersLoaded();

        $previouslySetInRoot = isset($this->rootInstallerDescriptors[$name]);
        $previousInstaller = $previouslySetInRoot ? $this->rootInstallerDescriptors[$name] : null;

        if (isset($this->installerDescriptors[$name]) && !$previouslySetInRoot) {

This code seems to be duplicated across your project.

            throw new RuntimeException(sprintf(
                'Cannot remove installer "%s": Can only remove installers '.
                'configured in the root module.',
                $name
            ));
        }

        if (!$previouslySetInRoot) {
            return;
        }

        try {
            unset($this->installerDescriptors[$name]);
            unset($this->rootInstallerDescriptors[$name]);

            $this->persistInstallersData();
        } catch (Exception $e) {
            if ($previouslySetInRoot) {
                $this->installerDescriptors[$name] = $previousInstaller;
                $this->rootInstallerDescriptors[$name] = $previousInstaller;
            }

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function removeRootInstallerDescriptors(Expression $expr)
    {
        $this->assertInstallersLoaded();

        $previousInstallers = $this->rootInstallerDescriptors;
        $previousRootInstallers = $this->rootInstallerDescriptors;

        try {
            // Only remove root installers
            foreach ($previousRootInstallers as $installer) {
                if ($expr->evaluate($installer)) {
                    unset($this->installerDescriptors[$installer->getName()]);
                    unset($this->rootInstallerDescriptors[$installer->getName()]);
                }
            }

            $this->persistInstallersData();
        } catch (Exception $e) {
            $this->installerDescriptors = $previousInstallers;
            $this->rootInstallerDescriptors = $previousRootInstallers;

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function clearRootInstallerDescriptors()
    {
        $this->removeRootInstallerDescriptors(Expr::true());
    }

    /**
     * {@inheritdoc}
     */
    public function getRootInstallerDescriptor($name)
    {
        $this->assertInstallersLoaded();

        if (!isset($this->rootInstallerDescriptors[$name])) {
            throw NoSuchInstallerException::forInstallerNameAndModuleName($name, $this->rootModule->getName());
        }

        return $this->rootInstallerDescriptors[$name];
    }

    /**
     * {@inheritdoc}
     */
    public function getRootInstallerDescriptors()
    {
        $this->assertInstallersLoaded();

        return $this->rootInstallerDescriptors;
    }

    /**
     * {@inheritdoc}
     */
    public function findRootInstallerDescriptors(Expression $expr)

This method seems to be duplicated in your project.

    {
        $this->assertInstallersLoaded();

        $installers = array();

        foreach ($this->rootInstallerDescriptors as $installer) {
            if ($expr->evaluate($installer)) {
                $installers[] = $installer;
            }
        }

        return $installers;
    }

    /**
     * {@inheritdoc}
     */
    public function hasRootInstallerDescriptor($name)
    {
        $this->assertInstallersLoaded();

        return isset($this->rootInstallerDescriptors[$name]);
    }

    /**
     * {@inheritdoc}
     */
    public function hasRootInstallerDescriptors(Expression $expr = null)

This method seems to be duplicated in your project.

    {
        $this->assertInstallersLoaded();

        if (!$expr) {
            return count($this->rootInstallerDescriptors) > 0;
        }

        foreach ($this->rootInstallerDescriptors as $installer) {
            if ($expr->evaluate($installer)) {
                return true;
            }
        }

        return false;
    }

    /**
     * {@inheritdoc}
     */
    public function getInstallerDescriptor($name)
    {
        $this->assertInstallersLoaded();

        if (!isset($this->installerDescriptors[$name])) {
            throw NoSuchInstallerException::forInstallerName($name);
        }

        return $this->installerDescriptors[$name];
    }

    /**
     * {@inheritdoc}
     */
    public function getInstallerDescriptors()
    {
        $this->assertInstallersLoaded();

        return $this->installerDescriptors;
    }

    /**
     * {@inheritdoc}
     */
    public function findInstallerDescriptors(Expression $expr)

This method seems to be duplicated in your project.

    {
        $this->assertInstallersLoaded();

        $installers = array();

        foreach ($this->installerDescriptors as $installer) {
            if ($expr->evaluate($installer)) {
                $installers[] = $installer;
            }
        }

        return $installers;
    }

    /**
     * {@inheritdoc}
     */
    public function hasInstallerDescriptor($name)
    {
        $this->assertInstallersLoaded();

        return isset($this->installerDescriptors[$name]);
    }

    /**
     * {@inheritdoc}
     */
    public function hasInstallerDescriptors(Expression $expr = null)

This method seems to be duplicated in your project.

    {
        $this->assertInstallersLoaded();

        if (!$expr) {
            return count($this->installerDescriptors) > 0;
        }

        foreach ($this->installerDescriptors as $installer) {
            if ($expr->evaluate($installer)) {
                return true;
            }
        }

        return false;
    }

    private function assertInstallersLoaded()
    {
        if (null !== $this->installerDescriptors) {
            return;
        }

        $this->installerDescriptors = array();

        foreach ($this->modules as $module) {
            if ($this->rootModule !== $module) {
                $this->loadInstallers($module);
            }
        }

        $this->loadInstallers($this->rootModule);
    }

    private function persistInstallersData()
    {
        $data = array();

        foreach ($this->rootInstallerDescriptors as $installerName => $installer) {
            $data[$installerName] = $this->installerToData($installer);
        }

        if ($data) {

The expression $data of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $this->rootModuleFileManager->setExtraKey(self::INSTALLERS_KEY, (object) $data);
        } else {
            $this->rootModuleFileManager->removeExtraKey(self::INSTALLERS_KEY);
        }
    }

    private function loadInstallers(Module $module)
    {
        foreach (self::$builtinInstallers as $name => $installerData) {
            $installer = $this->dataToInstaller($name, (object) $installerData);

            $this->installerDescriptors[$name] = $installer;
        }

        $moduleFile = $module->getModuleFile();

        if (null === $moduleFile) {
            return;
        }

        $moduleName = $module->getName();
        $installersData = $moduleFile->getExtraKey(self::INSTALLERS_KEY);

        if (!$installersData) {
            return;
        }

        $jsonValidator = new JsonValidator();
        $errors = $jsonValidator->validate($installersData, __DIR__.'/../../res/schema/installers-schema-1.0.json');

        if (count($errors) > 0) {

This code seems to be duplicated across your project.

            throw new ValidationFailedException(sprintf(
                "The extra key \"%s\" of module \"%s\" is invalid:\n%s",
                self::INSTALLERS_KEY,
                $moduleName,
                implode("\n", $errors)
            ));
        }

        foreach ($installersData as $name => $installerData) {
            $installer = $this->dataToInstaller($name, $installerData);

            $this->installerDescriptors[$name] = $installer;

            if ($module instanceof RootModule) {
                $this->rootInstallerDescriptors[$name] = $installer;
            }
        }
    }

    private function dataToInstaller($installerName, stdClass $installerData)
    {
        $parameters = array();

        if (isset($installerData->parameters)) {
            $parameters = $this->dataToParameters((object) $installerData->parameters);
        }

        return new InstallerDescriptor(
            $installerName,
            $installerData->class,
            isset($installerData->description) ? $installerData->description : null,
            $parameters
        );
    }

    private function dataToParameters(stdClass $parametersData)
    {
        $parameters = array();

        foreach ($parametersData as $parameterName => $parameterData) {

The expression $parametersData of type object<stdClass> is not traversable.

            $parameters[$parameterName] = $this->dataToParameter($parameterName, (object) $parameterData);
        }

        return $parameters;
    }

    private function dataToParameter($parameterName, stdClass $parameterData)
    {
        return new InstallerParameter(
            $parameterName,
            isset($parameterData->required) && $parameterData->required
                ? InstallerParameter::REQUIRED
                : InstallerParameter::OPTIONAL,
            isset($parameterData->default) ? $parameterData->default : null,
            isset($parameterData->description) ? $parameterData->description : null
        );
    }

    /**
     * Extracting an object containing the data from an installer descriptor.
     *
     * @param InstallerDescriptor $installer The installer descriptor.
     *
     * @return stdClass
     */
    private function installerToData(InstallerDescriptor $installer)
    {
        $data = (object) array(
            'class' => $installer->getClassName(),
        );

        if ($installer->getDescription()) {

The expression $installer->getDescription() of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $data->description = $installer->getDescription();
        }

        if ($installer->getParameters()) {
            $data->parameters = $this->parametersToData($installer->getParameters());
        }

        return $data;
    }

    /**
     * @param InstallerParameter[] $parameters
     *
     * @return array
     */
    private function parametersToData(array $parameters)
    {
        $data = array();

        foreach ($parameters as $parameter) {
            $data[$parameter->getName()] = $this->parameterToData($parameter);
        }

        return (object) $data;
    }

    private function parameterToData(InstallerParameter $parameter)
    {
        $data = new stdClass();

        if ($parameter->isRequired()) {
            $data->required = true;
        }

        if (null !== $default = $parameter->getDefaultValue()) {
            $data->default = $default;
        }

        if ($description = $parameter->getDescription()) {
            $data->description = $description;
        }

        return $data;
    }
}