PhpAbModule\Service\EngineFactory

Complexity

Total Complexity

24

Size/Duplication

Total Lines	131
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	6
Bugs	0	Features	1

9 Methods

Rating	Name	Duplication	Size	Complexity
A	createService()	0	20	1
A	loadService()	0	8	2
A	loadTests()	0	6	2
A	loadTest()	0	19	4
B	loadTestVariants()	0	24	5
A	loadTestVariant()	0	19	4
A	loadTestVariantCallback()	0	12	3
A	loadTestVariantSimple()	0	4	1
A	loadTestVariantFromServiceManager()	0	8	2

<?php

namespace PhpAbModule\Service;

use PhpAb\Engine\Engine;
use PhpAb\Engine\EngineInterface;
use PhpAb\Event\DispatcherInterface;
use PhpAb\Participation\ParticipationManagerInterface;
use PhpAb\Test\Test;
use PhpAb\Variant\CallbackVariant;
use PhpAb\Variant\SimpleVariant;
use RuntimeException;
use Zend\ServiceManager\FactoryInterface;
use Zend\ServiceManager\ServiceLocatorInterface;

class EngineFactory implements FactoryInterface
{
    public function createService(ServiceLocatorInterface $serviceLocator)
    {
        /** @var array $config */
        $config = $serviceLocator->get('Config');

        /** @var ParticipationManagerInterface $participationManager */
        $participationManager = $serviceLocator->get('phpab.participation_manager');

        /** @var DispatcherInterface $dispatcher */
        $dispatcher = $serviceLocator->get('phpab.dispatcher');

        $filter = $this->loadService($serviceLocator, $config['phpab']['default_filter']);
        $chooser = $this->loadService($serviceLocator, $config['phpab']['default_variant_chooser']);

        $engine = new Engine($participationManager, $dispatcher, $filter, $chooser);

It seems like $filter defined by $this->loadService($serviceLocator, $config['phpab']['default_filter']) on line 29 can also be of type array or object; however, PhpAb\Engine\Engine::__construct() does only seem to accept null|object<PhpAb\Participation\FilterInterface>, maybe add an additional type check?

It seems like $chooser defined by $this->loadService($serviceLocator, $config['phpab']['default_variant_chooser']) on line 30 can also be of type array or object; however, PhpAb\Engine\Engine::__construct() does only seem to accept null|object<PhpAb\Variant\ChooserInterface>, maybe add an additional type check?

        $this->loadTests($engine, $serviceLocator, $config['phpab']);

        return $engine;
    }

    private function loadService(ServiceLocatorInterface $serviceLocator, $serviceName)
    {
        if (!$serviceLocator->has($serviceName)) {
            return null;
        }

        return $serviceLocator->get($serviceName);
    }

    private function loadTests(EngineInterface $engine, ServiceLocatorInterface $serviceLocator, $config)
    {
        foreach ($config['tests'] as $identifier => $testConfig) {
            $this->loadTest($serviceLocator, $engine, $identifier, $testConfig);
        }
    }

    private function loadTest(ServiceLocatorInterface $serviceLocator, EngineInterface $engine, $identifier, array $config)
    {
        $filter = null;
        if (array_key_exists('filter', $config)) {
            $filter = $serviceLocator->get($config['filter']);
        }

        $variantChooser = null;
        if (array_key_exists('variant_chooser', $config)) {
            $variantChooser = $serviceLocator->get($config['variant_chooser']);
        }

        $variants = $this->loadTestVariants($serviceLocator, $config);
        $options = array_key_exists('options', $config) ? $config['options'] : [];

        $test = new Test($identifier, $variants);

        $engine->addTest($test, $options, $filter, $variantChooser);

The call to EngineInterface::addTest() has too many arguments starting with $filter.

    }

    private function loadTestVariants(ServiceLocatorInterface $serviceLocator, $config)
    {
        $variants = [];

        foreach ($config['variants'] as $identifier => $variant) {

            // We also support shortcuts so that the user can specify a service name straight away.
            if (is_string($variant)) {
                $variant = [
                    'type' => $variant,
                ];
            }

            if (!array_key_exists('type', $variant)) {
                throw new RuntimeException('The type of the variant is missing.');
            }

            $options = empty($variant['options']) ? [] : $variant['options'];

            $variants[] = $this->loadTestVariant($serviceLocator, $variant['type'], $identifier, $options);
        }

        return $variants;
    }

    private function loadTestVariant(ServiceLocatorInterface $serviceLocator, $type, $identifier, array $options)
    {
        switch ($type) {
            case 'callback':
                $variant = $this->loadTestVariantCallback($serviceLocator, $identifier, $options);
                break;

            case 'simple':
                $variant = $this->loadTestVariantSimple($serviceLocator, $identifier, $options);
                break;

            case 'service_manager':
            default:
                $variant = $this->loadTestVariantFromServiceManager($serviceLocator, $type);
                break;
        }

        return $variant;
    }

    private function loadTestVariantCallback(ServiceLocatorInterface $serviceLocator, $identifier, array $options)

The parameter $serviceLocator is not used and could be removed.

    {
        if (!array_key_exists('callback', $options)) {
            throw new RuntimeException('Missing "callback" for callback variant.');
        }

        if (!is_callable($options['callback'])) {
            throw new RuntimeException('The "callback" for callback variant cannot be called.');
        }

        return new CallbackVariant($identifier, $options['callback']);
    }

    private function loadTestVariantSimple(ServiceLocatorInterface $serviceLocator, $identifier, array $options)

The parameter $serviceLocator is not used and could be removed.

The parameter $options is not used and could be removed.

    {
        return new SimpleVariant($identifier);
    }

    private function loadTestVariantFromServiceManager(ServiceLocatorInterface $serviceLocator, $type)
    {
        if (!$serviceLocator->has($type)) {
            throw new RuntimeException(sprintf('The variant "%s" is not a valid service manager name.', $type));
        }

        return $serviceLocator->get($type);
    }
}