CuyZ\Notiz\Core\Definition\Tree\EventGroup\Event\Connection\Hook

Complexity

Total Complexity

16

Size/Duplication

Total Lines	165
Duplicated Lines	0 %

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getPath()	0	3	1
A	anotherNonUsefulSystem()	0	10	1
A	injectHookInGlobalArray()	0	7	1
A	getTypoScriptFrontendController()	0	3	1
A	getFullPath()	0	3	1
A	preventEvalNeverIdealStuff()	0	26	6
A	register()	0	17	4
A	hookIsRegistered()	0	3	1

<?php
declare(strict_types=1);

/*
 * Copyright (C)
 * Nathan Boiron <nathan.boiron@gmail.com>
 * Romain Canon <romain.hydrocanon@gmail.com>
 *
 * This file is part of the TYPO3 NotiZ 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 CuyZ\Notiz\Core\Definition\Tree\EventGroup\Event\Connection;

use Closure;
use CuyZ\Notiz\Core\Definition\Tree\AbstractDefinitionComponent;
use CuyZ\Notiz\Core\Event\Runner\EventRunner;
use CuyZ\Notiz\Core\Event\Runner\EventRunnerContainer;
use CuyZ\Notiz\Core\Exception\ClassNotFoundException;
use CuyZ\Notiz\Core\Exception\WrongFormatException;
use TYPO3\CMS\Core\Utility\ArrayUtility;
use TYPO3\CMS\Frontend\Controller\TypoScriptFrontendController;

The type TYPO3\CMS\Frontend\Controller\TypoScriptFrontendController was not found. Maybe you did not declare it correctly or list all dependencies?

class Hook extends AbstractDefinitionComponent implements Connection
{
    const INTERNAL_HOOK_KEY = '__notiz';

    /**
     * @var string
     *
     * @validate NotEmpty
     */
    protected $path;

    /**
     * @var string
     *
     * @validate Romm.ConfigurationObject:ClassExists
     */
    protected $interface;

    /**
     * @var string
     *
     * @validate RegularExpression(regularExpression=/^[_a-zA-Z]+\w*$/)
     */
    protected $method;

    /**
     * @return string
     */
    public function getPath(): string
    {
        return $this->path;
    }

    /**
     * Registers the hook in TYPO3.
     *
     * Two registration methods exist. The first one is pretty clean, the other
     * probably already killed dozens of puppies.
     *
     * @param EventRunner $eventRunner
     */
    public function register(EventRunner $eventRunner)
    {
        if ($this->hookIsRegistered()) {
            return;
        }

        if (!empty($this->interface)
            || !empty($this->method)
        ) {
            $closure = $this->preventEvalNeverIdealStuff($eventRunner);
        } else {
            $closure = function () use ($eventRunner) {
                return call_user_func_array($eventRunner->getCallable(), func_get_args());
            };
        }

        $this->injectHookInGlobalArray($closure);
    }

    /**
     * @param Closure|string $closure
     */
    protected function injectHookInGlobalArray($closure)
    {
        $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS'] = ArrayUtility::setValueByPath(
            $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS'],
            $this->getFullPath(),
            $closure,
            '|'
        );
    }

    /**
     * This method is called when a hook is bound to a class that must implement
     * an interface.
     *
     * In this case, to keep the handling we need to dynamically create some
     * proxy class that will call the internal API itself.
     *
     * If you don't want to lose your faith in humanity, you probably should not
     * read the code below. Really.
     *
     * @param EventRunner $eventRunner
     * @return string
     *
     * @throws ClassNotFoundException
     * @throws WrongFormatException
     */
    protected function preventEvalNeverIdealStuff(EventRunner $eventRunner): string
    {
        $className = 'notiz_hook_' . sha1($eventRunner->getEventDefinition()->getFullIdentifier());

        $implements = $this->interface
            ? 'implements ' . $this->interface
            : '';

        $method = $this->method ?: 'run';

        if ($this->interface
            && !interface_exists($this->interface)
        ) {
            throw ClassNotFoundException::eventHookInterfaceNotFound($this->interface, $this);
        }

        if (!preg_match('/^[_a-zA-Z]+\w*$/', $method)) {
            throw WrongFormatException::eventHookMethodNameWrongFormat($method, $this);
        }

        $classPhpCode = $this->anotherNonUsefulSystem($className, $implements, $method, $eventRunner);

        // Please lord, forgive me.
        eval($classPhpCode);

The use of eval() is discouraged.

        return $className;
    }

    /**
     * @see \CuyZ\Notiz\Core\Definition\Tree\EventGroup\Event\Connection\Hook::preventEvalNeverIdealStuff
     *
     * @param string $className
     * @param string $implements
     * @param string $method
     * @param EventRunner $eventRunner
     * @return string
     */
    protected function anotherNonUsefulSystem(string $className, string $implements, string $method, EventRunner $eventRunner): string
    {
        $eventRunnerContainerClass = EventRunnerContainer::class;

        return <<<PHP
class $className $implements
{
    public function $method(...\$arguments)
    {
        \$eventRunner = $eventRunnerContainerClass::getInstance()->get('{$eventRunner->getEventDefinition()->getFullIdentifier()}');

        call_user_func_array(\$eventRunner->getCallable(), \$arguments);
    }
}
PHP;
    }

    /**
     * @return bool
     */
    protected function hookIsRegistered(): bool
    {
        return ArrayUtility::isValidPath($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS'], $this->getFullPath(), '|');
    }

    /**
     * @return string
     */
    protected function getFullPath(): string
    {
        return $this->path . '|' . self::INTERNAL_HOOK_KEY;
    }

    /**
     * @return TypoScriptFrontendController
     */
    protected function getTypoScriptFrontendController(): TypoScriptFrontendController
    {
        return $GLOBALS['TSFE'];
    }
}