Scientist\Blind\Preparation

Complexity

Total Complexity

20

Size/Duplication

Total Lines	172
Duplicated Lines	8.14 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	1	Features	3

9 Methods

Rating	Name	Duplication	Size	Complexity
A	prepare()	0	5	1
B	createBlind()	0	24	3
A	createMethodExperiment()	7	22	3
A	createPropertyExperiment()	7	22	3
A	createPropertyCallable()	0	14	2
A	createMissingPropertyCallable()	0	6	1
A	createMissingMethodCallable()	0	6	1
A	addInterfaceMethods()	0	18	3
A	createExperiments()	0	12	3

<?php


namespace Scientist\Blind;

use ReflectionClass;
use ReflectionProperty;
use Scientist\Blind;
use Scientist\Experiment;
use Scientist\SideEffects\MissingMethod;
use Scientist\SideEffects\MissingProperty;
use Scientist\Study;
use Zend\Code\Generator\ClassGenerator;
use Zend\Code\Generator\MethodGenerator;
use Zend\Code\Reflection\ClassReflection;

class Preparation
{
    /**
     * @param Study $study
     * @param mixed $control
     * @param mixed[] $trials
     * @param string[] $interfaces that blind should satisfy
     * @return Blind
     */
    public function prepare(Study $study, $control, array $trials, array $interfaces = [])
    {
        $experiments = $this->createExperiments($study, $control, $trials);
        return $this->createBlind($study, $control, $experiments, $interfaces);
    }

    /**
     * @param $study
     * @param mixed $control
     * @param Experiment[] $experiments
     * @param string[] $interfaces
     * @return Blind
     */
    private function createBlind($study, $control, array $experiments, array $interfaces = [])

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

    {
        $blind_name = sprintf("Blind_%s", str_replace('.', '', uniqid('', true)));

        array_push($interfaces, Blind::class);

        foreach ($interfaces as &$interface) {
            if (strpos($interface, '\\') !== 0) {
                $interface = '\\'.$interface;
            }
        }

        $generator = new ClassGenerator($blind_name, 'Scientist\Blind');
        $generator->setImplementedInterfaces($interfaces);
        $generator->addTrait('\\'.DecoratorTrait::class);

        $this->addInterfaceMethods($generator, $interfaces);

        $code = $generator->generate();
        eval($code);

It is generally not recommended to use eval unless absolutely required.

        $class_name = sprintf('Scientist\Blind\%s', $blind_name);
        return new $class_name($study, $experiments);
    }

    /**
     * @param $study
     * @param $control
     * @param array $trials
     * @return array
     */
    private function createExperiments(Study $study, $control, array $trials)
    {
        $experiments = [];
        $reflection = new ReflectionClass($control);
        foreach ($reflection->getMethods() as $method) {
            $experiments[] = $this->createMethodExperiment($method->getName(), $study, $control, $trials);

Consider using $method->name. There is an issue with getName() and APC-enabled PHP versions.

        }
        foreach ($reflection->getProperties(ReflectionProperty::IS_PUBLIC) as $property) {
            $experiments[] = $this->createPropertyExperiment($property->getName(), $study, $control, $trials);
        }
        return $experiments;
    }

    /**
     * @param string $name
     * @param Study $study
     * @param mixed $control
     * @param mixed[] $trials
     * @return Experiment
     */
    private function createMethodExperiment($name, Study $study, $control, array $trials)
    {
        $experiment_name = sprintf('%s::%s', $study->getName(), $name);
        /** @var Experiment $experiment */
        $experiment = $study->getLaboratory()
            ->experiment($experiment_name);

        $experiment->control([$control, $name]);

        foreach ($trials as $trial_name => $trial) {

This code seems to be duplicated across your project.

            if (method_exists($trial, $name)) {
                $experiment->trial($trial_name, [$trial, $name]);
            } else {
                $experiment->trial($trial_name, $this->createMissingMethodCallable($trial, $name));
            }
        }

        $experiment->matcher($study->getMatcher());
        $experiment->chance($study->getChance());
        $study->addExperiment($experiment);
        return $experiment;
    }

    private function createPropertyExperiment($name, Study $study, $control, array $trials)
    {
        $experiment_name = sprintf('%s::$%s', $study->getName(), $name);
        /** @var Experiment $experiment */
        $experiment = $study->getLaboratory()
            ->experiment($experiment_name);

        $experiment->control($this->createPropertyCallable($control, $name));

        foreach ($trials as $trial_name => $trial) {

This code seems to be duplicated across your project.

            if (property_exists($trial, $name)) {
                $experiment->trial($trial_name, $this->createPropertyCallable($trial, $name));
            } else {
                $experiment->trial($trial_name, $this->createMissingPropertyCallable($trial, $name));
            }
        }

        $experiment->matcher($study->getMatcher());
        $experiment->chance($study->getChance());
        $study->addExperiment($experiment);
        return $experiment;
    }

    /**
     * @param mixed $instance
     * @param string $name
     * @return callable
     */
    private function createPropertyCallable($instance, $name)
    {
        return function () use ($instance, $name) {
            $args = func_get_args();
            // __set
            if (count($args) > 1) {
                list($name, $value) = $args;
                return $instance->{$name} = $value;
            }
            // __get
            $name = $args[0];

Consider using a different name than the imported variable $name, or did you forget to import by reference?

            return $instance->{$name};
        };
    }

    private function createMissingPropertyCallable($instance, $name)
    {
        return function () use ($instance, $name) {
            throw new MissingProperty($instance, $name);
        };
    }

    private function createMissingMethodCallable($instance, $name)
    {
        return function () use ($instance, $name) {
            throw new MissingMethod($instance, $name);
        };
    }

    private function addInterfaceMethods(Classgenerator $classGenerator, array $interfaces)
    {
        $template = <<<'PHP'
    $arguments = func_get_args();
    $experiment = $this->getExperiment($this->getExperimentNameForMethod('%s'));
    return call_user_func_array([$experiment, 'run'], $arguments);
PHP;

        foreach ($interfaces as $interface) {
            $reflection = new ClassReflection($interface);
            foreach ($reflection->getMethods() as $method) {
                $generator = MethodGenerator::fromReflection($method);
                $generator->setInterface(false);
                $generator->setBody(sprintf($template, $method->getName()));

Consider using $method->name. There is an issue with getName() and APC-enabled PHP versions.

                $classGenerator->addMethodFromGenerator($generator);
            }
        }
    }
}