Puli\Manager\Asset\DiscoveryAssetManager

Complexity

Total Complexity

40

Size/Duplication

Total Lines	279
Duplicated Lines	35.13 %

Coupling/Cohesion

Components	1
Dependencies	15

Test Coverage

Coverage

98.23%

Importance

Changes	4
Bugs	1	Features	1

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
D	addRootAssetMapping()	0	43	9
B	removeRootAssetMapping()	0	25	5
B	removeRootAssetMappings()	21	21	5
B	clearRootAssetMappings()	21	21	5
A	getRootAssetMapping()	10	10	2
A	hasRootAssetMapping()	7	7	1
A	hasRootAssetMappings()	0	4	1
A	findRootAssetMappings()	11	11	2
A	getAssetMapping()	10	10	2
A	findAssetMappings()	11	11	2
A	hasAssetMapping()	7	7	1
A	hasAssetMappings()	0	4	1
A	bindingToMapping()	0	10	1
A	getRootAssetMappings()	0	4	1
A	getAssetMappings()	0	4	1

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

use Puli\Discovery\Binding\ResourceBinding;
use Puli\Manager\Api\Asset\AssetManager;
use Puli\Manager\Api\Asset\AssetMapping;
use Puli\Manager\Api\Asset\DuplicateAssetMappingException;
use Puli\Manager\Api\Asset\NoSuchAssetMappingException;
use Puli\Manager\Api\Discovery\BindingDescriptor;
use Puli\Manager\Api\Discovery\DiscoveryManager;
use Puli\Manager\Api\Event\AddAssetMappingEvent;
use Puli\Manager\Api\Event\PuliEvents;
use Puli\Manager\Api\Event\RemoveAssetMappingEvent;
use Puli\Manager\Api\Server\NoSuchServerException;
use Puli\Manager\Api\Server\ServerCollection;
use Puli\UrlGenerator\DiscoveryUrlGenerator;
use Rhumsaa\Uuid\Uuid;
use RuntimeException;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Webmozart\Expression\Expr;
use Webmozart\Expression\Expression;

/**
 * An asset manager that uses a {@link DiscoveryManager} as storage backend.
 *
 * @since  1.0
 *
 * @author Bernhard Schussek <bschussek@gmail.com>
 */
class DiscoveryAssetManager implements AssetManager
{
    /**
     * @var DiscoveryManager
     */
    private $discoveryManager;

    /**
     * @var ServerCollection
     */
    private $servers;

    /**
     * @var BindingExpressionBuilder
     */
    private $exprBuilder;

    /**
     * @var EventDispatcherInterface
     */
    private $dispatcher;

    public function __construct(DiscoveryManager $discoveryManager, ServerCollection $servers, EventDispatcherInterface $dispatcher = null)
    {
        $this->discoveryManager = $discoveryManager;
        $this->servers = $servers;
        $this->exprBuilder = new BindingExpressionBuilder();
        $this->dispatcher = $dispatcher;
    }

    /**
     * {@inheritdoc}
     */
    public function addRootAssetMapping(AssetMapping $mapping, $flags = 0)
    {
        if (!$this->discoveryManager->hasTypeDescriptor(DiscoveryUrlGenerator::BINDING_TYPE)) {
            throw new RuntimeException(sprintf(
                'The binding type "%s" was not found. Please install the '.
                '"puli/url-generator" module with Composer:'."\n\n".
                '    $ composer require puli/url-generator',
                DiscoveryUrlGenerator::BINDING_TYPE
            ));
        }

        if (!($flags & self::IGNORE_SERVER_NOT_FOUND) && !$this->servers->contains($mapping->getServerName())) {
            throw NoSuchServerException::forServerName($mapping->getServerName());
        }

        if (!($flags & self::OVERRIDE) && $this->hasAssetMapping($mapping->getUuid())) {
            throw DuplicateAssetMappingException::forUuid($mapping->getUuid());
        }

        $binding = new ResourceBinding(
            // Match directories as well as all of their contents
            $mapping->getGlob().'{,/**/*}',
            DiscoveryUrlGenerator::BINDING_TYPE,
            array(
                DiscoveryUrlGenerator::SERVER_PARAMETER => $mapping->getServerName(),
                DiscoveryUrlGenerator::PATH_PARAMETER => $mapping->getServerPath(),
            ),
            'glob',
            $mapping->getUuid()
        );

        $this->discoveryManager->addRootBindingDescriptor(
            new BindingDescriptor($binding),
            ($flags & self::OVERRIDE) ? DiscoveryManager::OVERRIDE : 0
        );

        if ($this->dispatcher && $this->dispatcher->hasListeners(PuliEvents::POST_ADD_ASSET_MAPPING)) {
            $this->dispatcher->dispatch(
                PuliEvents::POST_ADD_ASSET_MAPPING,
                new AddAssetMappingEvent($mapping)
            );
        }
    }

    /**
     * {@inheritdoc}
     */
    public function removeRootAssetMapping(Uuid $uuid)
    {
        $mapping = null;
        $hasListener = $this->dispatcher && $this->dispatcher->hasListeners(PuliEvents::POST_REMOVE_ASSET_MAPPING);
        $expr = Expr::method('getUuid', Expr::method('toString', Expr::same($uuid->toString())))
            ->andX($this->exprBuilder->buildExpression());

        if ($hasListener) {
            // Query the mapping for the event
            try {
                $mapping = $this->getRootAssetMapping($uuid);
            } catch (NoSuchAssetMappingException $e) {
                return;
            }
        }

        $this->discoveryManager->removeRootBindingDescriptors($expr);

        if ($hasListener) {
            $this->dispatcher->dispatch(
                PuliEvents::POST_REMOVE_ASSET_MAPPING,
                new RemoveAssetMappingEvent($mapping)

It seems like $mapping defined by null on line 122 can be null; however, Puli\Manager\Api\Event\RemoveAssetMappingEvent::__construct() does not accept null, maybe add an additional type check?

            );
        }
    }

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

This method seems to be duplicated in your project.

