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\Delimiter\DelimiterParser; |
20
|
|
|
use League\CommonMark\Delimiter\Processor\DelimiterProcessorCollection; |
21
|
|
|
use League\CommonMark\Delimiter\Processor\DelimiterProcessorInterface; |
22
|
|
|
use League\CommonMark\Event\DocumentParsedEvent; |
23
|
|
|
use League\CommonMark\Event\ListenerData; |
24
|
|
|
use League\CommonMark\Extension\CommonMark\CommonMarkCoreExtension; |
25
|
|
|
use League\CommonMark\Extension\ConfigurableExtensionInterface; |
26
|
|
|
use League\CommonMark\Extension\ExtensionInterface; |
27
|
|
|
use League\CommonMark\Extension\GithubFlavoredMarkdownExtension; |
28
|
|
|
use League\CommonMark\Normalizer\SlugNormalizer; |
29
|
|
|
use League\CommonMark\Normalizer\TextNormalizerInterface; |
30
|
|
|
use League\CommonMark\Normalizer\UniqueSlugNormalizer; |
31
|
|
|
use League\CommonMark\Normalizer\UniqueSlugNormalizerInterface; |
32
|
|
|
use League\CommonMark\Parser\Block\BlockStartParserInterface; |
33
|
|
|
use League\CommonMark\Parser\Inline\InlineParserInterface; |
34
|
|
|
use League\CommonMark\Renderer\NodeRendererInterface; |
35
|
|
|
use League\CommonMark\Util\HtmlFilter; |
36
|
|
|
use League\CommonMark\Util\PrioritizedList; |
37
|
|
|
use League\Config\Configuration; |
38
|
|
|
use League\Config\ConfigurationAwareInterface; |
39
|
|
|
use League\Config\ConfigurationInterface; |
40
|
|
|
use Nette\Schema\Expect; |
41
|
|
|
use Psr\EventDispatcher\EventDispatcherInterface; |
42
|
|
|
use Psr\EventDispatcher\ListenerProviderInterface; |
43
|
|
|
use Psr\EventDispatcher\StoppableEventInterface; |
44
|
|
|
|
45
|
|
|
final class Environment implements EnvironmentInterface, EnvironmentBuilderInterface, ListenerProviderInterface |
46
|
|
|
{ |
47
|
|
|
/** |
48
|
|
|
* @var ExtensionInterface[] |
49
|
|
|
* |
50
|
|
|
* @psalm-readonly-allow-private-mutation |
51
|
|
|
*/ |
52
|
|
|
private $extensions = []; |
53
|
|
|
|
54
|
|
|
/** |
55
|
|
|
* @var ExtensionInterface[] |
56
|
|
|
* |
57
|
|
|
* @psalm-readonly-allow-private-mutation |
58
|
|
|
*/ |
59
|
|
|
private $uninitializedExtensions = []; |
60
|
|
|
|
61
|
|
|
/** |
62
|
|
|
* @var bool |
63
|
|
|
* |
64
|
|
|
* @psalm-readonly-allow-private-mutation |
65
|
|
|
*/ |
66
|
|
|
private $extensionsInitialized = false; |
67
|
|
|
|
68
|
|
|
/** |
69
|
|
|
* @var PrioritizedList<BlockStartParserInterface> |
70
|
|
|
* |
71
|
|
|
* @psalm-readonly |
72
|
|
|
*/ |
73
|
|
|
private $blockStartParsers; |
74
|
|
|
|
75
|
|
|
/** |
76
|
|
|
* @var PrioritizedList<InlineParserInterface> |
77
|
|
|
* |
78
|
|
|
* @psalm-readonly |
79
|
|
|
*/ |
80
|
|
|
private $inlineParsers; |
81
|
|
|
|
82
|
|
|
/** |
83
|
|
|
* @var DelimiterProcessorCollection |
84
|
|
|
* |
85
|
|
|
* @psalm-readonly |
86
|
|
|
*/ |
87
|
|
|
private $delimiterProcessors; |
88
|
|
|
|
89
|
|
|
/** |
90
|
|
|
* @var array<string, PrioritizedList<NodeRendererInterface>> |
|
|
|
|
91
|
|
|
* |
92
|
|
|
* @psalm-readonly-allow-private-mutation |
93
|
|
|
*/ |
94
|
|
|
private $renderersByClass = []; |
95
|
|
|
|
96
|
|
|
/** |
97
|
|
|
* @var PrioritizedList<ListenerData> |
98
|
|
|
* |
99
|
|
|
* @psalm-readonly-allow-private-mutation |
100
|
|
|
*/ |
101
|
|
|
private $listenerData; |
102
|
|
|
|
103
|
|
|
/** @var EventDispatcherInterface|null */ |
104
|
|
|
private $eventDispatcher; |
105
|
|
|
|
106
|
|
|
/** |
107
|
|
|
* @var Configuration |
108
|
|
|
* |
109
|
|
|
* @psalm-readonly |
110
|
|
|
*/ |
111
|
|
|
private $config; |
112
|
|
|
|
113
|
|
|
/** @var TextNormalizerInterface|null */ |
114
|
|
|
private $slugNormalizer = null; |
115
|
|
|
|
116
|
|
|
/** |
117
|
|
|
* @param array<string, mixed> $config |
118
|
|
|
*/ |
119
|
3150 |
|
public function __construct(array $config = []) |
120
|
|
|
{ |
121
|
3150 |
|
$this->config = self::createDefaultConfiguration(); |
122
|
3150 |
|
$this->config->merge($config); |
123
|
|
|
|
124
|
3150 |
|
$this->blockStartParsers = new PrioritizedList(); |
125
|
3150 |
|
$this->inlineParsers = new PrioritizedList(); |
126
|
3150 |
|
$this->listenerData = new PrioritizedList(); |
127
|
3150 |
|
$this->delimiterProcessors = new DelimiterProcessorCollection(); |
128
|
3150 |
|
} |
129
|
|
|
|
130
|
3039 |
|
public function getConfiguration(): ConfigurationInterface |
131
|
|
|
{ |
132
|
3039 |
|
return $this->config->reader(); |
133
|
|
|
} |
134
|
|
|
|
135
|
|
|
/** |
136
|
|
|
* @deprecated Environment::mergeConfig() is deprecated since league/commonmark v2.0 and will be removed in v3.0. Configuration should be set when instantiating the environment instead. |
137
|
|
|
* |
138
|
|
|
* @param array<string, mixed> $config |
139
|
|
|
*/ |
140
|
306 |
|
public function mergeConfig(array $config): void |
141
|
|
|
{ |
142
|
306 |
|
@\trigger_error('Environment::mergeConfig() is deprecated since league/commonmark v2.0 and will be removed in v3.0. Configuration should be set when instantiating the environment instead.', \E_USER_DEPRECATED); |
143
|
|
|
|
144
|
306 |
|
$this->assertUninitialized('Failed to modify configuration.'); |
145
|
|
|
|
146
|
303 |
|
$this->config->merge($config); |
147
|
303 |
|
} |
148
|
|
|
|
149
|
2997 |
|
public function addBlockStartParser(BlockStartParserInterface $parser, int $priority = 0): EnvironmentBuilderInterface |
150
|
|
|
{ |
151
|
2997 |
|
$this->assertUninitialized('Failed to add block start parser.'); |
152
|
|
|
|
153
|
2994 |
|
$this->blockStartParsers->add($parser, $priority); |
154
|
2994 |
|
$this->injectEnvironmentAndConfigurationIfNeeded($parser); |
155
|
|
|
|
156
|
2994 |
|
return $this; |
157
|
|
|
} |
158
|
|
|
|
159
|
3003 |
|
public function addInlineParser(InlineParserInterface $parser, int $priority = 0): EnvironmentBuilderInterface |
160
|
|
|
{ |
161
|
3003 |
|
$this->assertUninitialized('Failed to add inline parser.'); |
162
|
|
|
|
163
|
3000 |
|
$this->inlineParsers->add($parser, $priority); |
164
|
3000 |
|
$this->injectEnvironmentAndConfigurationIfNeeded($parser); |
165
|
|
|
|
166
|
3000 |
|
return $this; |
167
|
|
|
} |
168
|
|
|
|
169
|
3000 |
|
public function addDelimiterProcessor(DelimiterProcessorInterface $processor): EnvironmentBuilderInterface |
170
|
|
|
{ |
171
|
3000 |
|
$this->assertUninitialized('Failed to add delimiter processor.'); |
172
|
2997 |
|
$this->delimiterProcessors->add($processor); |
173
|
2997 |
|
$this->injectEnvironmentAndConfigurationIfNeeded($processor); |
174
|
|
|
|
175
|
2997 |
|
return $this; |
176
|
|
|
} |
177
|
|
|
|
178
|
3018 |
|
public function addRenderer(string $nodeClass, NodeRendererInterface $renderer, int $priority = 0): EnvironmentBuilderInterface |
179
|
|
|
{ |
180
|
3018 |
|
$this->assertUninitialized('Failed to add renderer.'); |
181
|
|
|
|
182
|
3015 |
|
if (! isset($this->renderersByClass[$nodeClass])) { |
183
|
3015 |
|
$this->renderersByClass[$nodeClass] = new PrioritizedList(); |
184
|
|
|
} |
185
|
|
|
|
186
|
3015 |
|
$this->renderersByClass[$nodeClass]->add($renderer, $priority); |
187
|
3015 |
|
$this->injectEnvironmentAndConfigurationIfNeeded($renderer); |
188
|
|
|
|
189
|
3015 |
|
return $this; |
190
|
|
|
} |
191
|
|
|
|
192
|
|
|
/** |
193
|
|
|
* {@inheritdoc} |
194
|
|
|
*/ |
195
|
2370 |
|
public function getBlockStartParsers(): iterable |
196
|
|
|
{ |
197
|
2370 |
|
if (! $this->extensionsInitialized) { |
198
|
30 |
|
$this->initializeExtensions(); |
199
|
|
|
} |
200
|
|
|
|
201
|
2370 |
|
return $this->blockStartParsers->getIterator(); |
202
|
|
|
} |
203
|
|
|
|
204
|
2700 |
|
public function getDelimiterProcessors(): DelimiterProcessorCollection |
205
|
|
|
{ |
206
|
2700 |
|
if (! $this->extensionsInitialized) { |
207
|
6 |
|
$this->initializeExtensions(); |
208
|
|
|
} |
209
|
|
|
|
210
|
2700 |
|
return $this->delimiterProcessors; |
211
|
|
|
} |
212
|
|
|
|
213
|
|
|
/** |
214
|
|
|
* {@inheritdoc} |
215
|
|
|
*/ |
216
|
3009 |
|
public function getRenderersForClass(string $nodeClass): iterable |
217
|
|
|
{ |
218
|
3009 |
|
if (! $this->extensionsInitialized) { |
219
|
33 |
|
$this->initializeExtensions(); |
220
|
|
|
} |
221
|
|
|
|
222
|
|
|
// If renderers are defined for this specific class, return them immediately |
223
|
3009 |
|
if (isset($this->renderersByClass[$nodeClass])) { |
224
|
3000 |
|
return $this->renderersByClass[$nodeClass]; |
225
|
|
|
} |
226
|
|
|
|
227
|
|
|
/** @psalm-suppress TypeDoesNotContainType -- Bug: https://github.com/vimeo/psalm/issues/3332 */ |
228
|
75 |
|
while (\class_exists($parent = $parent ?? $nodeClass) && $parent = \get_parent_class($parent)) { |
229
|
69 |
|
if (! isset($this->renderersByClass[$parent])) { |
230
|
6 |
|
continue; |
231
|
|
|
} |
232
|
|
|
|
233
|
|
|
// "Cache" this result to avoid future loops |
234
|
66 |
|
return $this->renderersByClass[$nodeClass] = $this->renderersByClass[$parent]; |
235
|
|
|
} |
236
|
|
|
|
237
|
9 |
|
return []; |
238
|
|
|
} |
239
|
|
|
|
240
|
|
|
/** |
241
|
|
|
* {@inheritDoc} |
242
|
|
|
*/ |
243
|
18 |
|
public function getExtensions(): iterable |
244
|
|
|
{ |
245
|
18 |
|
return $this->extensions; |
246
|
|
|
} |
247
|
|
|
|
248
|
|
|
/** |
249
|
|
|
* Add a single extension |
250
|
|
|
* |
251
|
|
|
* @return $this |
252
|
|
|
*/ |
253
|
3048 |
|
public function addExtension(ExtensionInterface $extension): EnvironmentBuilderInterface |
254
|
|
|
{ |
255
|
3048 |
|
$this->assertUninitialized('Failed to add extension.'); |
256
|
|
|
|
257
|
3045 |
|
$this->extensions[] = $extension; |
258
|
3045 |
|
$this->uninitializedExtensions[] = $extension; |
259
|
|
|
|
260
|
3045 |
|
if ($extension instanceof ConfigurableExtensionInterface) { |
261
|
3039 |
|
$extension->configureSchema($this->config); |
262
|
|
|
} |
263
|
|
|
|
264
|
3045 |
|
return $this; |
265
|
|
|
} |
266
|
|
|
|
267
|
3081 |
|
private function initializeExtensions(): void |
268
|
|
|
{ |
269
|
|
|
// Initialize the slug normalizer |
270
|
3081 |
|
$this->getSlugNormalizer(); |
271
|
|
|
|
272
|
|
|
// Ask all extensions to register their components |
273
|
3081 |
|
while (\count($this->uninitializedExtensions) > 0) { |
274
|
2991 |
|
foreach ($this->uninitializedExtensions as $i => $extension) { |
275
|
2991 |
|
$extension->register($this); |
276
|
2991 |
|
unset($this->uninitializedExtensions[$i]); |
277
|
|
|
} |
278
|
|
|
} |
279
|
|
|
|
280
|
3081 |
|
$this->extensionsInitialized = true; |
281
|
|
|
|
282
|
|
|
// Create the special delimiter parser if any processors were registered |
283
|
3081 |
|
if ($this->delimiterProcessors->count() > 0) { |
284
|
2994 |
|
$this->inlineParsers->add(new DelimiterParser($this->delimiterProcessors), PHP_INT_MIN); |
285
|
|
|
} |
286
|
3081 |
|
} |
287
|
|
|
|
288
|
3102 |
|
private function injectEnvironmentAndConfigurationIfNeeded(object $object): void |
289
|
|
|
{ |
290
|
3102 |
|
if ($object instanceof EnvironmentAwareInterface) { |
291
|
3003 |
|
$object->setEnvironment($this); |
292
|
|
|
} |
293
|
|
|
|
294
|
3102 |
|
if ($object instanceof ConfigurationAwareInterface) { |
295
|
3093 |
|
$object->setConfiguration($this->config->reader()); |
296
|
|
|
} |
297
|
3102 |
|
} |
298
|
|
|
|
299
|
|
|
/** |
300
|
|
|
* @deprecated Instantiate the environment and add the extension yourself |
301
|
|
|
* |
302
|
|
|
* @param array<string, mixed> $config |
303
|
|
|
*/ |
304
|
756 |
|
public static function createCommonMarkEnvironment(array $config = []): Environment |
305
|
|
|
{ |
306
|
756 |
|
$environment = new self($config); |
307
|
756 |
|
$environment->addExtension(new CommonMarkCoreExtension()); |
308
|
|
|
|
309
|
756 |
|
return $environment; |
310
|
|
|
} |
311
|
|
|
|
312
|
|
|
/** |
313
|
|
|
* @deprecated Instantiate the environment and add the extension yourself |
314
|
|
|
* |
315
|
|
|
* @param array<string, mixed> $config |
316
|
|
|
*/ |
317
|
81 |
|
public static function createGFMEnvironment(array $config = []): Environment |
318
|
|
|
{ |
319
|
81 |
|
$environment = self::createCommonMarkEnvironment($config); |
|
|
|
|
320
|
81 |
|
$environment->addExtension(new GithubFlavoredMarkdownExtension()); |
321
|
|
|
|
322
|
81 |
|
return $environment; |
323
|
|
|
} |
324
|
|
|
|
325
|
3093 |
|
public function addEventListener(string $eventClass, callable $listener, int $priority = 0): EnvironmentBuilderInterface |
326
|
|
|
{ |
327
|
3093 |
|
$this->assertUninitialized('Failed to add event listener.'); |
328
|
|
|
|
329
|
3093 |
|
$this->listenerData->add(new ListenerData($eventClass, $listener), $priority); |
330
|
|
|
|
331
|
3093 |
|
if (\is_object($listener)) { |
332
|
345 |
|
$this->injectEnvironmentAndConfigurationIfNeeded($listener); |
333
|
3093 |
|
} elseif (\is_array($listener) && \is_object($listener[0])) { |
334
|
3093 |
|
$this->injectEnvironmentAndConfigurationIfNeeded($listener[0]); |
335
|
|
|
} |
336
|
|
|
|
337
|
3093 |
|
return $this; |
338
|
|
|
} |
339
|
|
|
|
340
|
|
|
/** |
341
|
|
|
* {@inheritDoc} |
342
|
|
|
*/ |
343
|
3006 |
|
public function dispatch(object $event) |
344
|
|
|
{ |
345
|
3006 |
|
if (! $this->extensionsInitialized) { |
346
|
3000 |
|
$this->initializeExtensions(); |
347
|
|
|
} |
348
|
|
|
|
349
|
3006 |
|
if ($this->eventDispatcher !== null) { |
350
|
3 |
|
return $this->eventDispatcher->dispatch($event); |
351
|
|
|
} |
352
|
|
|
|
353
|
3003 |
|
foreach ($this->getListenersForEvent($event) as $listener) { |
354
|
2994 |
|
if ($event instanceof StoppableEventInterface && $event->isPropagationStopped()) { |
355
|
3 |
|
return $event; |
356
|
|
|
} |
357
|
|
|
|
358
|
2994 |
|
$listener($event); |
359
|
|
|
} |
360
|
|
|
|
361
|
2997 |
|
return $event; |
362
|
|
|
} |
363
|
|
|
|
364
|
3 |
|
public function setEventDispatcher(EventDispatcherInterface $dispatcher): void |
365
|
|
|
{ |
366
|
3 |
|
$this->eventDispatcher = $dispatcher; |
367
|
3 |
|
} |
368
|
|
|
|
369
|
|
|
/** |
370
|
|
|
* {@inheritDoc} |
371
|
|
|
* |
372
|
|
|
* @return iterable<callable> |
373
|
|
|
*/ |
374
|
3003 |
|
public function getListenersForEvent(object $event): iterable |
375
|
|
|
{ |
376
|
3003 |
|
foreach ($this->listenerData as $listenerData) { |
377
|
|
|
\assert($listenerData instanceof ListenerData); |
378
|
|
|
|
379
|
3000 |
|
if (! \is_a($event, $listenerData->getEvent())) { |
380
|
2991 |
|
continue; |
381
|
|
|
} |
382
|
|
|
|
383
|
1996 |
|
yield function (object $event) use ($listenerData) { |
384
|
2994 |
|
if (! $this->extensionsInitialized) { |
385
|
|
|
$this->initializeExtensions(); |
386
|
|
|
} |
387
|
|
|
|
388
|
2994 |
|
return \call_user_func($listenerData->getListener(), $event); |
389
|
2994 |
|
}; |
390
|
|
|
} |
391
|
2997 |
|
} |
392
|
|
|
|
393
|
|
|
/** |
394
|
|
|
* @return iterable<InlineParserInterface> |
395
|
|
|
*/ |
396
|
2994 |
|
public function getInlineParsers(): iterable |
397
|
|
|
{ |
398
|
2994 |
|
if (! $this->extensionsInitialized) { |
399
|
12 |
|
$this->initializeExtensions(); |
400
|
|
|
} |
401
|
|
|
|
402
|
2994 |
|
return $this->inlineParsers->getIterator(); |
403
|
|
|
} |
404
|
|
|
|
405
|
3102 |
|
public function getSlugNormalizer(): TextNormalizerInterface |
406
|
|
|
{ |
407
|
3102 |
|
if ($this->slugNormalizer === null) { |
408
|
3102 |
|
$normalizer = $this->config->get('slug_normalizer/instance'); |
409
|
|
|
\assert($normalizer instanceof TextNormalizerInterface); |
410
|
3099 |
|
$this->injectEnvironmentAndConfigurationIfNeeded($normalizer); |
411
|
|
|
|
412
|
3099 |
|
if ($this->config->get('slug_normalizer/unique') !== UniqueSlugNormalizerInterface::DISABLED && ! $normalizer instanceof UniqueSlugNormalizer) { |
413
|
3096 |
|
$normalizer = new UniqueSlugNormalizer($normalizer); |
414
|
|
|
} |
415
|
|
|
|
416
|
3099 |
|
if ($normalizer instanceof UniqueSlugNormalizer) { |
417
|
3096 |
|
if ($this->config->get('slug_normalizer/unique') === UniqueSlugNormalizerInterface::PER_DOCUMENT) { |
418
|
3093 |
|
$this->addEventListener(DocumentParsedEvent::class, [$normalizer, 'clearHistory'], -1000); |
419
|
|
|
} |
420
|
|
|
} |
421
|
|
|
|
422
|
3099 |
|
$this->slugNormalizer = $normalizer; |
423
|
|
|
} |
424
|
|
|
|
425
|
3099 |
|
return $this->slugNormalizer; |
426
|
|
|
} |
427
|
|
|
|
428
|
|
|
/** |
429
|
|
|
* @throws \RuntimeException |
430
|
|
|
*/ |
431
|
3138 |
|
private function assertUninitialized(string $message): void |
432
|
|
|
{ |
433
|
3138 |
|
if ($this->extensionsInitialized) { |
434
|
21 |
|
throw new \RuntimeException($message . ' Extensions have already been initialized.'); |
435
|
|
|
} |
436
|
3138 |
|
} |
437
|
|
|
|
438
|
3372 |
|
public static function createDefaultConfiguration(): Configuration |
439
|
|
|
{ |
440
|
3372 |
|
return new Configuration([ |
441
|
3372 |
|
'html_input' => Expect::anyOf(HtmlFilter::STRIP, HtmlFilter::ALLOW, HtmlFilter::ESCAPE)->default(HtmlFilter::ALLOW), |
442
|
3372 |
|
'allow_unsafe_links' => Expect::bool(true), |
443
|
3372 |
|
'max_nesting_level' => Expect::type('int')->default(PHP_INT_MAX), |
444
|
3372 |
|
'renderer' => Expect::structure([ |
445
|
3372 |
|
'block_separator' => Expect::string("\n"), |
446
|
3372 |
|
'inner_separator' => Expect::string("\n"), |
447
|
3372 |
|
'soft_break' => Expect::string("\n"), |
448
|
|
|
]), |
449
|
3372 |
|
'slug_normalizer' => Expect::structure([ |
450
|
3372 |
|
'instance' => Expect::type(TextNormalizerInterface::class)->default(new SlugNormalizer()), |
451
|
3372 |
|
'max_length' => Expect::int()->min(0)->default(255), |
452
|
3372 |
|
'unique' => Expect::anyOf(UniqueSlugNormalizerInterface::DISABLED, UniqueSlugNormalizerInterface::PER_ENVIRONMENT, UniqueSlugNormalizerInterface::PER_DOCUMENT)->default(UniqueSlugNormalizerInterface::PER_DOCUMENT), |
453
|
|
|
]), |
454
|
|
|
]); |
455
|
|
|
} |
456
|
|
|
} |
457
|
|
|
|