Silverback\ApiComponentBundle\Factory\Entity\AbstractFactory

Complexity

Total Complexity

16

Size/Duplication

Total Lines	127
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	findSetterMethod()	0	11	3
A	defaultOps()	0	3	1
A	__construct()	0	6	1
A	validate()	0	7	2
A	init()	0	17	5
A	getIgnoreOps()	0	3	1
A	setOptions()	0	16	3

<?php

namespace Silverback\ApiComponentBundle\Factory\Entity;

use Doctrine\Common\Persistence\ObjectManager;
use Silverback\ApiComponentBundle\Exception\InvalidEntityException;
use Silverback\ApiComponentBundle\Exception\InvalidFactoryOptionException;
use Symfony\Component\Validator\Validator\ValidatorInterface;

abstract class AbstractFactory implements FactoryInterface
{
    /**
     * @var ObjectManager
     */
    protected $manager;

    /**
     * @var null|array
     */
    protected $ops;

    /**
     * @var ValidatorInterface
     */
    private $validator;

    /**
     * @param ObjectManager $manager
     * @param ValidatorInterface $validator
     */
    public function __construct(
        ObjectManager $manager,
        ValidatorInterface $validator
    ) {
        $this->manager = $manager;
        $this->validator = $validator;
    }

    /**
     * @param $component
     * @param array|null $ops
     */
    protected function init($component, ?array $ops = null): void
    {
        $this->setOptions($ops);
        foreach ($this->ops as $op => $value) {
            if (
                null !== $value &&
                !\in_array($op, static::getIgnoreOps(), true)
            ) {
                $setter = $this->findSetterMethod($component, $op);
                if (\is_array($value)) {
                    $component->$setter(...$value);
                } else {
                    $component->$setter($value);
                }
            }
        }
        $this->manager->persist($component);
    }

    /**
     * @param $component
     * @param $op
     * @return string
     */
    private function findSetterMethod($component, $op): string
    {
        $prefixes = ['set', 'add'];
        $postfix = ucfirst($op);
        foreach ($prefixes as $prefix) {
            $setter = $prefix . $postfix;
            if (method_exists($component, $setter)) {
                return $setter;
            }
        }
        throw new \RuntimeException(sprintf('A preconfigured option `%s` has no setter or adder method', $op));
    }

    /**
     * @param array|null $ops
     * @throws \Silverback\ApiComponentBundle\Exception\InvalidFactoryOptionException
     */
    protected function setOptions(?array $ops = null): void
    {
        if (null === $ops) {
            $ops = [];
        }
        $this->ops = array_filter(
            array_merge(static::defaultOps(), $ops),
            function ($key) {
                if (!array_key_exists($key, static::defaultOps())) {
                    throw new InvalidFactoryOptionException(
                        sprintf('%s is not a valid option for the factory %s', $key, \get_class($this))
                    );
                }
                return true;
            },
            ARRAY_FILTER_USE_KEY
        );
    }

    /**
     * @param $component
     * @return bool
     * @throws \Silverback\ApiComponentBundle\Exception\InvalidEntityException
     */
    protected function validate($component): bool
    {
        $errors = $this->validator->validate($component);
        if (\count($errors)) {
            throw new InvalidEntityException($errors);
        }
        return true;
    }

    /**
     * @return array
     */
    protected static function defaultOps(): array
    {
        return [];
    }

    /**
     * @return array
     */
    protected static function getIgnoreOps(): array
    {
        return [];
    }

    /**
     * @param array|null $ops
     */
    abstract public function create(?array $ops = null);
}