Environment::getInlineParserCharacterRegex() - Code Metrics - Inspection of "Merge branch '1.5' into latest" - thephpleague/commonmark - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — latest ( ba39d8...ca9086 )

by Colin

created 2020-08-18 01:52 UTC

Environment::getInlineParserCharacterRegex() A

↳ Parent: Environment

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
eloc	1
dl	0
loc	3
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0
crap	1

<?php

declare(strict_types=1);

/*
 * This file is part of the league/commonmark package.
 *
 * (c) Colin O'Dell <[email protected]>
 *
 * 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 League\CommonMark\Environment;

use League\CommonMark\Configuration\Configuration;
use League\CommonMark\Configuration\ConfigurationAwareInterface;
use League\CommonMark\Delimiter\Processor\DelimiterProcessorCollection;
use League\CommonMark\Delimiter\Processor\DelimiterProcessorInterface;
use League\CommonMark\Event\AbstractEvent;
use League\CommonMark\Extension\CommonMark\CommonMarkCoreExtension;
use League\CommonMark\Extension\ExtensionInterface;
use League\CommonMark\Extension\GithubFlavoredMarkdownExtension;
use League\CommonMark\Parser\Block\BlockStartParserInterface;
use League\CommonMark\Parser\Inline\InlineParserInterface;
use League\CommonMark\Renderer\NodeRendererInterface;
use League\CommonMark\Util\HtmlFilter;
use League\CommonMark\Util\PrioritizedList;

final class Environment implements ConfigurableEnvironmentInterface
{
    /**
     * @var ExtensionInterface[]
     *
     * @psalm-readonly-allow-private-mutation
     */
    private $extensions = [];

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

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

    /**
     * @var PrioritizedList<BlockStartParserInterface>
     *
     * @psalm-readonly
     */
    private $blockStartParsers;

    /**
     * @var PrioritizedList<InlineParserInterface>
     *
     * @psalm-readonly
     */
    private $inlineParsers;

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

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

    /**
     * @var DelimiterProcessorCollection
     *
     * @psalm-readonly
     */
    private $delimiterProcessors;

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

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

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

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

    /**
     * @var Configuration
     *
     * @psalm-readonly
     */
    private $config;

    /**
     * @var string
     *
     * @psalm-readonly-allow-private-mutation
     */
    private $inlineParserCharacterRegex;

    /**
     * @param array<string, mixed> $config
     */
    public function __construct(array $config = [])
    {
        $this->config = new Configuration($config);

        $this->blockStartParsers   = new PrioritizedList();
        $this->inlineParsers       = new PrioritizedList();
        $this->delimiterProcessors = new DelimiterProcessorCollection();
    }

    /**
     * {@inheritdoc}
     */
    public function mergeConfig(array $config = []): void
    {
        $this->assertUninitialized('Failed to modify configuration.');

        $this->config->merge($config);
    }

    /**
     * {@inheritdoc}
     */
    public function setConfig(array $config = []): void
    {
        $this->assertUninitialized('Failed to modify configuration.');

        $this->config->replace($config);
    }

    /**
     * {@inheritdoc}
     */
    public function getConfig($key = null, $default = null)
    {
        return $this->config->get($key, $default);
    }

    public function addBlockStartParser(BlockStartParserInterface $parser, int $priority = 0): ConfigurableEnvironmentInterface
    {
        $this->assertUninitialized('Failed to add block start parser.');

        $this->blockStartParsers->add($parser, $priority);
        $this->injectEnvironmentAndConfigurationIfNeeded($parser);

        return $this;
    }

    public function addInlineParser(InlineParserInterface $parser, int $priority = 0): ConfigurableEnvironmentInterface
    {
        $this->assertUninitialized('Failed to add inline parser.');

        $this->inlineParsers->add($parser, $priority);
        $this->injectEnvironmentAndConfigurationIfNeeded($parser);

        foreach ($parser->getCharacters() as $character) {
            if (! isset($this->inlineParsersByCharacter[$character])) {
                $this->inlineParsersByCharacter[$character] = new PrioritizedList();
            }

            $this->inlineParsersByCharacter[$character]->add($parser, $priority);
        }

        return $this;
    }

    public function addDelimiterProcessor(DelimiterProcessorInterface $processor): ConfigurableEnvironmentInterface
    {
        $this->assertUninitialized('Failed to add delimiter processor.');
        $this->delimiterProcessors->add($processor);
        $this->injectEnvironmentAndConfigurationIfNeeded($processor);

        return $this;
    }

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

        if (! isset($this->renderersByClass[$nodeClass])) {
            $this->renderersByClass[$nodeClass] = new PrioritizedList();
        }

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

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function getBlockStartParsers(): iterable
    {
        if (! $this->extensionsInitialized) {
            $this->initializeExtensions();
        }

        return $this->blockStartParsers->getIterator();
    }

    /**
     * {@inheritdoc}
     */
    public function getInlineParsersForCharacter(string $character): iterable
    {
        if (! $this->extensionsInitialized) {
            $this->initializeExtensions();
        }

        if (! isset($this->inlineParsersByCharacter[$character])) {
            return [];
        }

        return $this->inlineParsersByCharacter[$character]->getIterator();
    }

    public function getDelimiterProcessors(): DelimiterProcessorCollection
    {
        if (! $this->extensionsInitialized) {
            $this->initializeExtensions();
        }

        return $this->delimiterProcessors;
    }

    /**
     * {@inheritdoc}
     */
    public function getRenderersForClass(string $nodeClass): iterable
    {
        if (! $this->extensionsInitialized) {
            $this->initializeExtensions();
        }

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

        /** @psalm-suppress TypeDoesNotContainType -- Bug: https://github.com/vimeo/psalm/issues/3332 */
        while (\class_exists($parent = $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];
        }

        return [];
    }

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

    /**
     * Add a single extension
     *
     * @return $this
     */
    public function addExtension(ExtensionInterface $extension): ConfigurableEnvironmentInterface
    {
        $this->assertUninitialized('Failed to add extension.');

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

        return $this;
    }

    private function initializeExtensions(): void
    {
        // 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;

        // Lastly, let's build a regex which matches non-inline characters
        // This will enable a huge performance boost with inline parsing
        $this->buildInlineParserCharacterRegex();
    }

    private function injectEnvironmentAndConfigurationIfNeeded(object $object): void
    {
        if ($object instanceof EnvironmentAwareInterface) {
            $object->setEnvironment($this);
        }

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

    public static function createCommonMarkEnvironment(): ConfigurableEnvironmentInterface
    {
        $environment = new static();
        $environment->addExtension(new CommonMarkCoreExtension());
        $environment->mergeConfig([
            'renderer' => [
                'block_separator' => "\n",
                'inner_separator' => "\n",
                'soft_break'      => "\n",
            ],
            'html_input'         => HtmlFilter::ALLOW,
            'allow_unsafe_links' => true,
            'max_nesting_level'  => \INF,
        ]);

        return $environment;
    }

    public static function createGFMEnvironment(): ConfigurableEnvironmentInterface
    {
        $environment = self::createCommonMarkEnvironment();
        $environment->addExtension(new GithubFlavoredMarkdownExtension());

        return $environment;
    }

    public function getInlineParserCharacterRegex(): string
    {
        return $this->inlineParserCharacterRegex;
    }

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

        if (! isset($this->listeners[$eventClass])) {
            $this->listeners[$eventClass] = new PrioritizedList();
        }

        $this->listeners[$eventClass]->add($listener, $priority);

        if (\is_object($listener)) {
            $this->injectEnvironmentAndConfigurationIfNeeded($listener);
        } elseif (\is_array($listener) && \is_object($listener[0])) {
            $this->injectEnvironmentAndConfigurationIfNeeded($listener[0]);
        }

        return $this;
    }

    public function dispatch(AbstractEvent $event): void
    {
        if (! $this->extensionsInitialized) {
            $this->initializeExtensions();
        }

        $type = \get_class($event);

        foreach ($this->listeners[$type] ?? [] as $listener) {
            if ($event->isPropagationStopped()) {
                return;
            }

            $listener($event);
        }
    }

    private function buildInlineParserCharacterRegex(): void
    {
        $chars = \array_unique(\array_merge(
            \array_keys($this->inlineParsersByCharacter),
            $this->delimiterProcessors->getDelimiterCharacters()
        ));

        if (\count($chars) === 0) {
            // If no special inline characters exist then parse the whole line
            $this->inlineParserCharacterRegex = '/^.+$/';
        } else {
            // Match any character which inline parsers are not interested in
            $this->inlineParserCharacterRegex = '/^[^' . \preg_quote(\implode('', $chars), '/') . ']+/';

            // Only add the u modifier (which slows down performance) if we have a multi-byte UTF-8 character in our regex
            if (\strlen($this->inlineParserCharacterRegex) > \mb_strlen($this->inlineParserCharacterRegex)) {
                $this->inlineParserCharacterRegex .= 'u';
            }
        }
    }

    /**
     * @throws \RuntimeException
     */
    private function assertUninitialized(string $message): void
    {
        if ($this->extensionsInitialized) {
            throw new \RuntimeException($message . ' Extensions have already been initialized.');
        }
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		/*
6		* This file is part of the league/commonmark package.
7		*
8		* (c) Colin O'Dell <[email protected]>
9		*
10		* Original code based on the CommonMark JS reference parser (https://bitly.com/commonmark-js)
11		* - (c) John MacFarlane
12		*
13		* For the full copyright and license information, please view the LICENSE
14		* file that was distributed with this source code.
15		*/
16
17		namespace League\CommonMark\Environment;
18
19		use League\CommonMark\Configuration\Configuration;
20		use League\CommonMark\Configuration\ConfigurationAwareInterface;
21		use League\CommonMark\Delimiter\Processor\DelimiterProcessorCollection;
22		use League\CommonMark\Delimiter\Processor\DelimiterProcessorInterface;
23		use League\CommonMark\Event\AbstractEvent;
24		use League\CommonMark\Extension\CommonMark\CommonMarkCoreExtension;
25		use League\CommonMark\Extension\ExtensionInterface;
26		use League\CommonMark\Extension\GithubFlavoredMarkdownExtension;
27		use League\CommonMark\Parser\Block\BlockStartParserInterface;
28		use League\CommonMark\Parser\Inline\InlineParserInterface;
29		use League\CommonMark\Renderer\NodeRendererInterface;
30		use League\CommonMark\Util\HtmlFilter;
31		use League\CommonMark\Util\PrioritizedList;
32
33		final class Environment implements ConfigurableEnvironmentInterface
34		{
35		/**
36		* @var ExtensionInterface[]
37		*
38		* @psalm-readonly-allow-private-mutation
39		*/
40		private $extensions = [];
41
42		/**
43		* @var ExtensionInterface[]
44		*
45		* @psalm-readonly-allow-private-mutation
46		*/
47		private $uninitializedExtensions = [];
48
49		/**
50		* @var bool
51		*
52		* @psalm-readonly-allow-private-mutation
53		*/
54		private $extensionsInitialized = false;
55
56		/**
57		* @var PrioritizedList<BlockStartParserInterface>
58		*
59		* @psalm-readonly
60		*/
61		private $blockStartParsers;
62
63		/**
64		* @var PrioritizedList<InlineParserInterface>
65		*
66		* @psalm-readonly
67		*/
68		private $inlineParsers;
69
70		/**
71		* @var array<string, PrioritizedList<InlineParserInterface>>
		0 ignored issues – show Documentation Bug introduced 2020-06-27 13:42 UTC by Report Bug Copy Issue Report The doc comment `array<string, Prioritize...InlineParserInterface>>` at position `4` could not be parsed: Expected '>' at position 4, but found 'PrioritizedList'. Loading history...
72		*
73		* @psalm-readonly-allow-private-mutation
74		*/
75		private $inlineParsersByCharacter = [];
76
77		/**
78		* @var DelimiterProcessorCollection
79		*
80		* @psalm-readonly
81		*/
82		private $delimiterProcessors;
83
84		/**
85		* @var array<string, PrioritizedList<NodeRendererInterface>>
		0 ignored issues – show Documentation Bug introduced 2020-06-27 13:42 UTC by Report Bug Copy Issue Report The doc comment `array<string, Prioritize...NodeRendererInterface>>` at position `4` could not be parsed: Expected '>' at position 4, but found 'PrioritizedList'. Loading history...
86		*
87		* @psalm-readonly-allow-private-mutation
88		*/
89		private $renderersByClass = [];
90
91		/**
92		* @var array<string, PrioritizedList<callable>>
		0 ignored issues – show Documentation Bug introduced 2020-06-27 13:42 UTC by Report Bug Copy Issue Report The doc comment `array<string, PrioritizedList<callable>>` at position `4` could not be parsed: Expected '>' at position 4, but found 'PrioritizedList'. Loading history...
93		*
94		* @psalm-readonly-allow-private-mutation
95		*/
96		private $listeners = [];
97
98		/**
99		* @var Configuration
100		*
101		* @psalm-readonly
102		*/
103		private $config;
104
105		/**
106		* @var string
107		*
108		* @psalm-readonly-allow-private-mutation
109		*/
110		private $inlineParserCharacterRegex;
111
112		/**
113		* @param array<string, mixed> $config
114		*/
115	2970	public function __construct(array $config = [])
116		{
117	2970	$this->config = new Configuration($config);
118
119	2970	$this->blockStartParsers = new PrioritizedList();
120	2970	$this->inlineParsers = new PrioritizedList();
121	2970	$this->delimiterProcessors = new DelimiterProcessorCollection();
122	2970	}
123
124		/**
125		* {@inheritdoc}
126		*/
127	2862	public function mergeConfig(array $config = []): void
128		{
129	2862	$this->assertUninitialized('Failed to modify configuration.');
130
131	2859	$this->config->merge($config);
132	2859	}
133
134		/**
135		* {@inheritdoc}
136		*/
137	18	public function setConfig(array $config = []): void
138		{
139	18	$this->assertUninitialized('Failed to modify configuration.');
140
141	15	$this->config->replace($config);
142	15	}
143
144		/**
145		* {@inheritdoc}
146		*/
147	2868	public function getConfig($key = null, $default = null)
148		{
149	2868	return $this->config->get($key, $default);
150		}
151
152	2850	public function addBlockStartParser(BlockStartParserInterface $parser, int $priority = 0): ConfigurableEnvironmentInterface
153		{
154	2850	$this->assertUninitialized('Failed to add block start parser.');
155
156	2847	$this->blockStartParsers->add($parser, $priority);
157	2847	$this->injectEnvironmentAndConfigurationIfNeeded($parser);
158
159	2847	return $this;
160		}
161
162	2862	public function addInlineParser(InlineParserInterface $parser, int $priority = 0): ConfigurableEnvironmentInterface
163		{
164	2862	$this->assertUninitialized('Failed to add inline parser.');
165
166	2859	$this->inlineParsers->add($parser, $priority);
167	2859	$this->injectEnvironmentAndConfigurationIfNeeded($parser);
168
169	2859	foreach ($parser->getCharacters() as $character) {
170	2856	if (! isset($this->inlineParsersByCharacter[$character])) {
171	2856	$this->inlineParsersByCharacter[$character] = new PrioritizedList();
172		}
173
174	2856	$this->inlineParsersByCharacter[$character]->add($parser, $priority);
175		}
176
177	2859	return $this;
178		}
179
180	2853	public function addDelimiterProcessor(DelimiterProcessorInterface $processor): ConfigurableEnvironmentInterface
181		{
182	2853	$this->assertUninitialized('Failed to add delimiter processor.');
183	2850	$this->delimiterProcessors->add($processor);
184	2850	$this->injectEnvironmentAndConfigurationIfNeeded($processor);
185
186	2850	return $this;
187		}
188
189	2871	public function addRenderer(string $nodeClass, NodeRendererInterface $renderer, int $priority = 0): ConfigurableEnvironmentInterface
190		{
191	2871	$this->assertUninitialized('Failed to add renderer.');
192
193	2868	if (! isset($this->renderersByClass[$nodeClass])) {
194	2868	$this->renderersByClass[$nodeClass] = new PrioritizedList();
195		}
196
197	2868	$this->renderersByClass[$nodeClass]->add($renderer, $priority);
198	2868	$this->injectEnvironmentAndConfigurationIfNeeded($renderer);
199
200	2868	return $this;
201		}
202
203		/**
204		* {@inheritdoc}
205		*/
206	2241	public function getBlockStartParsers(): iterable
207		{
208	2241	if (! $this->extensionsInitialized) {
209	33	$this->initializeExtensions();
210		}
211
212	2241	return $this->blockStartParsers->getIterator();
213		}
214
215		/**
216		* {@inheritdoc}
217		*/
218	2568	public function getInlineParsersForCharacter(string $character): iterable
219		{
220	2568	if (! $this->extensionsInitialized) {
221	24	$this->initializeExtensions();
222		}
223
224	2568	if (! isset($this->inlineParsersByCharacter[$character])) {
225	2430	return [];
226		}
227
228	1467	return $this->inlineParsersByCharacter[$character]->getIterator();
229		}
230
231	2553	public function getDelimiterProcessors(): DelimiterProcessorCollection
232		{
233	2553	if (! $this->extensionsInitialized) {
234	6	$this->initializeExtensions();
235		}
236
237	2553	return $this->delimiterProcessors;
238		}
239
240		/**
241		* {@inheritdoc}
242		*/
243	2859	public function getRenderersForClass(string $nodeClass): iterable
244		{
245	2859	if (! $this->extensionsInitialized) {
246	30	$this->initializeExtensions();
247		}
248
249		// If renderers are defined for this specific class, return them immediately
250	2859	if (isset($this->renderersByClass[$nodeClass])) {
251	2850	return $this->renderersByClass[$nodeClass];
252		}
253
254		/** @psalm-suppress TypeDoesNotContainType -- Bug: https://github.com/vimeo/psalm/issues/3332 */
255	60	while (\class_exists($parent = $parent ?? $nodeClass) && $parent = \get_parent_class($parent)) {
256	54	if (! isset($this->renderersByClass[$parent])) {
257	6	continue;
258		}
259
260		// "Cache" this result to avoid future loops
261	51	return $this->renderersByClass[$nodeClass] = $this->renderersByClass[$parent];
262		}
263
264	9	return [];
265		}
266
267		/**
268		* Get all registered extensions
269		*
270		* @return ExtensionInterface[]
271		*/
272	12	public function getExtensions(): iterable
273		{
274	12	return $this->extensions;
275		}
276
277		/**
278		* Add a single extension
279		*
280		* @return $this
281		*/
282	2865	public function addExtension(ExtensionInterface $extension): ConfigurableEnvironmentInterface
283		{
284	2865	$this->assertUninitialized('Failed to add extension.');
285
286	2862	$this->extensions[] = $extension;
287	2862	$this->uninitializedExtensions[] = $extension;
288
289	2862	return $this;
290		}
291
292	2940	private function initializeExtensions(): void
293		{
294		// Ask all extensions to register their components
295	2940	while (\count($this->uninitializedExtensions) > 0) {
296	2844	foreach ($this->uninitializedExtensions as $i => $extension) {
297	2844	$extension->register($this);
298	2844	unset($this->uninitializedExtensions[$i]);
299		}
300		}
301
302	2937	$this->extensionsInitialized = true;
303
304		// Lastly, let's build a regex which matches non-inline characters
305		// This will enable a huge performance boost with inline parsing
306	2937	$this->buildInlineParserCharacterRegex();
307	2937	}
308
309	2910	private function injectEnvironmentAndConfigurationIfNeeded(object $object): void
310		{
311	2910	if ($object instanceof EnvironmentAwareInterface) {
312	2856	$object->setEnvironment($this);
313		}
314
315	2910	if ($object instanceof ConfigurationAwareInterface) {
316	2856	$object->setConfiguration($this->config);
317		}
318	2910	}
319
320	2853	public static function createCommonMarkEnvironment(): ConfigurableEnvironmentInterface
321		{
322	2853	$environment = new static();
323	2853	$environment->addExtension(new CommonMarkCoreExtension());
324	2853	$environment->mergeConfig([
325	951	'renderer' => [
326	1902	'block_separator' => "\n",
327		'inner_separator' => "\n",
328		'soft_break' => "\n",
329		],
330	2853	'html_input' => HtmlFilter::ALLOW,
331		'allow_unsafe_links' => true,
332		'max_nesting_level' => \INF,
333		]);
334
335	2853	return $environment;
336		}
337
338	150	public static function createGFMEnvironment(): ConfigurableEnvironmentInterface
339		{
340	150	$environment = self::createCommonMarkEnvironment();
341	150	$environment->addExtension(new GithubFlavoredMarkdownExtension());
342
343	150	return $environment;
344		}
345
346	2418	public function getInlineParserCharacterRegex(): string
347		{
348	2418	return $this->inlineParserCharacterRegex;
349		}
350
351	579	public function addEventListener(string $eventClass, callable $listener, int $priority = 0): ConfigurableEnvironmentInterface
352		{
353	579	$this->assertUninitialized('Failed to add event listener.');
354
355	576	if (! isset($this->listeners[$eventClass])) {
356	576	$this->listeners[$eventClass] = new PrioritizedList();
357		}
358
359	576	$this->listeners[$eventClass]->add($listener, $priority);
360
361	576	if (\is_object($listener)) {
362	510	$this->injectEnvironmentAndConfigurationIfNeeded($listener);
363	153	} elseif (\is_array($listener) && \is_object($listener[0])) {
364	153	$this->injectEnvironmentAndConfigurationIfNeeded($listener[0]);
365		}
366
367	576	return $this;
368		}
369
370	2847	public function dispatch(AbstractEvent $event): void
371		{
372	2847	if (! $this->extensionsInitialized) {
373	2847	$this->initializeExtensions();
374		}
375
376	2844	$type = \get_class($event);
377
378	2844	foreach ($this->listeners[$type] ?? [] as $listener) {
379	573	if ($event->isPropagationStopped()) {
380	3	return;
381		}
382
383	573	$listener($event);
384		}
385	2841	}
386
387	2937	private function buildInlineParserCharacterRegex(): void
388		{
389	2937	$chars = \array_unique(\array_merge(
390	2937	\array_keys($this->inlineParsersByCharacter),
391	2937	$this->delimiterProcessors->getDelimiterCharacters()
392		));
393
394	2937	if (\count($chars) === 0) {
395		// If no special inline characters exist then parse the whole line
396	78	$this->inlineParserCharacterRegex = '/^.+$/';
397		} else {
398		// Match any character which inline parsers are not interested in
399	2859	$this->inlineParserCharacterRegex = '/^[^' . \preg_quote(\implode('', $chars), '/') . ']+/';
400
401		// Only add the u modifier (which slows down performance) if we have a multi-byte UTF-8 character in our regex
402	2859	if (\strlen($this->inlineParserCharacterRegex) > \mb_strlen($this->inlineParserCharacterRegex)) {
403	54	$this->inlineParserCharacterRegex .= 'u';
404		}
405		}
406	2937	}
407
408		/**
409		* @throws \RuntimeException
410		*/
411	2958	private function assertUninitialized(string $message): void
412		{
413	2958	if ($this->extensionsInitialized) {
414	24	throw new \RuntimeException($message . ' Extensions have already been initialized.');
415		}
416	2934	}
417		}
418

thephpleague / commonmark

Push — latest ( ba39d8...ca9086 )

Environment::getInlineParserCharacterRegex() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like