Puli\Manager\Module\RootModuleFileManagerImpl

Complexity

Total Complexity

75

Size/Duplication

Total Lines	486
Duplicated Lines	34.77 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

98.47%

Importance

Changes	1
Bugs	0	Features	0

27 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getConfig()	0	4	1
A	getContext()	0	4	1
A	getModuleFile()	0	4	1
A	getModuleName()	0	4	1
A	setModuleName()	18	18	3
A	addPluginClass()	21	21	3
A	removePluginClass()	0	18	3
B	removePluginClasses()	24	24	5
A	clearPluginClasses()	0	4	1
A	hasPluginClass()	0	4	1
A	hasPluginClasses()	14	14	4
A	getPluginClasses()	0	4	1
A	findPluginClasses()	0	12	3
B	setExtraKey()	0	23	4
D	setExtraKeys()	0	35	9
A	removeExtraKey()	18	18	3
B	removeExtraKeys()	24	24	5
A	clearExtraKeys()	18	18	3
A	hasExtraKey()	0	4	1
A	hasExtraKeys()	14	14	4
A	getExtraKey()	0	4	1
A	getExtraKeys()	0	4	1
A	findExtraKeys()	0	12	3
A	migrate()	18	18	3
A	saveConfigFile()	0	4	1
C	validatePluginClass()	0	42	8

<?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\Module;

use Exception;
use InvalidArgumentException;
use Puli\Manager\Api\Context\ProjectContext;
use Puli\Manager\Api\Module\RootModuleFile;
use Puli\Manager\Api\Module\RootModuleFileManager;
use Puli\Manager\Config\AbstractConfigManager;
use ReflectionClass;
use ReflectionException;
use Webmozart\Expression\Expr;
use Webmozart\Expression\Expression;

/**
 * Manages changes to the root module file.
 *
 * Use this class to make persistent changes to the puli.json of a project.
 * Whenever you call methods in this class, the changes will be written to disk.
 *
 * @since  1.0
 *
 * @author Bernhard Schussek <bschussek@gmail.com>
 */
class RootModuleFileManagerImpl extends AbstractConfigManager implements RootModuleFileManager
{
    /**
     * @var ProjectContext
     */
    private $context;

    /**
     * @var RootModuleFile
     */
    private $rootModuleFile;

    /**
     * @var ModuleFileStorage
     */
    private $moduleFileStorage;

    /**
     * Creates a new module file manager.
     *
     * @param ProjectContext    $context           The project context
     * @param ModuleFileStorage $moduleFileStorage The module file storage.
     */
    public function __construct(ProjectContext $context, ModuleFileStorage $moduleFileStorage)
    {
        $this->context = $context;
        $this->rootModuleFile = $context->getRootModuleFile();
        $this->moduleFileStorage = $moduleFileStorage;
    }

    /**
     * {@inheritdoc}
     */
    public function getConfig()
    {
        return $this->rootModuleFile->getConfig();
    }

    /**
     * {@inheritdoc}
     */
    public function getContext()
    {
        return $this->context;
    }

    /**
     * {@inheritdoc}
     */
    public function getModuleFile()
    {
        return $this->rootModuleFile;
    }

    /**
     * {@inheritdoc}
     */
    public function getModuleName()
    {
        return $this->rootModuleFile->getModuleName();
    }

    /**
     * {@inheritdoc}
     */
    public function setModuleName($moduleName)

This method seems to be duplicated in your project.

