PhpAbModule\Service\EngineFactory

Complexity

Total Complexity

36

Size/Duplication

Total Lines	187
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes	9
Bugs	1	Features	3

10 Methods

Rating	Name	Duplication	Size	Complexity
A	createService()	0	20	1
A	loadService()	0	12	3
A	loadTests()	0	10	3
B	loadTest()	0	23	4
B	loadTestVariants()	0	27	6
B	loadTestVariant()	0	23	5
A	loadTestVariantCallback()	0	12	3
C	loadTestVariantEventManager()	0	36	8
A	loadTestVariantSimple()	0	4	1
A	loadTestVariantFromServiceManager()	0	8	2

<?php
/**
 * This file is part of phpab/phpab-module. (https://github.com/phpab/phpab-module)
 *
 * @link https://github.com/phpab/phpab-module for the canonical source repository
 * @copyright Copyright (c) 2015-2016 phpab. (https://github.com/phpab/)
 * @license https://raw.githubusercontent.com/phpab/phpab-module/master/LICENSE MIT
 */

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 PhpAbModule\Variant\EventManagerVariant;
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 37 can also be of type array or object; however, PhpAb\Engine\Engine::__construct() does only seem to accept null|object<PhpAb\Participation\Filter\FilterInterface>, maybe add an additional type check?

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

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

        return $engine;
    }

    private function loadService(ServiceLocatorInterface $serviceLocator, $config, $serviceName)
    {
        if (!array_key_exists($serviceName, $config)) {
            return null;
        }

        if (!$serviceLocator->has($config[$serviceName])) {
            return null;
        }

        return $serviceLocator->get($config[$serviceName]);
    }

    private function loadTests(EngineInterface $engine, ServiceLocatorInterface $serviceLocator, $config)
    {
        if (!array_key_exists('tests', $config)) {
            return;
        }
        
        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);

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

It seems like $variantChooser defined by $serviceLocator->get($config['variant_chooser']) on line 84 can also be of type array or object; however, PhpAb\Engine\EngineInterface::addTest() does only seem to accept null|object<PhpAb\Variant\Chooser\ChooserInterface>, maybe add an additional type check?

    }

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

        if (!array_key_exists('variants', $config)) {
            return $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 'event_manager':
                $variant = $this->loadTestVariantEventManager($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 loadTestVariantEventManager(ServiceLocatorInterface $serviceLocator, $identifier, array $options)
    {
        if (!array_key_exists('callback', $options)) {
            throw new RuntimeException('Missing the "callback" option for event manager variant.');
        }

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

        if (!array_key_exists('priority', $options)) {
            $options['priority'] = 0;
        }

        if (empty($options['event_manager'])) {
            $eventManager = $serviceLocator->get('Application')->getEventManager();
        } else {
            $eventManager = $serviceLocator->get($options['event_manager']);
        }

        $callback = $options['callback'];

        if (!is_callable($callback) && $serviceLocator->has($callback)) {
            $callback = $serviceLocator->get($callback);
        } elseif (!is_callable($callback)) {
            throw new RuntimeException('The callback is not callable.');
        }

        return new EventManagerVariant(
            $eventManager,
            $identifier,
            $options['event'],
            $callback,
            $options['priority']
        );
    }

    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);
    }
}