UnicornFail\Emoji\Environment\Environment

Complexity

Total Complexity

51

Size/Duplication

Total Lines	398
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	addEventListener()	0	28	5
A	defaultExtensions()	0	3	1
A	addExtension()	0	22	4
A	__construct()	0	5	1
A	setEventDispatcher()	0	3	1
A	getParser()	0	7	2
A	assertUninitialized()	0	4	2
A	create()	0	9	2
A	normalizePresets()	0	30	4
A	getExtensions()	0	3	1
A	createDefaultConfiguration()	0	31	1
A	getListenersForEvent()	0	18	4
A	initializeExtensions()	0	15	4
A	dispatch()	0	17	5
A	addRenderer()	0	25	4
A	getRenderersForClass()	0	22	5
A	getRuntimeDataset()	0	7	2
A	initialize()	0	9	2
A	getConfiguration()	0	3	1

<?php

declare(strict_types=1);

/*
 * This file was originally part of the league/commonmark package.
 *
 * (c) Colin O'Dell <colinodell@gmail.com>
 *
 * Original code based on the CommonMark JS reference parser (https://bitly.com/commonmark-js)
 *  - (c) John MacFarlane
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace UnicornFail\Emoji\Environment;

use League\Configuration\Configuration;
use League\Configuration\ConfigurationAwareInterface;
use League\Configuration\ConfigurationBuilderInterface;
use League\Configuration\ConfigurationInterface;
use League\Configuration\Exception\InvalidConfigurationException;
use Nette\Schema\Expect;
use Psr\EventDispatcher\EventDispatcherInterface;
use Psr\EventDispatcher\StoppableEventInterface;
use UnicornFail\Emoji\Dataset\RuntimeDataset;
use UnicornFail\Emoji\Emojibase\EmojibaseDatasetInterface;
use UnicornFail\Emoji\Emojibase\EmojibaseShortcodeInterface;
use UnicornFail\Emoji\Event\ListenerData;
use UnicornFail\Emoji\Extension\ConfigurableExtensionInterface;
use UnicornFail\Emoji\Extension\EmojiCoreExtension;
use UnicornFail\Emoji\Extension\ExtensionInterface;
use UnicornFail\Emoji\Parser\EmojiParser;
use UnicornFail\Emoji\Parser\EmojiParserInterface;
use UnicornFail\Emoji\Parser\Lexer;
use UnicornFail\Emoji\Renderer\NodeRendererInterface;
use UnicornFail\Emoji\Util\PrioritizedList;

final class Environment implements EnvironmentBuilderInterface
{
    /** @var ConfigurationBuilderInterface */
    private $config;

    /** @var ?RuntimeDataset */
    private $dataset;

    /** @var ?EventDispatcherInterface */
    private $eventDispatcher;

    /**
     * @var ExtensionInterface[]
     *
     * @psalm-readonly-allow-private-mutation
     */
    private $extensions = [];

    /**
     * @var bool
     *
     * @psalm-readonly-allow-private-mutation
     */
    private $extensionsInitialized = false;

    /**
     * @var bool
     *
     * @psalm-readonly-allow-private-mutation
     */
    private $initialized = false;

    /**
     * @var ?PrioritizedList<ListenerData>
     *
     * @psalm-readonly-allow-private-mutation
     */
    private $listenerData;

    /** @var ?EmojiParserInterface */
    private $parser;

    /**
     * @var array<string, PrioritizedList<NodeRendererInterface>>

The doc comment array<string, PrioritizedList<NodeRendererInterface>> at position 4 could not be parsed: Expected '>' at position 4, but found 'PrioritizedList'.

     *
     * @psalm-readonly-allow-private-mutation
     */
    private $renderersByClass = [];

    /**
     * @var ExtensionInterface[]
     *
     * @psalm-readonly-allow-private-mutation
     */
    private $uninitializedExtensions = [];

    /** @var RuntimeDataset */
    private $locale;

    /**
     * @param array<string, mixed> $config
     */
    public function __construct(array $config = [])
    {
        $this->config = self::createDefaultConfiguration();
        $this->config->merge($config);
        $this->locale = new RuntimeDataset($this->config);
    }

    /**
     * @param array<string, mixed> $configuration
     */
    public static function create(array $configuration = []): self
    {
        $environment = new self($configuration);

        foreach (self::defaultExtensions() as $extension) {
            $environment->addExtension($extension);
        }

        return $environment;
    }

    public static function createDefaultConfiguration(): ConfigurationBuilderInterface
    {
        return new Configuration([
            'allow_unsafe_links' => Expect::bool(true),

            'convert' => Expect::anyOf(false, Expect::structure([
                'emoticons'     => Expect::anyOf(false, ...Lexer::TYPES)->default(Lexer::UNICODE)->nullable(),
                'html_entities' => Expect::anyOf(false, ...Lexer::TYPES)->default(Lexer::UNICODE)->nullable(),
                'shortcodes'    => Expect::anyOf(false, ...Lexer::TYPES)->default(Lexer::UNICODE)->nullable(),
                'unicodes'      => Expect::anyOf(false, ...Lexer::TYPES)->default(Lexer::UNICODE)->nullable(),
            ]))->nullable(),

            'exclude' => Expect::structure([
                'shortcodes' => Expect::arrayOf('string')
                    ->default([])
                    ->before('\UnicornFail\Emoji\Util\Normalize::shortcodes'),
            ]),

            'locale' => Expect::anyOf(...EmojibaseDatasetInterface::SUPPORTED_LOCALES)
                ->default('en')
                ->before('\UnicornFail\Emoji\Dataset\Locale'),

            'native' => Expect::bool()->nullable(),

            'presentation' => Expect::anyOf(...EmojibaseDatasetInterface::SUPPORTED_PRESENTATIONS)
                ->default(EmojibaseDatasetInterface::EMOJI),

            'preset' => Expect::arrayOf('string')
                ->default(EmojibaseShortcodeInterface::DEFAULT_PRESETS)
                ->mergeDefaults(false)
                ->before('\UnicornFail\Emoji\Environment\Environment::normalizePresets'),
        ]);
    }

    /**
     * @return ExtensionInterface[]
     */
    protected static function defaultExtensions(): iterable
    {
        return [new EmojiCoreExtension()];
    }

    /**
     * @param string|string[] $presets
     *
     * @return string[]
     */
    public static function normalizePresets($presets): array
    {
        // Presets.
        $normalized = [];
        foreach ((array) $presets as $preset) {
            if (isset(EmojibaseShortcodeInterface::PRESET_ALIASES[$preset])) {
                $normalized[] = EmojibaseShortcodeInterface::PRESET_ALIASES[$preset];
            } elseif (isset(EmojibaseShortcodeInterface::PRESETS[$preset])) {
                $normalized[] = EmojibaseShortcodeInterface::PRESETS[$preset];
            } else {
                throw InvalidConfigurationException::forConfigOption(
                    'preset',
                    $preset,
                    \sprintf(
                        'Accepted values are: %s.',
                        \implode(
                            ', ',
                            \array_map(
                                static function ($s) {
                                    return \sprintf('"%s"', $s);
                                },
                                EmojibaseShortcodeInterface::SUPPORTED_PRESETS
                            )
                        )
                    )
                );
            }
        }

        return \array_values(\array_unique($normalized));
    }

    public function addEventListener(
        string $eventClass,
        callable $listener,
        int $priority = 0
    ): EnvironmentBuilderInterface {
        $this->assertUninitialized('Failed to add event listener.');

        if ($this->listenerData === null) {
            /** @var PrioritizedList<ListenerData> $listenerData */
            $listenerData       = new PrioritizedList();
            $this->listenerData = $listenerData;
        }

        $this->listenerData->add(new ListenerData($eventClass, $listener), $priority);

        $object = \is_array($listener)
            ? $listener[0]
            : $listener;

        if ($object instanceof EnvironmentAwareInterface) {
            $object->setEnvironment($this);
        }

        if ($object instanceof ConfigurationAwareInterface) {
            $object->setConfiguration($this->getConfiguration());
        }

        return $this;
    }

    public function addExtension(ExtensionInterface $extension): EnvironmentBuilderInterface
    {
        $this->assertUninitialized('Failed to add extension.');

        $this->extensions[]              = $extension;
        $this->uninitializedExtensions[] = $extension;

        $config = $this->getConfiguration();

        if ($extension instanceof ConfigurableExtensionInterface) {
            $extension->configureSchema($config);
        }

        if ($extension instanceof EnvironmentAwareInterface) {
            $extension->setEnvironment($this);
        }

        if ($extension instanceof ConfigurationAwareInterface) {
            $extension->setConfiguration($config);
        }

        return $this;
    }

    public function addRenderer(
        string $nodeClass,
        NodeRendererInterface $renderer,
        int $priority = 0
    ): EnvironmentBuilderInterface {
        $this->assertUninitialized('Failed to add renderer.');

        if (! isset($this->renderersByClass[$nodeClass])) {
            /** @var PrioritizedList<NodeRendererInterface> $renderers */
            $renderers = new PrioritizedList();

            $this->renderersByClass[$nodeClass] = $renderers;
        }

        $this->renderersByClass[$nodeClass]->add($renderer, $priority);

        if ($renderer instanceof EnvironmentAwareInterface) {
            $renderer->setEnvironment($this);
        }

        if ($renderer instanceof ConfigurationAwareInterface) {
            $renderer->setConfiguration($this->getConfiguration());
        }

        return $this;
    }

    /**
     * @throws \RuntimeException
     */
    protected function assertUninitialized(string $message): void
    {
        if ($this->initialized) {
            throw new \RuntimeException(\sprintf('%s The Environment has already been initialized.', $message));
        }
    }

    /**
     * {@inheritDoc}
     */
    public function dispatch(object $event)
    {
        $this->initialize();

        if ($this->eventDispatcher !== null) {
            return $this->eventDispatcher->dispatch($event);
        }

        foreach ($this->getListenersForEvent($event) as $listener) {
            if ($event instanceof StoppableEventInterface && $event->isPropagationStopped()) {
                return $event;
            }

            $listener($event);
        }

        return $event;
    }

    /**
     * @return ConfigurationBuilderInterface
     */
    public function getConfiguration(): ConfigurationInterface
    {
        return $this->config;
    }

    public function getRuntimeDataset(): RuntimeDataset
    {
        if ($this->dataset === null) {
            $this->dataset = new RuntimeDataset($this->getConfiguration());
        }

        return $this->dataset;
    }

    /**
     * {@inheritDoc}
     *
     * @return ExtensionInterface[]
     */
    public function getExtensions(): iterable
    {
        return $this->extensions;
    }

    /**
     * {@inheritDoc}
     *
     * @return iterable<callable>
     */
    public function getListenersForEvent(object $event): iterable
    {
        if ($this->listenerData === null) {
            /** @var PrioritizedList<ListenerData> $listenerData */
            $listenerData       = new PrioritizedList();
            $this->listenerData = $listenerData;
        }

        /** @var ListenerData $listenerData */
        foreach ($this->listenerData as $listenerData) {
            if (! \is_a($event, $listenerData->getEvent())) {
                continue;
            }

            yield function (object $event) use ($listenerData): void {
                $this->initialize();

                \call_user_func($listenerData->getListener(), $event);
            };
        }
    }

    public function getParser(): EmojiParserInterface
    {
        if ($this->parser === null) {
            $this->parser = new EmojiParser($this);
        }

        return $this->parser;
    }

    /**
     * {@inheritDoc}
     *
     * @return PrioritizedList<NodeRendererInterface>
     */
    public function getRenderersForClass(string $nodeClass): iterable
    {
        $this->initialize();

        // If renderers are defined for this specific class, return them immediately
        if (isset($this->renderersByClass[$nodeClass])) {
            return $this->renderersByClass[$nodeClass];
        }

        while (\class_exists($parent = (string) ($parent ?? $nodeClass)) && ($parent = \get_parent_class($parent))) {
            if (! isset($this->renderersByClass[$parent])) {
                continue;
            }

            // "Cache" this result to avoid future loops
            return $this->renderersByClass[$nodeClass] = $this->renderersByClass[$parent];
        }

        /** @var PrioritizedList<NodeRendererInterface> $renderers */
        $renderers = new PrioritizedList();

        return $renderers;
    }

    protected function initialize(): void
    {
        if ($this->initialized) {
            return;
        }

        $this->initializeExtensions();

        $this->initialized = true;
    }

    protected function initializeExtensions(): void
    {
        if ($this->extensionsInitialized) {
            return;
        }

        // Ask all extensions to register their components.
        while (\count($this->uninitializedExtensions) > 0) {
            foreach ($this->uninitializedExtensions as $i => $extension) {
                $extension->register($this);
                unset($this->uninitializedExtensions[$i]);
            }
        }

        $this->extensionsInitialized = true;
    }

    public function setEventDispatcher(EventDispatcherInterface $dispatcher): void
    {
        $this->eventDispatcher = $dispatcher;
    }
}