rtens\domin\delivery\web\fields\ObjectField

Complexity

Total Complexity

24

Size/Duplication

Total Lines	136
Duplicated Lines	5.15 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes	6
Bugs	1	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	handles()	0	3	1
A	headElements()	0	8	2
A	inflate()	0	3	1
A	render()	0	10	1
A	createInstance()	0	11	2
A	inflateProperties()	0	10	3
A	inflateProperty()	0	3	1
A	renderPropertyFields()	0	8	2
A	renderPropertyField()	0	6	3
A	getField()	0	3	1
A	getClass()	7	7	2
A	makePropertyParameter()	0	3	1
A	getProperties()	0	9	3

<?php
namespace rtens\domin\delivery\web\fields;

use rtens\domin\delivery\FieldRegistry;
use rtens\domin\delivery\web\Element;
use rtens\domin\delivery\web\WebField;
use rtens\domin\Parameter;
use watoki\factory\Factory;
use watoki\factory\Injector;
use watoki\reflect\Property;
use watoki\reflect\PropertyReader;
use watoki\reflect\type\ClassType;
use watoki\reflect\TypeFactory;

class ObjectField implements WebField {

    /** @var TypeFactory */
    private $types;

    /** @var FieldRegistry */
    private $fields;

    /**
     * @param TypeFactory $types
     * @param FieldRegistry $fields
     */
    public function __construct(TypeFactory $types, FieldRegistry $fields) {
        $this->types = $types;
        $this->fields = $fields;
    }

    /**
     * @param Parameter $parameter
     * @return bool
     */
    public function handles(Parameter $parameter) {
        return $parameter->getType() instanceof ClassType;
    }

    /**
     * @param Parameter $parameter
     * @return array|\rtens\domin\delivery\web\Element[]
     */
    public function headElements(Parameter $parameter) {
        $headElements = [];
        foreach ($this->getProperties($parameter) as $property) {
            $param = $this->makePropertyParameter($parameter, $property);
            $headElements = array_merge($headElements, $this->getField($param)->headElements($param));
        }
        return $headElements;
    }

    /**
     * @param Parameter $parameter
     * @param array $serialized
     * @return object
     */
    public function inflate(Parameter $parameter, $serialized) {
        return $this->createInstance($parameter, $this->inflateProperties($parameter, $serialized));
    }

    /**
     * @param Parameter $parameter
     * @param mixed $value
     * @return string
     */
    public function render(Parameter $parameter, $value) {
        return (string)new Element('div', ['class' => 'panel panel-default'], [
            new Element('div', ['class' => 'panel-heading clearfix'], [
                new Element('h3', ['class' => 'panel-title'], [
                    htmlentities((new \ReflectionClass($this->getClass($parameter)))->getShortName()),
                ])
            ]),
            new Element('div', ['class' => 'panel-body'], $this->renderPropertyFields($parameter, $value))
        ]);
    }

    private function createInstance(Parameter $parameter, $properties) {
        $injector = new Injector(new Factory());
        $instance = $injector->injectConstructor($this->getClass($parameter), $properties, function () {
            return false;
        });

        foreach ($this->getProperties($parameter) as $property) {
            $property->set($instance, $properties[$property->name()]);
        }
        return $instance;
    }

    private function inflateProperties(Parameter $parameter, array $serialized) {
        $properties = [];
        foreach ($this->getProperties($parameter) as $property) {
            if (array_key_exists($property->name(), $serialized)) {
                $param = $this->makePropertyParameter($parameter, $property);
                $properties[$property->name()] = $this->inflateProperty($serialized[$property->name()], $param);
            }
        }
        return $properties;
    }

    private function inflateProperty($serialized, Parameter $parameter) {
        return $this->getField($parameter)->inflate($parameter, $serialized);
    }

    private function renderPropertyFields(Parameter $parameter, $object) {
        $fields = [];
        foreach ($this->getProperties($parameter, $object) as $property) {
            $param = $this->makePropertyParameter($parameter, $property);
            $fields[] = $this->renderPropertyField($property, $param, $object);
        }
        return $fields;
    }

    private function renderPropertyField(Property $property, Parameter $param, $object) {
        return new Element('div', ['class' => 'form-group'], [
            new Element('label', [], [ucfirst($property->name()) . ($property->isRequired() ? '*' : '')]),
            $this->getField($param)->render($param, $object ? $property->get($object) : null)
        ]);
    }

    /**
     * @param Parameter $param
     * @return WebField
     */
    private function getField(Parameter $param) {
        return $this->fields->getField($param);
    }

    private function getClass(Parameter $parameter) {

This method seems to be duplicated in your project.

        $type = $parameter->getType();
        if (!($type instanceof ClassType)) {
            throw new \InvalidArgumentException("[$type] is not a ClassType");
        }
        return $type->getClass();
    }

    private function makePropertyParameter(Parameter $parameter, Property $property) {
        return new Parameter($parameter->getName() . '[' . $property->name() . ']', $property->type(), $property->isRequired());
    }

    private function getProperties(Parameter $parameter, $object = null) {
        $reader = new PropertyReader($this->types, $this->getClass($parameter));

        foreach ($reader->readInterface($object) as $property) {
            if ($property->canSet()) {
                yield $property;
            }
        }
    }
}