FormatterManager::formatSourceBlocks() - Code Metrics - Inspection of "Before di" - Symplify/PHP7_Sculpin - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#10)

by Tomáš

created 2016-09-23 20:22 UTC

FormatterManager::formatSourceBlocks() A

↳ Parent: FormatterManager

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	8
ccs	0
cts	8
cp	0
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	5
nc	1
nop	1
crap	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\Formatter;

use Dflydev\DotAccessConfiguration\Configuration;
use Symplify\PHP7_Sculpin\DataProvider\DataProviderManager;
use Symplify\PHP7_Sculpin\Source\SourceInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;

final class FormatterManager
{
    /**
     * @var EventDispatcherInterface
     */
    private $eventDispatcher;

    /**
     * @var Configuration
     */
    private $siteConfiguration;

    /**
     * @var DataProviderManager
     */
    private $dataProviderManager;

    /**
     * @var array
     */
    private $formatters = [];

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

    public function __construct(
        EventDispatcherInterface $eventDispatcher,
        Configuration $siteConfiguration,
        DataProviderManager $dataProviderManager = null
    ) {
        $this->eventDispatcher = $eventDispatcher;
        $this->siteConfiguration = $siteConfiguration;
        $this->dataProviderManager = $dataProviderManager;
    }

    /**
     * @param mixed $context
     */
    private function buildBaseFormatContext($context) : Configuration
    {
        $baseContext = new Configuration([
            'site' => $this->siteConfiguration->export(),
            'page' => $context,
            'formatter' => $this->defaultFormatter,
            'converters' => [],
        ]);

        if (isset($context['url'])) {
            if ('/' === $context['url']) {
                $relativeUrl = '.';
            } else {
                $relativeUrl = rtrim(str_repeat('../', substr_count($context['url'], '/')), '/');
            }

            $baseContext->set('relative_root_url', $relativeUrl);
        }

        foreach ($this->dataProviderManager->dataProviders() as $name) {
            if (isset($context['use']) and in_array($name, $context['use'])) {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
                $baseContext->set('data.'.$name, $this->dataProviderManager->dataProvider($name)->provideData());
            }
        }

        return $baseContext;
    }

    public function buildFormatContext(string $templateId, string $template, array $context) : FormatContext
    {
        $baseContext = $this->buildBaseFormatContext($context);

        foreach (['layout', 'formatter', 'converters'] as $key) {
            if (isset($context[$key])) {
                $baseContext->set($key, $context[$key]);
            }
        }

        return new FormatContext($templateId, $template, $baseContext->export());
    }

    public function registerFormatter(string $name, FormatterInterface $formatter)
    {
        $this->formatters[$name] = $formatter;

        if (null === $this->defaultFormatter) {
            $this->defaultFormatter = $name;
        }
    }

    public function formatter(string $name) : FormatterInterface
    {
        return $this->formatters[$name];
    }

    public function formatPage(string $templateId, string $template, array $context) : string

    {
        $formatContext = $this->buildFormatContext($templateId, $template, $context);

        if (!$formatContext->formatter()) {
            return $template;
        }

        return $this->formatter($formatContext->formatter())->formatPage($formatContext);
    }

    public function formatSourcePage(SourceInterface $source) : string
    {
        return $this->formatPage(
            $source->sourceId(),
            $source->content(),
            $source->data()->export()
        );
    }

    public function formatBlocks(string $templateId, string $template = null, array $context) : array

    {
        $formatContext = $this->buildFormatContext($templateId, $template, $context);

        if (!$formatContext->formatter()) {
            return ['content' => $template];
        }

        return $this->formatter($formatContext->formatter())->formatBlocks($formatContext);
    }

    public function formatSourceBlocks(SourceInterface $source) : array
    {
        return $this->formatBlocks(
            $source->sourceId(),
            $source->content(),
            $source->data()->export()
        );
    }

    public function defaultFormatter() : string
    {
        return $this->defaultFormatter;
    }

    /**
     * NOTE: This is a hack because Symfony DiC cannot handle passing Data Provider
     * Manager via constructor injection as some data providers might also rely
     * on formatter. Hurray for circular dependencies. :(.
     */
    public function setDataProviderManager(DataProviderManager $dataProviderManager)
    {
        $this->dataProviderManager = $dataProviderManager;
    }
}


Symplify / PHP7_Sculpin

Pull Request — master (#10)

FormatterManager::formatSourceBlocks() A

Complexity

Size

Duplication

Code Coverage

Importance

Logical Operators are used for Control-Flow

Duplication Side-by-Side

Filter issues like