Romm\Formz\Form\FormObject\FormObjectFactory

Complexity

Total Complexity

16

Size/Duplication

Total Lines	171
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	getInstanceWithFormInstance()	0	11	2
A	getInstanceWithClassName()	0	7	1
A	getProxy()	0	10	2
B	getStaticInstance()	0	31	5
A	addToGlobalConfiguration()	0	6	2
A	getCacheIdentifier()	0	6	1
A	buildStaticInstance()	0	7	1
A	getNewProxyInstance()	0	9	1
A	getGlobalConfiguration()	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\ConfigurationObject\ConfigurationObjectInterface;
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\Form\FormObject\Builder\DefaultFormObjectBuilder;
use Romm\Formz\Form\FormObject\Builder\FormObjectBuilderInterface;
use Romm\Formz\Service\CacheService;
use Romm\Formz\Service\StringService;
use Romm\Formz\Service\Traits\ExtendedSelfInstantiateTrait;
use TYPO3\CMS\Core\SingletonInterface;

/**
 * Factory class that will manage form object instances.
 *
 * You can fetch a new instance by calling one of the following methods:
 * `getInstanceFromFormInstance()` or `getInstanceFromClassName()`
 *
 * @see \Romm\Formz\Form\FormObject\FormObject
 */
class FormObjectFactory implements SingletonInterface
{
    use ExtendedSelfInstantiateTrait;

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

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

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

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

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

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

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

        return $formObject;
    }

    /**
     * Returns the proxy object for the given form object and form instance.
     *
     * Please use with caution, as this is a very low level function!
     *
     * @param FormInterface $form
     * @return FormObjectProxy
     */
    public function getProxy(FormInterface $form)
    {
        $hash = spl_object_hash($form);

        if (false === isset($this->proxy[$hash])) {
            $this->proxy[$hash] = $this->getNewProxyInstance($form);
        }

        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)) {
                $static = $cacheInstance->get($cacheIdentifier);
            } else {
                $static = $this->buildStaticInstance($className);
                $static->getObjectHash();

                $cacheInstance->set($cacheIdentifier, $static);
            }

            $this->addToGlobalConfiguration($static);

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

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

    /**
     * Adds the given form configuration to the global FormZ configuration
     * object.
     *
     * @param FormObjectStatic $static
     */
    public function addToGlobalConfiguration(FormObjectStatic $static)
    {
        if (false === $this->getGlobalConfiguration()->hasForm($static->getClassName())) {

It seems like you code against a concrete implementation and not the interface Romm\ConfigurationObject\ConfigurationObjectInterface as the method hasForm() does only exist in the following implementations of said interface: Romm\Formz\Configuration\Configuration.

            $this->getGlobalConfiguration()->addForm($static);

It seems like you code against a concrete implementation and not the interface Romm\ConfigurationObject\ConfigurationObjectInterface as the method addForm() does only exist in the following implementations of said interface: Romm\Formz\Configuration\Configuration.

        }
    }

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

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

    /**
     * Wrapper for unit tests.
     *
     * @param string $className
     * @return FormObjectStatic
     */
    protected function buildStaticInstance($className)
    {
        /** @var FormObjectBuilderInterface $builder */
        $builder = Core::instantiate(DefaultFormObjectBuilder::class);

        return $builder->getStaticInstance($className);
    }

    /**
     * Wrapper for unit tests.
     *
     * @param FormInterface $form
     * @return FormObjectProxy
     */
    protected function getNewProxyInstance(FormInterface $form)
    {
        $formObject = $this->getInstanceWithFormInstance($form);

        /** @var FormObjectProxy $formObjectProxy */
        $formObjectProxy = Core::instantiate(FormObjectProxy::class, $formObject, $form);

        return $formObjectProxy;
    }

    /**
     * @return Configuration|ConfigurationObjectInterface
     */
    protected function getGlobalConfiguration()
    {
        return ConfigurationFactory::get()->getFormzConfiguration()->getObject(true);
    }
}