Symplify\PHP7_Sculpin\PostsBundle\ProxySourceCollection\ProxySourceCollectionDataProvider

Complexity

Total Complexity

19

Size/Duplication

Total Lines	130
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

0%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	15	1
A	provideData()	0	4	1
A	getSubscribedEvents()	0	10	1
C	beforeRun()	0	34	7
B	beforeRunPost()	0	18	7
A	afterConvert()	0	8	2

<?php

/*
 * This file is a part of Sculpin.
 *
 * (c) Dragonfly Development Inc.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symplify\PHP7_Sculpin\PostsBundle\ProxySourceCollection;

use Symplify\PHP7_Sculpin\DataProvider\DataProviderInterface;
use Symplify\PHP7_Sculpin\Event\ConvertEvent;
use Symplify\PHP7_Sculpin\Event\SculpinEvents;
use Symplify\PHP7_Sculpin\Event\SourceSetEvent;
use Symplify\PHP7_Sculpin\Formatter\FormatterManager;
use Symplify\PHP7_Sculpin\Source\Filter\FilterInterface;
use Symplify\PHP7_Sculpin\Source\Map\MapInterface;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;

final class ProxySourceCollectionDataProvider implements DataProviderInterface, EventSubscriberInterface
{
    /**
     * @var FormatterManager
     */
    private $formatterManager;

    /**
     * @var string
     */
    private $dataProviderName;

    /**
     * @var array|ProxySourceCollection
     */
    private $collection = [];

    /**
     * @var FilterInterface
     */
    private $filter;

    /**
     * @var MapInterface
     */
    private $map;

    /**
     * @var SimpleProxySourceItemFactory
     */
    private $factory;

    public function __construct(
        FormatterManager $formatterManager,
        string $dataProviderName,
        ProxySourceCollection $collection,
        FilterInterface $filter,
        MapInterface $map,
        SimpleProxySourceItemFactory $factory
    ) {
        $this->formatterManager = $formatterManager;
        $this->dataProviderName = $dataProviderName;
        $this->collection = $collection; // ?: new ProxySourceCollection();

60% of this comment could be valid code. Did you maybe forget this after debugging?

        $this->filter = $filter;
        $this->map = $map;
        $this->factory = $factory;
    }

    /**
     * {@inheritdoc}
     */
    public function provideData() : ProxySourceCollection
    {
        return $this->collection;
    }

    public static function getSubscribedEvents() : array
    {
        return [
            SculpinEvents::BEFORE_RUN => [
                ['beforeRun', 0],
                ['beforeRunPost', -100],
            ],
            SculpinEvents::AFTER_CONVERT => 'afterConvert',
        ];
    }

    public function beforeRun(SourceSetEvent $sourceSetEvent)
    {
        foreach ($sourceSetEvent->updatedSources() as $source) {
            if ($source->isGenerated()) {
                // We want to skip generated sources in case someone is
                // doing something like a redirect where virtual sources are
                // created like a redirect plugin.

                // NOTE: This means that a generator cannot create proxy
                // source collection items. This could be limiting in the
                // future...
                continue;
            }

            if ($this->filter->match($source)) {
                $this->map->process($source);
                $this->collection[$source->sourceId()] = $this->factory->createProxySourceItem($source);
            }
        }
        $foudAtLeastOne = false;

        foreach ($sourceSetEvent->allSources() as $source) {
            if ($this->filter->match($source)) {
                $foudAtLeastOne = true;
                break;
            }
        }

        if (!$foudAtLeastOne) {
            echo 'Didn\'t find at least one of this type : '.$this->dataProviderName.PHP_EOL;
        }

        $this->collection->init();
    }

    public function beforeRunPost(SourceSetEvent $sourceSetEvent)
    {
        $anItemHasChanged = false;
        foreach ($this->collection as $item) {
            if ($item->hasChanged()) {
                $anItemHasChanged = true;
                $this->collection->init();
                break;
            }
        }
        if ($anItemHasChanged) {
            foreach ($sourceSetEvent->allSources() as $source) {
                if ($source->data()->get('use') and in_array($this->dataProviderName, $source->data()->get('use'))) {

Using logical operators such as and instead of && is generally not recommended.

                    $source->forceReprocess();
                }
            }
        }
    }

    public function afterConvert(ConvertEvent $convertEvent)
    {
        $sourceId = $convertEvent->source()->sourceId();
        if (isset($this->collection[$sourceId])) {
            $item = $this->collection[$sourceId];
            $item->setBlocks($this->formatterManager->formatSourceBlocks($convertEvent->source()));
        }
    }
}