Romm\Formz\Form\FormObject\FormObjectFactory

Complexity

Total Complexity

21

Size/Duplication

Total Lines	209
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	13

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	getInstanceFromClassName()	0	7	1
A	getInstanceFromFormInstance()	0	13	2
A	getProxy()	0	12	2
B	getStaticInstance()	0	36	6
A	createInstance()	0	13	1
B	insertObjectProperties()	0	24	6
A	getCacheIdentifier()	0	6	1
A	injectConfigurationFactory()	0	4	1
A	injectTypoScriptService()	0	4	1

<?php
/*
 * 2017 Romain CANON <romain.hydrocanon@gmail.com>
 *
 * This file is part of the TYPO3 FormZ project.
 * It is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License, either
 * version 3 of the License, or any later version.
 *
 * For the full copyright and license information, see:
 * http://www.gnu.org/licenses/gpl-3.0.html
 */

namespace Romm\Formz\Form\FormObject;

use Romm\Formz\Configuration\Configuration;
use Romm\Formz\Configuration\ConfigurationFactory;
use Romm\Formz\Core\Core;
use Romm\Formz\Exceptions\ClassNotFoundException;
use Romm\Formz\Exceptions\InvalidArgumentTypeException;
use Romm\Formz\Form\FormInterface;
use Romm\Formz\Service\CacheService;
use Romm\Formz\Service\StringService;
use Romm\Formz\Service\Traits\ExtendedSelfInstantiateTrait;
use Romm\Formz\Service\TypoScriptService;
use TYPO3\CMS\Core\SingletonInterface;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Extbase\Reflection\ReflectionService;

/**
 * Factory class which will manage instances of `FormObject`.
 */
class FormObjectFactory implements SingletonInterface
{
    use ExtendedSelfInstantiateTrait;

    const IGNORE_PROPERTY = 'formz-ignore';

    /**
     * @var ConfigurationFactory
     */
    protected $configurationFactory;

    /**
     * @var TypoScriptService
     */
    protected $typoScriptService;

    /**
     * @var FormObject[]
     */
    protected $instances = [];

    /**
     * @var FormObjectStatic[]
     */
    protected $static = [];

    /**
     * @var FormObjectProxy[]
     */
    protected $proxy = [];

    /**
     * @var array
     */
    private static $ignoredProperties = ['validationData', 'uid', 'pid', '_localizedUid', '_languageUid', '_versionedUid'];

    /**
     * Will create an instance of `FormObject` based on a class which implements
     * the interface `FormInterface`.
     *
     * @param string $className
     * @param string $name
     * @return FormObject
     */
    public function getInstanceFromClassName($className, $name)
    {
        /** @var FormObject $formObject */
        $formObject = Core::instantiate(FormObject::class, $name, $this->getStaticInstance($className));

        return $formObject;
    }

    /**
     * @param FormInterface $form
     * @param string        $name
     * @return FormObject
     */
    public function getInstanceFromFormInstance(FormInterface $form, $name = 'defaultName')
    {
        $hash = spl_object_hash($form);

        if (false === isset($this->instances[$hash])) {
            $formObject = $this->getInstanceFromClassName(get_class($form), $name);
            $formObject->setForm($form);

            $this->instances[$hash] = $formObject;
        }

        return $this->instances[$hash];
    }

    /**
     * @param FormObject    $formObject
     * @param FormInterface $form
     * @return FormObjectProxy
     */
    public function getProxy(FormObject $formObject, FormInterface $form)
    {
        $hash = spl_object_hash($form);

        if (false === isset($this->proxy[$hash])) {
            $proxy = Core::instantiate(FormObjectProxy::class, $formObject, $form);

            $this->proxy[$hash] = $proxy;
        }

        return $this->proxy[$hash];
    }

    /**
     * @param string $className
     * @return FormObjectStatic
     * @throws ClassNotFoundException
     * @throws InvalidArgumentTypeException
     */
    protected function getStaticInstance($className)
    {
        if (false === class_exists($className)) {
            throw ClassNotFoundException::wrongFormClassName($className);
        }

        if (false === in_array(FormInterface::class, class_implements($className))) {
            throw InvalidArgumentTypeException::wrongFormType($className);
        }

        $cacheIdentifier = $this->getCacheIdentifier($className);

        if (false === isset($this->static[$cacheIdentifier])) {
            $cacheInstance = CacheService::get()->getCacheInstance();

            if ($cacheInstance->has($cacheIdentifier)) {
                $instance = $cacheInstance->get($cacheIdentifier);
            } else {
                $instance = $this->createInstance($className);
                $cacheInstance->set($cacheIdentifier, $instance);
            }

            /** @var Configuration $formzConfigurationObject */
            $formzConfigurationObject = $this->configurationFactory
                ->getFormzConfiguration()
                ->getObject(true);

            if (false === $formzConfigurationObject->hasForm($className)) {
                $formzConfigurationObject->addForm($instance);
            }

            $this->static[$cacheIdentifier] = $instance;
        }

        return $this->static[$cacheIdentifier];
    }

    /**
     * Creates and initializes a new `StaticFormObject` instance.
     *
     * @param string $className
     * @return FormObjectStatic
     */
    protected function createInstance($className)
    {
        $formConfiguration = $this->typoScriptService->getFormConfiguration($className);

        /** @var FormObjectStatic $instance */
        $instance = Core::instantiate(FormObjectStatic::class, $className, $formConfiguration);

        $this->insertObjectProperties($instance);

        $instance->getObjectHash();

        return $instance;
    }

    /**
     * Will insert all the accessible properties of the given instance.
     *
     * @param FormObjectStatic $instance
     */
    protected function insertObjectProperties(FormObjectStatic $instance)
    {
        $className = $instance->getClassName();

        /** @var ReflectionService $reflectionService */
        $reflectionService = GeneralUtility::makeInstance(ReflectionService::class);
        $reflectionProperties = $reflectionService->getClassPropertyNames($className);

        $classReflection = new \ReflectionClass($className);
        $publicProperties = $classReflection->getProperties(\ReflectionProperty::IS_PUBLIC);

        foreach ($reflectionProperties as $property) {
            if (false === in_array($property, self::$ignoredProperties)
                && false === $reflectionService->isPropertyTaggedWith($className, $property, self::IGNORE_PROPERTY)
                && ((true === in_array($property, $publicProperties))
                    || $reflectionService->hasMethod($className, 'get' . ucfirst($property))
                )
            ) {
                $instance->addProperty($property);
            }
        }

        unset($publicProperties);
    }

    /**
     * @param string $className
     * @return string
     */
    protected function getCacheIdentifier($className)
    {
        $sanitizedClassName = StringService::get()->sanitizeString(str_replace('\\', '-', $className));

        return 'form-object-' . $sanitizedClassName;
    }

    /**
     * @param ConfigurationFactory $configurationFactory
     */
    public function injectConfigurationFactory(ConfigurationFactory $configurationFactory)
    {
        $this->configurationFactory = $configurationFactory;
    }

    /**
     * @param TypoScriptService $typoScriptService
     */
    public function injectTypoScriptService(TypoScriptService $typoScriptService)
    {
        $this->typoScriptService = $typoScriptService;
    }
}