    {
        if ($moduleName === $this->rootModuleFile->getModuleName()) {
            return;
        }

        $previousName = $this->rootModuleFile->getModuleName();

        $this->rootModuleFile->setModuleName($moduleName);

        try {
            $this->moduleFileStorage->saveRootModuleFile($this->rootModuleFile);
        } catch (Exception $e) {
            $this->rootModuleFile->setModuleName($previousName);

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function addPluginClass($pluginClass)

This method seems to be duplicated in your project.

    {
        if ($this->rootModuleFile->hasPluginClass($pluginClass)) {
            // Already installed locally
            return;
        }

        $this->validatePluginClass($pluginClass);

        $previousClasses = $this->rootModuleFile->getPluginClasses();

        $this->rootModuleFile->addPluginClass($pluginClass);

        try {
            $this->moduleFileStorage->saveRootModuleFile($this->rootModuleFile);
        } catch (Exception $e) {
            $this->rootModuleFile->setPluginClasses($previousClasses);

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function removePluginClass($pluginClass)
    {
        if (!$this->rootModuleFile->hasPluginClass($pluginClass)) {
            return;
        }

        $previousClasses = $this->rootModuleFile->getPluginClasses();

        $this->rootModuleFile->removePluginClass($pluginClass);

        try {
            $this->moduleFileStorage->saveRootModuleFile($this->rootModuleFile);
        } catch (Exception $e) {
            $this->rootModuleFile->setPluginClasses($previousClasses);

            throw $e;
        }
    }

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

This method seems to be duplicated in your project.

    {
        $save = false;
        $previousClasses = $this->rootModuleFile->getPluginClasses();

        foreach ($previousClasses as $pluginClass) {
            if ($expr->evaluate($pluginClass)) {
                $this->rootModuleFile->removePluginClass($pluginClass);
                $save = true;
            }
        }

        if (!$save) {
            return;
        }

        try {
            $this->moduleFileStorage->saveRootModuleFile($this->rootModuleFile);
        } catch (Exception $e) {
            $this->rootModuleFile->setPluginClasses($previousClasses);

            throw $e;
        }
    }

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

    /**
     * {@inheritdoc}
     */
    public function hasPluginClass($pluginClass)
    {
        return $this->rootModuleFile->hasPluginClass($pluginClass);
    }

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

This method seems to be duplicated in your project.

    {
        if (!$expr) {
            return $this->rootModuleFile->hasPluginClasses();
        }

        foreach ($this->rootModuleFile->getPluginClasses() as $pluginClass) {
            if ($expr->evaluate($pluginClass)) {
                return true;
            }
        }

        return false;
    }

    /**
     * {@inheritdoc}
     */
    public function getPluginClasses()
    {
        return $this->rootModuleFile->getPluginClasses();
    }

    /**
     * {@inheritdoc}
     */
    public function findPluginClasses(Expression $expr)
    {
        $pluginClasses = array();

        foreach ($this->rootModuleFile->getPluginClasses() as $pluginClass) {
            if ($expr->evaluate($pluginClass)) {
                $pluginClasses[] = $pluginClass;
            }
        }

        return $pluginClasses;
    }

    /**
     * {@inheritdoc}
     */
    public function setExtraKey($key, $value)
    {
        $previouslySet = $this->rootModuleFile->hasExtraKey($key);
        $previousValue = $this->rootModuleFile->getExtraKey($key);

        if ($value === $previousValue) {
            return;
        }

        $this->rootModuleFile->setExtraKey($key, $value);

        try {
            $this->moduleFileStorage->saveRootModuleFile($this->rootModuleFile);
        } catch (Exception $e) {
            if ($previouslySet) {
                $this->rootModuleFile->setExtraKey($key, $previousValue);
            } else {
                $this->rootModuleFile->removeExtraKey($key);
            }

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function setExtraKeys(array $values)
    {
        $previousValues = array();
        $previouslyUnset = array();

        foreach ($values as $key => $value) {
            if ($this->rootModuleFile->hasExtraKey($key)) {
                if ($value !== $previous = $this->rootModuleFile->getExtraKey($key)) {
                    $previousValues[$key] = $previous;
                }
            } else {
                $previouslyUnset[$key] = true;
            }
        }

        if (!$previousValues && !$previouslyUnset) {

The expression $previousValues 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.

The expression $previouslyUnset 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.

            return;
        }

        $this->rootModuleFile->setExtraKeys($values);

        try {
            $this->moduleFileStorage->saveRootModuleFile($this->rootModuleFile);
        } catch (Exception $e) {
            foreach ($values as $key => $value) {
                if (isset($previouslyUnset[$key])) {
                    $this->rootModuleFile->removeExtraKey($key);
                } else {
                    $this->rootModuleFile->setExtraKey($key, $previousValues[$key]);
                }
            }

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function removeExtraKey($key)

This method seems to be duplicated in your project.

    {
        if (!$this->rootModuleFile->hasExtraKey($key)) {
            return;
        }

        $previousValue = $this->rootModuleFile->getExtraKey($key);

        $this->rootModuleFile->removeExtraKey($key);

        try {
            $this->moduleFileStorage->saveRootModuleFile($this->rootModuleFile);
        } catch (Exception $e) {
            $this->rootModuleFile->setExtraKey($key, $previousValue);

            throw $e;
        }
    }

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

This method seems to be duplicated in your project.

    {
        $previousValues = $this->rootModuleFile->getExtraKeys();
        $save = false;

        foreach ($this->rootModuleFile->getExtraKeys() as $key => $value) {
            if ($expr->evaluate($key)) {
                $this->rootModuleFile->removeExtraKey($key);
                $save = true;
            }
        }

        if (!$save) {
            return;
        }

        try {
            $this->moduleFileStorage->saveRootModuleFile($this->rootModuleFile);
        } catch (Exception $e) {
            $this->rootModuleFile->setExtraKeys($previousValues);

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function clearExtraKeys()

This method seems to be duplicated in your project.

    {
        $previousValues = $this->rootModuleFile->getExtraKeys();

        if (!$previousValues) {

The expression $previousValues 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.

            return;
        }

        $this->rootModuleFile->clearExtraKeys();

        try {
            $this->moduleFileStorage->saveRootModuleFile($this->rootModuleFile);
        } catch (Exception $e) {
            $this->rootModuleFile->setExtraKeys($previousValues);

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function hasExtraKey($key)
    {
        return $this->rootModuleFile->hasExtraKey($key);
    }

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

This method seems to be duplicated in your project.

    {
        if (!$expr) {
            return $this->rootModuleFile->hasExtraKeys();
        }

        foreach ($this->rootModuleFile->getExtraKeys() as $key => $value) {
            if ($expr->evaluate($key)) {
                return true;
            }
        }

        return false;
    }

    /**
     * {@inheritdoc}
     */
    public function getExtraKey($key, $default = null)
    {
        return $this->rootModuleFile->getExtraKey($key, $default);
    }

    /**
     * {@inheritdoc}
     */
    public function getExtraKeys()
    {
        return $this->rootModuleFile->getExtraKeys();
    }

    /**
     * {@inheritdoc}
     */
    public function findExtraKeys(Expression $expr)
    {
        $values = array();

        foreach ($this->rootModuleFile->getExtraKeys() as $key => $value) {
            if ($expr->evaluate($key)) {
                $values[$key] = $value;
            }
        }

        return $values;
    }

    /**
     * {@inheritdoc}
     */
    public function migrate($targetVersion)

This method seems to be duplicated in your project.

    {
        $previousVersion = $this->rootModuleFile->getVersion();

        if ($previousVersion === $targetVersion) {
            return;
        }

        $this->rootModuleFile->setVersion($targetVersion);

        try {
            $this->moduleFileStorage->saveRootModuleFile($this->rootModuleFile);
        } catch (Exception $e) {
            $this->rootModuleFile->setVersion($previousVersion);

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    protected function saveConfigFile()
    {
        $this->moduleFileStorage->saveRootModuleFile($this->rootModuleFile);
    }

    private function validatePluginClass($pluginClass)
    {
        try {
            $reflClass = new ReflectionClass($pluginClass);
        } catch (ReflectionException $e) {
            throw new InvalidArgumentException(sprintf(
                'The plugin class %s does not exist.',
                $pluginClass
            ), 0, $e);
        }

        if ($reflClass->isInterface()) {
            throw new InvalidArgumentException(sprintf(
                'The plugin class %s should be a class, but is an interface.',
                $pluginClass
            ));
        }

        if (version_compare(PHP_VERSION, '5.4.0', '>=') && $reflClass->isTrait()) {
            throw new InvalidArgumentException(sprintf(
                'The plugin class %s should be a class, but is a trait.',
                $pluginClass
            ));
        }

        if (!$reflClass->implementsInterface('\Puli\Manager\Api\PuliPlugin')) {
            throw new InvalidArgumentException(sprintf(
                'The plugin class %s must implement PuliPlugin.',
                $pluginClass
            ));
        }

        $constructor = $reflClass->getConstructor();

        if (null !== $constructor && $constructor->getNumberOfRequiredParameters() > 0) {
            throw new InvalidArgumentException(sprintf(
                'The constructor of the plugin class %s must not have required '.
                'parameters.',
                $pluginClass
            ));
        }
    }
}