Oliverde8\Component\PhpEtl\ChainBuilder

Complexity

Total Complexity

10

Size/Duplication

Total Lines	68
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	registerFactory()	0	3	1
A	__construct()	0	5	1
A	getOperationFromConfig()	0	16	6
A	buildChainProcessor()	0	8	2

<?php

declare(strict_types=1);

namespace Oliverde8\Component\PhpEtl;

use Oliverde8\Component\PhpEtl\Builder\Factories\AbstractFactory;
use Oliverde8\Component\PhpEtl\ChainOperation\ChainOperationInterface;
use Oliverde8\Component\PhpEtl\Exception\UnknownOperationException;
use Symfony\Component\ExpressionLanguage\ExpressionLanguage;

/**
 * Class ChainBuilder
 *
 * @author    de Cramer Oliver<oiverde8@gmail.com>
 * @copyright 2018 Oliverde8
 * @package Oliverde8\Component\PhpEtl
 */
class ChainBuilder
{
    /** @var AbstractFactory[] */
    protected array $operationFactories;

    protected ExecutionContextFactoryInterface $contextFactory;

    protected ExpressionLanguage $expressionLanguage;

    /**
     * @param ExecutionContextFactoryInterface $contextFactory
     */
    public function __construct(ExecutionContextFactoryInterface $contextFactory)
    {
        $this->contextFactory = $contextFactory;

        $this->expressionLanguage = new ExpressionLanguage();
    }


    /**
     * Register an operation factory.
     *
     * @param AbstractFactory $factory
     */
    public function registerFactory(AbstractFactory $factory)
    {
        $this->operationFactories[] = $factory;
    }

    /**
     * Get chain processor from configs.
     *
     * @throws Exception\ChainBuilderValidationException
     * @throws UnknownOperationException
     */
    public function buildChainProcessor(array $configs, array $inputOptions = [], int $maxAsynchronousItems = 10): ChainProcessorInterface
    {
        $chainOperations = [];
        foreach ($configs as $id => $operation) {
            $chainOperations[$id] = $this->getOperationFromConfig($operation, $inputOptions);
        }

        return new ChainProcessor($chainOperations, $this->contextFactory, $maxAsynchronousItems);
    }

    /**
     * Get chain operation instance from config.
     *
     * @throws Exception\ChainBuilderValidationException
     * @throws UnknownOperationException
     */
    protected function getOperationFromConfig(array $config, array $inputOptions): ChainOperationInterface
    {
        foreach ($config['options'] as &$option) {
            if (is_string($option) && strpos($option, "!") === 0) {
                $option = ltrim($option, '!');
                $option = $this->expressionLanguage->evaluate($option, $inputOptions);
            }
        }

        foreach ($this->operationFactories as $factory) {
            if ($factory->supports($config['operation'], $config['options'])) {
                return $factory->getOperation($config['operation'], $config['options']);
            }
        }

       throw new UnknownOperationException("No compatible factories were found for operation '{$config['operation']}'");
    }
}