Everlution\Navigation\Factory\Build\NavigationItemConfig

Complexity

Total Complexity

14

Size/Duplication

Total Lines	156
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	24	1
A	toArray()	0	13	2
A	toObject()	0	21	3
A	resolve()	0	4	1
A	checkIfSupport()	0	6	2
	getObject()	0	1	?
	getArray()	0	1	?
	config()	0	1	?
A	popClassName()	0	7	1
A	addManualMatchesToArray()	0	6	2
A	addManualMatchesToObject()	0	6	2

<?php

declare(strict_types = 1);

namespace Everlution\Navigation\Factory\Build;

use Everlution\Navigation\Extension\ManualMatch;
use Everlution\Navigation\Item;
use Everlution\Navigation\Factory\ItemFactory;
use Symfony\Component\OptionsResolver\OptionsResolver;

/**
 * Class NavigationItemConfig.
 * @author Ivan Barlog <ivan.barlog@everlution.sk>
 */
abstract class NavigationItemConfig implements Config
{
    const OPTION_CLASS = 'class';
    const OPTION_LABEL = 'label';
    const OPTION_IDENTIFIER = 'identifier';
    const OPTION_CHILDREN = 'children';
    const OPTION_MATCHES = 'matches';

    /** @var OptionsResolver */
    protected $resolver;
    /** @var array */
    protected $supportedClasses = [];

    public function __construct()
    {
        $this->resolver = new OptionsResolver();

        $this->resolver->setRequired(
            [
                self::OPTION_CLASS,
                self::OPTION_LABEL,
                self::OPTION_IDENTIFIER,
                self::OPTION_CHILDREN,
                self::OPTION_MATCHES,
            ]
        );
        $this->resolver->setAllowedTypes(self::OPTION_CLASS, 'string');
        $this->resolver->setAllowedTypes(self::OPTION_LABEL, 'string');
        $this->resolver->setAllowedTypes(self::OPTION_IDENTIFIER, 'string');
        $this->resolver->setAllowedTypes(self::OPTION_CHILDREN, 'array');
        $this->resolver->setAllowedTypes(self::OPTION_MATCHES, 'array');

        $this->resolver->setDefault(self::OPTION_CHILDREN, []);
        $this->resolver->setDefault(self::OPTION_MATCHES, []);

        $this->config();
    }

    /**
     * @param Item $item
     * @param ItemFactory $factory
     * @return array
     */
    public function toArray(Item $item, ItemFactory $factory): array
    {
        $this->checkIfSupport(get_class($item));

        $result = $this->getArray($item);
        $this->addManualMatchesToArray($result, $item);

        foreach ($item->getChildren() as $child) {
            $result[static::OPTION_CHILDREN][] = $factory->flatten($child);
        }

        return $result;
    }

    /**
     * @param array $config
     * @param ItemFactory $factory
     * @return Item
     * @throws NavigationItemClassDoesNotExistException
     */
    public function toObject(array $config, ItemFactory $factory): Item
    {
        $className = $this->popClassName($config);
        $this->checkIfSupport($className);

        $config = $this->resolve($config);

        if (false === class_exists($className)) {
            throw new NavigationItemClassDoesNotExistException($className);
        }

        $object = $this->getObject($className, $config);
        $this->addManualMatchesToObject($object, $config);

        foreach ($config[self::OPTION_CHILDREN] as $item) {
            $child = $factory->create($item);
            $object->addChild($child);
        }

        return $object;
    }

    /**
     * @param array $config
     * @return array
     */
    protected function resolve(array $config): array
    {
        return $this->resolver->resolve($config);
    }

    /**
     * @param string $class
     */
    protected function checkIfSupport(string $class)
    {
        if (false === in_array($class, $this->supportedClasses)) {
            throw new UnsupportedItemClassException($class, $this->supportedClasses);
        }
    }

    /**
     * Specifies how the object should be created
     *
     * @param string $className
     * @param array $arguments
     * @return Item
     */
    abstract protected function getObject(string $className, array $arguments);

    /**
     * Specifies how should object be transformed to an array
     *
     * @param Item $item
     * @return array
     */
    abstract protected function getArray($item): array;

    /**
     * Specifies additional options
     * This method is called after initial OptionsResolver setup
     * Use OptionsResolver within this method
     *
     * @return void
     */
    abstract protected function config();

    /**
     * @param array $config
     * @return string
     */
    private function popClassName(array $config): string
    {
        $class = $config[self::OPTION_CLASS];
        unset($config[self::OPTION_CLASS]);

        return $class;
    }

    private function addManualMatchesToArray(array $result, Item $item)
    {
        if ($item instanceof ManualMatch) {
            $result[self::OPTION_MATCHES] = $item->getMatches();
        }
    }

    private function addManualMatchesToObject(Item $object, array $config)
    {
        if ($object instanceof ManualMatch) {
            $object->setMatches($config[self::OPTION_MATCHES]);
        }
    }
}