Kaliop\eZMigrationBundle\Core\Executor\ServiceExecutor

Complexity

Total Complexity

30

Size/Duplication

Total Lines	138
Duplicated Lines	19.57 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

5.88%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	execute()	16	16	3
D	call()	0	43	10
C	setReferences()	0	37	13
A	resolveReferencesRecursively()	11	11	3

<?php

namespace Kaliop\eZMigrationBundle\Core\Executor;

use Symfony\Component\DependencyInjection\ContainerInterface;
use Kaliop\eZMigrationBundle\API\Value\MigrationStep;
use Kaliop\eZMigrationBundle\Core\ReferenceResolver\PrefixBasedResolverInterface;

class ServiceExecutor extends AbstractExecutor
{
    protected $supportedStepTypes = array('service');
    protected $supportedActions = array('call');

    /** @var PrefixBasedResolverInterface $referenceResolver */
    protected $referenceResolver;

    protected $container;

    public function __construct(ContainerInterface $container, PrefixBasedResolverInterface $referenceResolver)
    {
        $this->referenceResolver = $referenceResolver;
        $this->container = $container;
    }

    /**
     * @param MigrationStep $step
     * @return mixed
     * @throws \Exception
     */
    public function execute(MigrationStep $step)

This method seems to be duplicated in your project.

    {
        parent::execute($step);

        if (!isset($step->dsl['mode'])) {
            throw new \Exception("Invalid step definition: missing 'mode'");
        }

        $action = $step->dsl['mode'];

        if (!in_array($action, $this->supportedActions)) {
            throw new \Exception("Invalid step definition: value '$action' is not allowed for 'mode'");
        }

        return $this->$action($step->dsl, $step->context);
    }

    /**
     * @param $dsl
     * @param $context
     * @return \Symfony\Component\Process\Process
     * @throws \Exception
     */
    protected function call($dsl, $context)

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

    {
        if (!isset($dsl['service'])) {
            throw new \Exception("Can not call service method: 'service' missing");
        }
        if (!isset($dsl['method'])) {
            throw new \Exception("Can not call service method: 'method' missing");
        }
        if (isset($dsl['arguments']) && !is_array($dsl['arguments'])) {
            throw new \Exception("Can not call service method: 'arguments' is not an array");
        }

        $service = $this->container->get($this->referenceResolver->resolveReference($dsl['service']));
        $method = $this->referenceResolver->resolveReference($dsl['method']);
        $callable = array($service, $method);
        if (!is_callable($callable)) {
            throw new \Exception("Can not call service method: $method is not a method of " . get_class($service));
        }

        if (isset($dsl['arguments'])) {
            $args = $dsl['arguments'];
        } else {
            $args = array();
        }
        foreach($args as &$val) {
            $val = $this->resolveReferencesRecursively($val);
        }

        $exception = null;
        try {
            $result = call_user_func_array($callable, $args);
        } catch (\Exception $exception) {
            if (isset($dsl['catch'])) {

This if statement is empty and can be removed.

                // @todo allow to specify a set of exceptions to tolerate
            }

            throw $exception;
        }

        $this->setReferences($result, $exception, $dsl);

        return $result;
    }

    protected function setReferences($result, \Exception $exception = null, $dsl)
    {
        if (!array_key_exists('references', $dsl)) {
            return false;
        }

        foreach ($dsl['references'] as $reference) {
            switch ($reference['attribute']) {
                case 'result':
                    $value = $result;
                    break;
                case 'exception_code':
                    $value = $exception ? $exception->getCode() : null;
                    break;
                case 'exception_message':
                    $value = $exception ? $exception->getMessage() : null;
                    break;
                case 'exception_file':
                    $value = $exception ? $exception->getFile() : null;
                    break;
                case 'exception_line':
                    $value = $exception ? $exception->getLine() : null;
                    break;

                default:
                    throw new \InvalidArgumentException('Service executor does not support setting references for attribute ' . $reference['attribute']);
            }

            $overwrite = false;
            if (isset($reference['overwrite'])) {
                $overwrite = $reference['overwrite'];
            }
            $this->referenceResolver->addReference($reference['identifier'], $value, $overwrite);

It seems like you code against a concrete implementation and not the interface Kaliop\eZMigrationBundle\Core\ReferenceResolver\PrefixBasedResolverInterface as the method addReference() does only exist in the following implementations of said interface: Kaliop\eZMigrationBundle\Core\ReferenceResolver\ChainPrefixResolver, Kaliop\eZMigrationBundle\Core\ReferenceResolver\CustomReferenceResolver.

        }

        return true;
    }

    protected function resolveReferencesRecursively($match)

This method seems to be duplicated in your project.

    {
        if (is_array($match)) {
            foreach ($match as $condition => $values) {
                $match[$condition] = $this->resolveReferencesRecursively($values);
            }
            return $match;
        } else {
            return $this->referenceResolver->resolveReference($match);
        }
    }
}