Bex\Behat\ExtensionDriverLocator\DriverLocator

Complexity

Total Complexity

16

Size/Duplication

Total Lines	137
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getInstance()	0	4	1
A	findDrivers()	0	10	1
A	getDrivers()	0	4	1
A	removeUnusedDrivers()	0	10	3
A	createDrivers()	0	11	2
A	configureDrivers()	0	10	2
A	processDriverConfiguration()	0	10	3
A	loadDrivers()	0	8	2

<?php

namespace Bex\Behat\ExtensionDriverLocator;

use Bex\Behat\ExtensionDriverLocator\DriverClassNameResolver;
use Bex\Behat\ExtensionDriverLocator\DriverClassValidator;
use Bex\Behat\ExtensionDriverLocator\DriverInterface;
use Symfony\Component\Config\Definition\Builder\TreeBuilder;
use Symfony\Component\Config\Definition\NodeInterface;
use Symfony\Component\Config\Definition\Processor;
use Symfony\Component\DependencyInjection\ContainerBuilder;

class DriverLocator
{
    /**
     * @var DriverClassNameResolver
     */
    private $classNameResolver;

    /**
     * @var DriverInterface[]
     */
    private $drivers = [];

    /**
     * @param DriverClassNameResolver $classNameResolver
     */
    public function __construct(DriverClassNameResolver $classNameResolver)
    {
        $this->classNameResolver = $classNameResolver;
    }

    /**
     * @param  string $namespace
     * @param  string $parent
     *
     * @return Locator
     */
    public static function getInstance($namespace, $parent = '')
    {
        return new self(new DriverClassNameResolver($namespace, new DriverClassValidator($parent)));
    }

    /**
     * @param  ContainerBuilder $container
     * @param  array            $activeDrivers
     * @param  array            $driverConfigs
     *
     * @return DriverInterface[]
     */
    public function findDrivers(ContainerBuilder $container, array $activeDrivers, array $driverConfigs)
    {
        $driverConfigs = $this->removeUnusedDrivers($activeDrivers, $driverConfigs);
        $this->createDrivers($activeDrivers);
        $configTree = $this->configureDrivers();
        $driverConfigs = $this->processDriverConfiguration($configTree, $driverConfigs);
        $this->loadDrivers($container, $driverConfigs);

        return $this->drivers;
    }

    /**
     * @return DriverInterface[]
     */
    public function getDrivers()
    {
        return $this->drivers;
    }

    /**
     * @param  array $activeDrivers
     * @param  array $driverConfigs
     *
     * @return array
     */
    private function removeUnusedDrivers($activeDrivers, $driverConfigs)
    {
        foreach ($driverConfigs as $driverKey => $driverConfig) {
            if (!in_array($driverKey, $activeDrivers)) {
                unset($driverConfigs[$driverKey]);
            }
        }

        return $driverConfigs;
    }

    /**
     * @param array $driverKeys 
     *
     * @return DriverInterface[]
     */
    private function createDrivers($driverKeys)
    {
        $this->drivers = [];

        foreach ($driverKeys as $driverKey) {
            $driverClass = $this->classNameResolver->getClassNameByDriverKey($driverKey);
            $this->drivers[$driverKey] = new $driverClass();
        }

        return $this->drivers;
    }

    /**
     * @return NodeInterface
     */
    private function configureDrivers()
    {
        $tree = new TreeBuilder('drivers');

        foreach ($this->drivers as $driverKey => $driver) {
            $driver->configure($tree->getRootNode()->children()->arrayNode($driverKey));

It seems like you code against a specific sub-type and not the parent class Symfony\Component\Config\Definition\Builder\NodeDefinition as the method children() does only exist in the following sub-classes of Symfony\Component\Config\Definition\Builder\NodeDefinition: Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition. Maybe you want to instanceof check for one of these explicitly?

        }

        return $tree->buildTree();
    }

    /**
     * @param  NodeInterface $configTree
     * @param  array         $configs
     *
     * @return array The processed configuration
     */
    private function processDriverConfiguration(NodeInterface $configTree, array $configs)
    {
        $configProcessor = new Processor();

        foreach ($this->drivers as $driverKey => $driver) {
            $configs[$driverKey] = isset($configs[$driverKey]) ? $configs[$driverKey] : [];
        }

        return $configProcessor->process($configTree, ['drivers' => $configs]);
    }

    /**
     * @param  ContainerBuilder $container
     * @param  array            $driverConfigs
     *
     * @return DriverInterface[]
     */
    private function loadDrivers(ContainerBuilder $container, array $driverConfigs)
    {
        foreach ($this->drivers as $driverKey => $driver) {
            $driver->load($container, $driverConfigs[$driverKey]);
        }

        return $this->drivers;
    }
}