rtens\domin\reflection\ObjectAction

Complexity

Total Complexity

16

Size/Duplication

Total Lines	111
Duplicated Lines	9.01 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
	executeWith()	0	1	?
A	caption()	0	3	1
A	description()	0	10	2
A	fill()	5	8	3
A	parameters()	0	10	3
A	isModifying()	0	3	1
A	execute()	0	3	1
A	createInstance()	5	13	4

<?php
namespace rtens\domin\reflection;

use rtens\domin\Action;
use rtens\domin\Parameter;
use rtens\domin\reflection\types\TypeFactory;
use watoki\factory\Factory;
use watoki\factory\Injector;
use watoki\reflect\PropertyReader;

abstract class ObjectAction implements Action {

    /** @var PropertyReader */
    private $reader;

    /** @var \ReflectionClass */
    protected $class;

    /** @var CommentParser */
    private $parser;

    /**
     * @param string $class
     * @param TypeFactory $types
     * @param CommentParser $parser
     */
    public function __construct($class, TypeFactory $types, CommentParser $parser) {
        $this->reader = new PropertyReader($types, $class);
        $this->class = new \ReflectionClass($class);
        $this->parser = $parser;
    }

    /**
     * Called by execute() with the instantiated object
     *
     * @param object $object
     * @return mixed
     */
    abstract protected function executeWith($object);

    /**
     * @return string
     */
    public function caption() {
        return preg_replace('/(.)([A-Z0-9])/', '$1 $2', $this->class->getShortName());
    }

    /**
     * @return string|null
     */
    public function description() {
        $docComment = $this->class->getDocComment();
        if (!$docComment) {
            return null;
        }

        return $this->parser->parse(implode("\n", array_map(function ($line) {
            return ltrim($line, " *\r\n\t");
        }, array_slice(explode("\n", $docComment), 1, -1))));
    }

    /**
     * Fills out partially available parameters
     *
     * @param array $parameters Available values indexed by name
     * @return array Filled values indexed by name
     */
    public function fill(array $parameters) {
        foreach ($this->reader->readInterface() as $property) {

This code seems to be duplicated across your project.

            if (!array_key_exists($property->name(), $parameters)) {
                $parameters[$property->name()] = $property->defaultValue();
            }
        }
        return $parameters;
    }

    /**
     * @return Parameter[]
     * @throws \Exception
     */
    public function parameters() {
        $parameters = [];
        foreach ($this->reader->readInterface() as $property) {
            if ($property->canSet()) {
                $parameters[] = (new Parameter($property->name(), $property->type(), $property->isRequired()))
                    ->setDescription($this->parser->parse($property->comment()));
            }
        }
        return $parameters;
    }

    /**
     * @return boolean True if the action modifies the state of the application
     */
    public function isModifying() {
        return true;
    }

    /**
     * @param mixed[] $parameters Values indexed by name
     * @return mixed the result of the execution
     * @throws \Exception if Action cannot be executed
     */
    public function execute(array $parameters) {
        return $this->executeWith($this->createInstance($parameters));
    }

    protected function createInstance(array $parameters) {
        $injector = new Injector(new Factory());
        $instance = $injector->injectConstructor($this->class->name, $parameters, function () {
            return false;
        });

        foreach ($this->reader->readInterface() as $property) {

This code seems to be duplicated across your project.

            if ($property->canSet() && array_key_exists($property->name(), $parameters)) {
                $property->set($instance, $parameters[$property->name()]);
            }
        }
        return $instance;
    }
}