Puli\Manager\Api\Discovery\BindingDescriptor

Complexity

Total Complexity

38

Size/Duplication

Total Lines	329
Duplicated Lines	12.16 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

82.5%

Importance

Changes	4
Bugs	2	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	isLoaded()	0	4	1
A	getTypeName()	0	4	1
A	getBinding()	0	4	1
A	__construct()	0	4	1
A	getUuid()	0	4	1
A	unload()	0	11	2
A	getLoadErrors()	0	8	2
A	isEnabled()	8	8	2
A	isDisabled()	8	8	2
A	isTypeNotFound()	8	8	2
A	isTypeNotEnabled()	8	8	2
A	isInvalid()	8	8	2
B	load()	0	21	6
A	getContainingModule()	0	8	2
A	getTypeDescriptor()	0	9	2
B	refreshState()	0	16	7
A	getState()	0	8	2

<?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\Api\Discovery;

use Exception;
use Puli\Discovery\Api\Binding\Binding;
use Puli\Discovery\Binding\ResourceBinding;
use Puli\Manager\Api\AlreadyLoadedException;
use Puli\Manager\Api\Module\Module;
use Puli\Manager\Api\Module\RootModule;
use Puli\Manager\Api\NotLoadedException;
use Rhumsaa\Uuid\Uuid;

/**
 * Describes a resource binding.
 *
 * This class contains a high-level model of {@link ResourceBinding} as it is
 * used in this module.
 *
 * @since  1.0
 *
 * @author Bernhard Schussek <bschussek@gmail.com>
 *
 * @see    ResourceBinding
 */
class BindingDescriptor
{
    /**
     * @var Binding
     */
    private $binding;

    /**
     * @var int
     */
    private $state;

    /**
     * @var Module
     */
    private $containingModule;

    /**
     * @var BindingTypeDescriptor
     */
    private $typeDescriptor;

    /**
     * @var Exception[]
     */
    private $loadErrors;

    /**
     * Creates a new binding descriptor.
     *
     * @param Binding $binding The described binding.
     */
    public function __construct(Binding $binding)
    {
        $this->binding = $binding;
    }

    /**
     * Loads the binding descriptor.
     *
     * @param Module                     $containingModule The module that
     *                                                     contains the
     *                                                     descriptor.
     * @param BindingTypeDescriptor|null $typeDescriptor   The type descriptor.
     *
     * @throws AlreadyLoadedException If the descriptor is already loaded.
     */
    public function load(Module $containingModule, BindingTypeDescriptor $typeDescriptor = null)
    {
        if (null !== $this->state) {
            throw new AlreadyLoadedException('The binding descriptor is already loaded.');
        }

        $this->loadErrors = array();

        if ($typeDescriptor && $typeDescriptor->isLoaded() && $typeDescriptor->isEnabled()) {
            try {
                $this->binding->initialize($typeDescriptor->getType());
            } catch (Exception $e) {
                $this->loadErrors[] = $e;
            }
        }

        $this->containingModule = $containingModule;
        $this->typeDescriptor = $typeDescriptor;

        $this->refreshState();
    }

    /**
     * Unloads the binding descriptor.
     *
     * All memory allocated during {@link load()} is freed.
     *
     * @throws NotLoadedException If the descriptor is not loaded.
     */
    public function unload()
    {
        if (null === $this->state) {
            throw new NotLoadedException('The binding descriptor is not loaded.');
        }

        $this->containingModule = null;
        $this->typeDescriptor = null;
        $this->loadErrors = array();
        $this->state = null;
    }

    /**
     * Returns whether the descriptor is loaded.
     *
     * @return bool Returns `true` if the descriptor is loaded.
     */
    public function isLoaded()
    {
        return null !== $this->state;
    }

    /**
     * Returns the UUID of the described binding.
     *
     * @return Uuid The UUID.
     */
    public function getUuid()
    {
        return $this->binding->getUuid();
    }

    /**
     * Returns the name of the bound type.
     *
     * @return string The type name.
     */
    public function getTypeName()
    {
        return $this->binding->getTypeName();
    }

    /**
     * Returns the described binding.
     *
     * @return Binding The binding.
     */
    public function getBinding()
    {
        return $this->binding;
    }

    /**
     * Returns the errors that happened during loading.
     *
     * The method {@link load()} needs to be called before calling this method,
     * otherwise an exception is thrown.
     *
     * @return Exception[] The load errors.
     *
     * @throws NotLoadedException If the descriptor is not loaded.
     */
    public function getLoadErrors()
    {
        if (null === $this->loadErrors) {
            throw new NotLoadedException('The binding descriptor is not loaded.');
        }

        return $this->loadErrors;
    }

    /**
     * Returns the module that contains the descriptor.
     *
     * The method {@link load()} needs to be called before calling this method,
     * otherwise an exception is thrown.
     *
     * @return Module The containing module.
     *
     * @throws NotLoadedException If the descriptor is not loaded.
     */
    public function getContainingModule()
    {
        if (null === $this->containingModule) {
            throw new NotLoadedException('The binding descriptor is not loaded.');
        }

        return $this->containingModule;
    }