    {
        $mappings = array();
        $hasListener = $this->dispatcher && $this->dispatcher->hasListeners(PuliEvents::POST_REMOVE_ASSET_MAPPING);

        if ($hasListener) {
            // Query the mappings for the event
            $mappings = $this->findRootAssetMappings($expr);
        }

        $this->discoveryManager->removeRootBindingDescriptors($this->exprBuilder->buildExpression($expr));

        if ($hasListener) {
            foreach ($mappings as $mapping) {
                $this->dispatcher->dispatch(
                    PuliEvents::POST_REMOVE_ASSET_MAPPING,
                    new RemoveAssetMappingEvent($mapping)
                );
            }
        }
    }

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

This method seems to be duplicated in your project.

    {
        $mappings = array();
        $hasListener = $this->dispatcher && $this->dispatcher->hasListeners(PuliEvents::POST_REMOVE_ASSET_MAPPING);

        if ($hasListener) {
            // Query the mappings for the event
            $mappings = $this->getRootAssetMappings();
        }

        $this->discoveryManager->removeRootBindingDescriptors($this->exprBuilder->buildExpression());

        if ($hasListener) {
            foreach ($mappings as $mapping) {
                $this->dispatcher->dispatch(
                    PuliEvents::POST_REMOVE_ASSET_MAPPING,
                    new RemoveAssetMappingEvent($mapping)
                );
            }
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getRootAssetMapping(Uuid $uuid)

This method seems to be duplicated in your project.

    {
        $mappings = $this->findRootAssetMappings(Expr::method('getUuid', Expr::method('toString', Expr::same($uuid->toString()))));

        if (!$mappings) {

The expression $mappings of type Puli\Manager\Api\Asset\AssetMapping[] 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.

            throw NoSuchAssetMappingException::forUuid($uuid);
        }

        return reset($mappings);
    }

    /**
     * {@inheritdoc}
     */
    public function getRootAssetMappings()
    {
        return $this->findRootAssetMappings(Expr::true());
    }

    /**
     * {@inheritdoc}
     */
    public function hasRootAssetMapping(Uuid $uuid)

This method seems to be duplicated in your project.

    {
        $expr = Expr::method('getUuid', Expr::method('toString', Expr::same($uuid->toString())))
            ->andX($this->exprBuilder->buildExpression());

        return $this->discoveryManager->hasRootBindingDescriptors($expr);
    }

    /**
     * {@inheritdoc}
     */
    public function hasRootAssetMappings(Expression $expr = null)
    {
        return $this->discoveryManager->hasRootBindingDescriptors($this->exprBuilder->buildExpression($expr));
    }

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

This method seems to be duplicated in your project.

    {
        $descriptors = $this->discoveryManager->findRootBindingDescriptors($this->exprBuilder->buildExpression($expr));
        $mappings = array();

        foreach ($descriptors as $descriptor) {
            $mappings[] = $this->bindingToMapping($descriptor->getBinding());

$descriptor->getBinding() of type object<Puli\Discovery\Api\Binding\Binding> is not a sub-type of object<Puli\Discovery\Binding\ResourceBinding>. It seems like you assume a concrete implementation of the interface Puli\Discovery\Api\Binding\Binding to be always present.

        }

        return $mappings;
    }

    /**
     * {@inheritdoc}
     */
    public function getAssetMapping(Uuid $uuid)

This method seems to be duplicated in your project.

    {
        $mappings = $this->findAssetMappings(Expr::method('getUuid', Expr::method('toString', Expr::same($uuid->toString()))));

        if (!$mappings) {

The expression $mappings of type Puli\Manager\Api\Asset\AssetMapping[] 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.

            throw NoSuchAssetMappingException::forUuid($uuid);
        }

        return reset($mappings);
    }

    /**
     * {@inheritdoc}
     */
    public function getAssetMappings()
    {
        return $this->findAssetMappings(Expr::true());
    }

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

This method seems to be duplicated in your project.

    {
        $descriptors = $this->discoveryManager->findBindingDescriptors($this->exprBuilder->buildExpression($expr));
        $mappings = array();

        foreach ($descriptors as $descriptor) {
            $mappings[] = $this->bindingToMapping($descriptor->getBinding());

$descriptor->getBinding() of type object<Puli\Discovery\Api\Binding\Binding> is not a sub-type of object<Puli\Discovery\Binding\ResourceBinding>. It seems like you assume a concrete implementation of the interface Puli\Discovery\Api\Binding\Binding to be always present.

        }

        return $mappings;
    }

    /**
     * {@inheritdoc}
     */
    public function hasAssetMapping(Uuid $uuid)

This method seems to be duplicated in your project.

    {
        $expr = Expr::method('getUuid', Expr::method('toString', Expr::same($uuid->toString())))
            ->andX($this->exprBuilder->buildExpression());

        return $this->discoveryManager->hasBindingDescriptors($expr);
    }

    /**
     * {@inheritdoc}
     */
    public function hasAssetMappings(Expression $expr = null)
    {
        return $this->discoveryManager->hasBindingDescriptors($this->exprBuilder->buildExpression($expr));
    }

    private function bindingToMapping(ResourceBinding $binding)
    {
        return new AssetMapping(
            // Remove "{,/**/*}" suffix
            substr($binding->getQuery(), 0, -8),
            $binding->getParameterValue(DiscoveryUrlGenerator::SERVER_PARAMETER),
            $binding->getParameterValue(DiscoveryUrlGenerator::PATH_PARAMETER),
            $binding->getUuid()
        );
    }
}