    /**
     * Returns the type descriptor.
     *
     * The method {@link load()} needs to be called before calling this method,
     * otherwise an exception is thrown.
     *
     * @return BindingTypeDescriptor|null The type descriptor or null, if no
     *                                    type descriptor exists for the
     *                                    binding's type name.
     *
     * @throws NotLoadedException If the binding descriptor is not loaded.
     */
    public function getTypeDescriptor()
    {
        // Check containing module, as the type descriptor may be null
        if (null === $this->containingModule) {
            throw new NotLoadedException('The binding descriptor is not loaded.');
        }

        return $this->typeDescriptor;
    }

    /**
     * Returns the state of the binding.
     *
     * The method {@link load()} needs to be called before calling this method,
     * otherwise an exception is thrown.
     *
     * @return int One of the {@link BindingState} constants.
     *
     * @throws NotLoadedException If the descriptor is not loaded.
     */
    public function getState()
    {
        if (null === $this->state) {
            throw new NotLoadedException('The binding descriptor is not loaded.');
        }

        return $this->state;
    }

    /**
     * Returns whether the binding is enabled.
     *
     * The method {@link load()} needs to be called before calling this method,
     * otherwise an exception is thrown.
     *
     * @return bool Returns `true` if the state is {@link BindingState::ENABLED}.
     *
     * @throws NotLoadedException If the descriptor is not loaded.
     *
     * @see BindingState::ENABLED
     */
    public function isEnabled()

This method seems to be duplicated in your project.

    {
        if (null === $this->state) {
            throw new NotLoadedException('The binding descriptor is not loaded.');
        }

        return BindingState::ENABLED === $this->state;
    }

    /**
     * Returns whether the binding is disabled.
     *
     * The method {@link load()} needs to be called before calling this method,
     * otherwise an exception is thrown.
     *
     * @return bool Returns `true` if the state is {@link BindingState::DISABLED}.
     *
     * @throws NotLoadedException If the descriptor is not loaded.
     *
     * @see BindingState::DISABLED
     */
    public function isDisabled()

This method seems to be duplicated in your project.

    {
        if (null === $this->state) {
            throw new NotLoadedException('The binding descriptor is not loaded.');
        }

        return BindingState::DISABLED === $this->state;
    }

    /**
     * Returns whether the type of the binding does not exist.
     *
     * The method {@link load()} needs to be called before calling this method,
     * otherwise an exception is thrown.
     *
     * @return bool Returns `true` if the state is {@link BindingState::TYPE_NOT_FOUND}.
     *
     * @throws NotLoadedException If the descriptor is not loaded.
     *
     * @see BindingState::TYPE_NOT_FOUND
     */
    public function isTypeNotFound()

This method seems to be duplicated in your project.

    {
        if (null === $this->state) {
            throw new NotLoadedException('The binding descriptor is not loaded.');
        }

        return BindingState::TYPE_NOT_FOUND === $this->state;
    }

    /**
     * Returns whether the type of the binding is not enabled.
     *
     * The method {@link load()} needs to be called before calling this method,
     * otherwise an exception is thrown.
     *
     * @return bool Returns `true` if the state is {@link BindingState::TYPE_NOT_ENABLED}.
     *
     * @throws NotLoadedException If the descriptor is not loaded.
     *
     * @see BindingState::TYPE_NOT_ENABLED
     */
    public function isTypeNotEnabled()

This method seems to be duplicated in your project.

    {
        if (null === $this->state) {
            throw new NotLoadedException('The binding descriptor is not loaded.');
        }

        return BindingState::TYPE_NOT_ENABLED === $this->state;
    }

    /**
     * Returns whether the binding is invalid.
     *
     * The method {@link load()} needs to be called before calling this method,
     * otherwise an exception is thrown.
     *
     * @return bool Returns `true` if the state is {@link BindingState::INVALID}.
     *
     * @throws NotLoadedException If the descriptor is not loaded.
     *
     * @see BindingState::INVALID
     */
    public function isInvalid()

This method seems to be duplicated in your project.

    {
        if (null === $this->state) {
            throw new NotLoadedException('The binding descriptor is not loaded.');
        }

        return BindingState::INVALID === $this->state;
    }

    private function refreshState()
    {
        if (null === $this->typeDescriptor || !$this->typeDescriptor->isLoaded()) {
            $this->state = BindingState::TYPE_NOT_FOUND;
        } elseif (!$this->typeDescriptor->isEnabled()) {
            $this->state = BindingState::TYPE_NOT_ENABLED;
        } elseif (count($this->loadErrors) > 0) {
            $this->state = BindingState::INVALID;
        } elseif ($this->containingModule instanceof RootModule) {
            $this->state = BindingState::ENABLED;
        } elseif ($this->containingModule->getInstallInfo()->hasDisabledBindingUuid($this->binding->getUuid())) {
            $this->state = BindingState::DISABLED;
        } else {
            $this->state = BindingState::ENABLED;
        }
    }
}