29746802114

Committed 20 Jul 2026 01:19PM UTC coverage: 94.677% (+0.04%) from 94.641%

Build Type

push

github

Committed by

Commit Message

Dead code removed

- Engine::getPatternNames() and Texy::getEngine(): no callers in src or tests.
- LinkDefinitionModule::resolveUrl(): unreachable. Both bracket forms it
  handles ([*img*] and [ref]) are already consumed by earlier returns in
  resolveLinkNodeUrl(), so it could only ever return its argument unchanged.
- Text\Renderer: CodeBlockNode type 'comment' never exists; comments are a
  separate CommentNode. Leftover from before the node split.

Coverage Stats

1 of 1 new or added line in 1 file covered. (100.0%)

74 existing lines in 15 files now uncovered.

3344 of 3532 relevant lines covered (94.68%)

0.95 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.8

/src/Texy/Modules/ImageModule.php

<?php declare(strict_types=1);

/**
 * This file is part of the Texy! (https://texy.nette.org)
 * Copyright (c) 2004 David Grudl (https://davidgrudl.com)
 */

namespace Texy\Modules;

use Texy;
use Texy\Compat;
use Texy\Helpers;
use Texy\Modifier;
use Texy\Node;
use Texy\Nodes\ContentNode;
use Texy\Nodes\DocumentNode;
use Texy\Nodes\FigureNode;
use Texy\Nodes\ImageDefinitionNode;
use Texy\Nodes\ImageNode;
use Texy\Nodes\LinkNode;
use Texy\NodeTraverser;
use Texy\ParseContext;
use Texy\Patterns;
use Texy\Range;
use Texy\Regexp;
use Texy\Syntax;
use function count, strlen;


/**
 * Processes image and figure (image with caption) syntax.
 */
final class ImageModule extends Texy\Module
{
        /** the [* url .(title) alignment ] part, shared by the image and figure syntaxes */
        private const ImagePattern = '
                        \[\* \ *+                         # opening bracket with asterisk
                        ([^\n]{1,1000})                   # URLs (1)
                        ' . Patterns::Modifier . '?       # modifier (2)
                        \ *+
                        ( \* | (?<! < ) > | < )           # alignment (3)
                        ]';

        /** the optional :LINK (or :: self link) suffix */
        private const LinkPattern = '
                        (?:
                                :(' . Patterns::LinkUrl . ' | : ) # link or just colon (4)
                        )??';

        /** @var array<string, ImageDefinitionNode> collected image definitions */
        private array $definitions = [];

        /** @var array<string, ImageDefinitionNode> user-defined definitions (persist across process() calls) */
        private array $userDefinitions = [];


        public function __construct(
                private Texy\Texy $texy,
        ) {
                $texy->allowed[Syntax::ImageDefinition] = true;
                $texy->addHandler('afterParse', $this->resolveReferences(...));
        }


        public function beforeParse(string &$text): void
        {
                // [*image*]:LINK
                $this->texy->registerLinePattern(
                        $this->parseImage(...),
                        '~' . self::ImagePattern . self::LinkPattern . '
                        ~Ux',
                        Syntax::Image,
                );

                // [*ref*]: url .(title)[class]{style}
                $this->texy->registerBlockPattern(
                        $this->parseDefinition(...),
                        '~^
                                \[\*                              # opening [*
                                ( [^\n]{1,100} )                  # reference (1)
                                \*]                               # closing *]
                                : [ \t]+
                                (.{1,1000})                       # URL (2)
                                [ \t]*
                                ' . Patterns::Modifier . '?       # modifier (3)
                                \s*
                        $~mUx',
                        Syntax::ImageDefinition,
                );

                // [*image*]:link *** caption
                $this->texy->registerBlockPattern(
                        $this->parseFigure(...),
                        '~^
                                (?>' . self::ImagePattern . ')' . self::LinkPattern . '
                                (?:
                                        \ ++ \*\*\* \ ++              # separator
                                        (.{0,2000})                   # caption (5)
                                )?
                                ' . Patterns::ModifierHAlign . '?     # modifier (6)
                        $~mUx',
                        Syntax::Figure,
                );
        }


        /**
         * Parses [*image*]: urls .(title)[class]{style}
         * @param  array{string, string, string, ?string}  $matches
         * @param  array{int, int, int, ?int}  $offsets
         */
        public function parseDefinition(ParseContext $context, array $matches, array $offsets): ImageDefinitionNode
        {
                [, $mRef, $mURLs, $mMod] = $matches;
                $parsed = $this->parseImageContent($mURLs);
                $modifier = Modifier::parse($mMod, $offsets[3] ?? null);

                return new ImageDefinitionNode(
                        trim($mRef),
                        $parsed['url'],
                        $parsed['width'],
                        $parsed['height'],
                        $modifier,
                        new Range($offsets[0], strlen($matches[0])),
                );
        }


        /**
         * Parses [* small.jpg 80x13 .(alternative text)[class]{style}>]:LINK
         * @param  array{string, string, ?string, string, ?string}  $matches
         * @param  array{int, int, ?int, int, ?int}  $offsets
         */
        public function parseImage(ParseContext $context, array $matches, array $offsets): ImageNode|LinkNode
        {
                [, $mURLs, $mMod, $mAlign, $mLink] = $matches;
                $parsed = $this->parseImageContent($mURLs);
                $modifier = Modifier::parse($mMod . $mAlign);
                $range = new Range($offsets[0], strlen($matches[0]));

                $imageNode = new ImageNode(
                        $parsed['url'],
                        $parsed['width'],
                        $parsed['height'],
                        $modifier,
                        $range,
                );

                return $mLink
                        ? $this->wrapInLink($imageNode, $mLink, $range)
                        : $imageNode;
        }


        /**
         * Parses [*image*]:link *** caption .(title)[class]{style}>.
         * @param  array{string, string, ?string, string, ?string, ?string, ?string}  $matches
         * @param  array{int, int, ?int, int, ?int, ?int, ?int}  $offsets
         */
        public function parseFigure(ParseContext $context, array $matches, array $offsets): ?FigureNode
        {
                [, $mURLs, $mImgMod, $mAlign, $mLink, $mContent, $mMod] = $matches;

                $parsed = $this->parseImageContent($mURLs);
                $modifier = Modifier::parse($mImgMod . $mAlign);

                if ($parsed['url'] === null) {
                        return null;
                }

                // ImageNode source span is "[* ... <alignment>]"
                $imageEnd = $offsets[3] + strlen($mAlign) + 1; // 1 = "]"
                $imageNode = new ImageNode(
                        $parsed['url'],
                        $parsed['width'],
                        $parsed['height'],
                        $modifier,
                        new Range($offsets[0], $imageEnd - $offsets[0]),
                );

                $image = $mLink
                        ? $this->wrapInLink(
                                $imageNode,
                                $mLink,
                                new Range($offsets[0], $offsets[4] + strlen($mLink) - $offsets[0]),
                        )
                        : $imageNode;

                // Parse caption as inline content
                $caption = null;
                $mContent = trim($mContent ?? '');
                if ($mContent !== '') {
                        $caption = $context->parseInline($mContent, $offsets[5] ?? $offsets[0]);
                }

                return new FigureNode(
                        $image,
                        $caption,
                        Modifier::parse($mMod, $offsets[6] ?? null),
                        new Range($offsets[0], strlen($matches[0])),
                );
        }


        private function wrapInLink(ImageNode $imageNode, string $mLink, Range $range): LinkNode
        {
                if ($mLink === ':') {
                        // Link to the image itself
                        $linkUrl = $imageNode->url;
                        $isImageLink = true;
                } else {
                        // Direct URL or reference like [ref] or [*img*]
                        $linkUrl = $mLink;
                        // Image reference [*...*] → uses imageRoot
                        $len = strlen($mLink);
                        $isImageLink = $len > 4 && $mLink[0] === '[' && $mLink[1] === '*'
                                && $mLink[$len - 1] === ']' && $mLink[$len - 2] === '*';
                }

                return new LinkNode(
                        url: $linkUrl,
                        content: new ContentNode([$imageNode]),
                        range: $range,
                        isImageLink: $isImageLink,
                );
        }


        /**
         * Parse image content: "image.jpg 100x200"
         * @return array{url: ?string, width: ?int, height: ?int}
         */
        public function parseImageContent(string $content): array
        {
                $parts = explode('|', $content);
                $main = trim($parts[0]);

                if (count($parts) > 1) {
                        trigger_error("Image syntax with '|' or '||' inside brackets is deprecated. Use [* image *]:url for linked images.", E_USER_DEPRECATED);
                }

                $url = $main;
                $width = $height = null;

                // Parse dimensions: "image.jpg 100x200" or "image.jpg 100X200" (asMax)
                if ($m = Regexp::match($main, '~^(.*)\ (\d+|\?)\ *[xX]\ *(\d+|\?)\ *$~U')) {
                        /** @var array{string, string, string, string} $m */
                        $url = trim($m[1]);
                        $width = $m[2] === '?' ? null : (int) $m[2];
                        $height = $m[3] === '?' ? null : (int) $m[3];
                }

                // Check URL
                if (!$this->texy->urlPolicy->isImageAllowed($url)) {
                        $url = null;
                }

                return [
                        'url' => $url,
                        'width' => $width,
                        'height' => $height,
                ];
        }


        /**
         * Adds a user-defined image definition (persists across process() calls).
         */
        public function addDefinition(
                string $name,
                string $url,
                ?int $width = null,
                ?int $height = null,
                ?string $alt = null,
        ): void
        {
                $modifier = $alt !== null ? Modifier::parse('(' . $alt . ')') : null;
                $this->userDefinitions[Helpers::toLower($name)] = new ImageDefinitionNode($name, $url, $width, $height, $modifier);
        }


        /**
         * Resolve image references in the document.
         * Called via afterParse handler.
         */
        public function resolveReferences(DocumentNode $doc): void
        {
                // Start with user-defined definitions
                $this->definitions = $this->userDefinitions;
                $traverser = new NodeTraverser;

                // Pass 1: Collect document definitions (overwrites user-defined)
                $traverser->traverse($doc, function (Node $node): ?int {
                        if ($node instanceof ImageDefinitionNode) {
                                $this->definitions[Helpers::toLower($node->reference)] = $node;
                                return NodeTraverser::DontTraverseChildren;
                        }
                        return null;
                });

                // Pass 2: Resolve ImageNode references (NodeTraverser visits all nodes including FigureNode.image)
                $traverser->traverse($doc, function (Node $node): ?int {
                        if ($node instanceof ImageNode) {
                                $this->resolveImageNode($node);
                        } elseif (
                                $node instanceof LinkNode
                                && ($imageNode = $node->content->children[0] ?? null) instanceof ImageNode
                        ) {
                                // LinkNode wrapping ImageNode - resolve image and possibly the link URL
                                $imageKey = $imageNode->url !== null ? Helpers::toLower(trim($imageNode->url)) : null;
                                $linkKey = $node->url !== null ? Helpers::toLower(trim($node->url)) : null;

                                // Resolve the image
                                $this->resolveImageNode($imageNode);

                                // If link URL matches the original image reference (from :: syntax), resolve it too
                                if ($imageKey !== null && $linkKey === $imageKey && isset($this->definitions[$imageKey])) {
                                        $node->url = $this->definitions[$imageKey]->url;
                                }
                        }
                        return null;
                });
        }


        private function resolveImageNode(ImageNode $node): void
        {
                if ($node->url === null) {
                        return;
                }

                $key = Helpers::toLower(trim($node->url));
                if (!isset($this->definitions[$key])) {
                        return;
                }

                $def = $this->definitions[$key];

                $node->ref = trim($node->url); // keep the written reference name for analyzers
                $node->url = $def->url;
                $node->width ??= $def->width;
                $node->height ??= $def->height;

                // Merge modifier from definition if node doesn't have one
                if ($def->modifier && !$node->modifier) {
                        $node->modifier = clone $def->modifier;
                } elseif ($def->modifier) {
                        // Merge: node modifier takes precedence, but inherit missing values from definition
                        if ($node->modifier->title === null && $def->modifier->title !== null) {
                                $node->modifier->title = $def->modifier->title;
                        }
                }
        }


        /**
         * Get image definition by name (for LinkReferenceModule to resolve [*img*] links).
         */
        public function getDefinition(string $name): ?ImageDefinitionNode
        {
                return $this->definitions[Helpers::toLower($name)] ?? null;
        }


        /**
         * @deprecated use $texy->htmlOutput->imageRoot etc. instead
         */
        public function &__get(string $name): mixed
        {
                return Compat\Legacy::ref($this->texy, Compat\Legacy::OfModule['imageModule'], '$texy->imageModule', $name, 'read');
        }


        /**
         * @deprecated use $texy->htmlOutput->imageRoot etc. instead
         */
        public function __set(string $name, mixed $value): void
        {
                Compat\Legacy::set($this->texy, Compat\Legacy::OfModule['imageModule'], '$texy->imageModule', $name, $value);
        }


        public function __isset(string $name): bool
        {
                return Compat\Legacy::isSet($this->texy, Compat\Legacy::OfModule['imageModule'], $name);
        }
}

1	<?php declare(strict_types=1);
2
3	/**
4	* This file is part of the Texy! (https://texy.nette.org)
5	* Copyright (c) 2004 David Grudl (https://davidgrudl.com)
6	*/
7
8	namespace Texy\Modules;
9
10	use Texy;
11	use Texy\Compat;
12	use Texy\Helpers;
13	use Texy\Modifier;
14	use Texy\Node;
15	use Texy\Nodes\ContentNode;
16	use Texy\Nodes\DocumentNode;
17	use Texy\Nodes\FigureNode;
18	use Texy\Nodes\ImageDefinitionNode;
19	use Texy\Nodes\ImageNode;
20	use Texy\Nodes\LinkNode;
21	use Texy\NodeTraverser;
22	use Texy\ParseContext;
23	use Texy\Patterns;
24	use Texy\Range;
25	use Texy\Regexp;
26	use Texy\Syntax;
27	use function count, strlen;
28
29
30	/**
31	* Processes image and figure (image with caption) syntax.
32	*/
33	final class ImageModule extends Texy\Module
34	{
35	/** the [* url .(title) alignment ] part, shared by the image and figure syntaxes */
36	private const ImagePattern = '
37	\[\* \ *+ # opening bracket with asterisk
38	([^\n]{1,1000}) # URLs (1)
39	' . Patterns::Modifier . '? # modifier (2)
40	\ *+
41	( \* \| (?<! < ) > \| < ) # alignment (3)
42	]';
43
44	/** the optional :LINK (or :: self link) suffix */
45	private const LinkPattern = '
46	(?:
47	:(' . Patterns::LinkUrl . ' \| : ) # link or just colon (4)
48	)??';
49
50	/** @var array<string, ImageDefinitionNode> collected image definitions */
51	private array $definitions = [];
52
53	/** @var array<string, ImageDefinitionNode> user-defined definitions (persist across process() calls) */
54	private array $userDefinitions = [];
55
56
57	public function __construct(	1✔
58	private Texy\Texy $texy,
59	) {
60	$texy->allowed[Syntax::ImageDefinition] = true;	1✔
61	$texy->addHandler('afterParse', $this->resolveReferences(...));	1✔
62	}	1✔
63
64
65	public function beforeParse(string &$text): void	1✔
66	{
67	// [image]:LINK
68	$this->texy->registerLinePattern(	1✔
69	$this->parseImage(...),	1✔
70	'~' . self::ImagePattern . self::LinkPattern . '	1✔
71	~Ux',
72	Syntax::Image,	1✔
73	);
74
75	// [ref]: url .(title)[class]{style}
76	$this->texy->registerBlockPattern(	1✔
77	$this->parseDefinition(...),	1✔
78	'~^
79	\[\* # opening [*
80	( [^\n]{1,100} ) # reference (1)
81	\] # closing ]
82	: [ \t]+
83	(.{1,1000}) # URL (2)
84	[ \t]*
85	' . Patterns::Modifier . '? # modifier (3)	1✔
86	\s*
87	$~mUx',
88	Syntax::ImageDefinition,	1✔
89	);
90
91	// [image]:link *** caption
92	$this->texy->registerBlockPattern(	1✔
93	$this->parseFigure(...),	1✔
94	'~^
95	(?>' . self::ImagePattern . ')' . self::LinkPattern . '	1✔
96	(?:
97	\ ++ \\\* \ ++ # separator
98	(.{0,2000}) # caption (5)
99	)?
100	' . Patterns::ModifierHAlign . '? # modifier (6)	1✔
101	$~mUx',
102	Syntax::Figure,	1✔
103	);
104	}	1✔
105
106
107	/**
108	* Parses [image]: urls .(title)[class]{style}
109	* @param array{string, string, string, ?string} $matches
110	* @param array{int, int, int, ?int} $offsets
111	*/
112	public function parseDefinition(ParseContext $context, array $matches, array $offsets): ImageDefinitionNode	1✔
113	{
114	[, $mRef, $mURLs, $mMod] = $matches;	1✔
115	$parsed = $this->parseImageContent($mURLs);	1✔
116	$modifier = Modifier::parse($mMod, $offsets[3] ?? null);	1✔
117
118	return new ImageDefinitionNode(	1✔
119	trim($mRef),	1✔
120	$parsed['url'],	1✔
121	$parsed['width'],	1✔
122	$parsed['height'],	1✔
123	$modifier,
124	new Range($offsets[0], strlen($matches[0])),	1✔
125	);
126	}
127
128
129	/**
130	* Parses [* small.jpg 80x13 .(alternative text)[class]{style}>]:LINK
131	* @param array{string, string, ?string, string, ?string} $matches
132	* @param array{int, int, ?int, int, ?int} $offsets
133	*/
134	public function parseImage(ParseContext $context, array $matches, array $offsets): ImageNode\|LinkNode	1✔
135	{
136	[, $mURLs, $mMod, $mAlign, $mLink] = $matches;	1✔
137	$parsed = $this->parseImageContent($mURLs);	1✔
138	$modifier = Modifier::parse($mMod . $mAlign);	1✔
139	$range = new Range($offsets[0], strlen($matches[0]));	1✔
140
141	$imageNode = new ImageNode(	1✔
142	$parsed['url'],	1✔
143	$parsed['width'],	1✔
144	$parsed['height'],	1✔
145	$modifier,
146	$range,
147	);
148
149	return $mLink	1✔
150	? $this->wrapInLink($imageNode, $mLink, $range)	1✔
151	: $imageNode;	1✔
152	}
153
154
155	/**
156	* Parses [image]:link *** caption .(title)[class]{style}>.
157	* @param array{string, string, ?string, string, ?string, ?string, ?string} $matches
158	* @param array{int, int, ?int, int, ?int, ?int, ?int} $offsets
159	*/
160	public function parseFigure(ParseContext $context, array $matches, array $offsets): ?FigureNode	1✔
161	{
162	[, $mURLs, $mImgMod, $mAlign, $mLink, $mContent, $mMod] = $matches;	1✔
163
164	$parsed = $this->parseImageContent($mURLs);	1✔
165	$modifier = Modifier::parse($mImgMod . $mAlign);	1✔
166
167	if ($parsed['url'] === null) {	1✔
UNCOV 168	return null;	×
169	}
170
171	// ImageNode source span is "[* ... <alignment>]"
172	$imageEnd = $offsets[3] + strlen($mAlign) + 1; // 1 = "]"	1✔
173	$imageNode = new ImageNode(	1✔
174	$parsed['url'],	1✔
175	$parsed['width'],	1✔
176	$parsed['height'],	1✔
177	$modifier,
178	new Range($offsets[0], $imageEnd - $offsets[0]),	1✔
179	);
180
181	$image = $mLink	1✔
182	? $this->wrapInLink(	1✔
183	$imageNode,	1✔
184	$mLink,
185	new Range($offsets[0], $offsets[4] + strlen($mLink) - $offsets[0]),	1✔
186	)
187	: $imageNode;	1✔
188
189	// Parse caption as inline content
190	$caption = null;	1✔
191	$mContent = trim($mContent ?? '');	1✔
192	if ($mContent !== '') {	1✔
193	$caption = $context->parseInline($mContent, $offsets[5] ?? $offsets[0]);	1✔
194	}
195
196	return new FigureNode(	1✔
197	$image,	1✔
198	$caption,
199	Modifier::parse($mMod, $offsets[6] ?? null),	1✔
200	new Range($offsets[0], strlen($matches[0])),	1✔
201	);
202	}
203
204
205	private function wrapInLink(ImageNode $imageNode, string $mLink, Range $range): LinkNode	1✔
206	{
207	if ($mLink === ':') {	1✔
208	// Link to the image itself
209	$linkUrl = $imageNode->url;	1✔
210	$isImageLink = true;	1✔
211	} else {
212	// Direct URL or reference like [ref] or [img]
213	$linkUrl = $mLink;	1✔
214	// Image reference [...] → uses imageRoot
215	$len = strlen($mLink);	1✔
216	$isImageLink = $len > 4 && $mLink[0] === '[' && $mLink[1] === '*'	1✔
217	&& $mLink[$len - 1] === ']' && $mLink[$len - 2] === '*';	1✔
218	}
219
220	return new LinkNode(	1✔
221	url: $linkUrl,	1✔
222	content: new ContentNode([$imageNode]),	1✔
223	range: $range,
224	isImageLink: $isImageLink,
225	);
226	}
227
228
229	/**
230	* Parse image content: "image.jpg 100x200"
231	* @return array{url: ?string, width: ?int, height: ?int}
232	*/
233	public function parseImageContent(string $content): array	1✔
234	{
235	$parts = explode('\|', $content);	1✔
236	$main = trim($parts[0]);	1✔
237
238	if (count($parts) > 1) {	1✔
239	trigger_error("Image syntax with '\|' or '\|\|' inside brackets is deprecated. Use [* image *]:url for linked images.", E_USER_DEPRECATED);	1✔
240	}
241
242	$url = $main;	1✔
243	$width = $height = null;	1✔
244
245	// Parse dimensions: "image.jpg 100x200" or "image.jpg 100X200" (asMax)
246	if ($m = Regexp::match($main, '~^(.)\ (\d+\|\?)\ [xX]\ (\d+\|\?)\ $~U')) {	1✔
247	/** @var array{string, string, string, string} $m */
248	$url = trim($m[1]);	1✔
249	$width = $m[2] === '?' ? null : (int) $m[2];	1✔
250	$height = $m[3] === '?' ? null : (int) $m[3];	1✔
251	}
252
253	// Check URL
254	if (!$this->texy->urlPolicy->isImageAllowed($url)) {	1✔
UNCOV 255	$url = null;	×
256	}
257
258	return [
259	'url' => $url,	1✔
260	'width' => $width,	1✔
261	'height' => $height,	1✔
262	];
263	}
264
265
266	/**
267	* Adds a user-defined image definition (persists across process() calls).
268	*/
269	public function addDefinition(	1✔
270	string $name,
271	string $url,
272	?int $width = null,
273	?int $height = null,
274	?string $alt = null,
275	): void
276	{
277	$modifier = $alt !== null ? Modifier::parse('(' . $alt . ')') : null;	1✔
278	$this->userDefinitions[Helpers::toLower($name)] = new ImageDefinitionNode($name, $url, $width, $height, $modifier);	1✔
279	}	1✔
280
281
282	/**
283	* Resolve image references in the document.
284	* Called via afterParse handler.
285	*/
286	public function resolveReferences(DocumentNode $doc): void	1✔
287	{
288	// Start with user-defined definitions
289	$this->definitions = $this->userDefinitions;	1✔
290	$traverser = new NodeTraverser;	1✔
291
292	// Pass 1: Collect document definitions (overwrites user-defined)
293	$traverser->traverse($doc, function (Node $node): ?int {	1✔
294	if ($node instanceof ImageDefinitionNode) {	1✔
295	$this->definitions[Helpers::toLower($node->reference)] = $node;	1✔
296	return NodeTraverser::DontTraverseChildren;	1✔
297	}
298	return null;	1✔
299	});	1✔
300
301	// Pass 2: Resolve ImageNode references (NodeTraverser visits all nodes including FigureNode.image)
302	$traverser->traverse($doc, function (Node $node): ?int {	1✔
303	if ($node instanceof ImageNode) {	1✔
304	$this->resolveImageNode($node);	1✔
305	} elseif (
306	$node instanceof LinkNode	1✔
307	&& ($imageNode = $node->content->children[0] ?? null) instanceof ImageNode	1✔
308	) {
309	// LinkNode wrapping ImageNode - resolve image and possibly the link URL
310	$imageKey = $imageNode->url !== null ? Helpers::toLower(trim($imageNode->url)) : null;	1✔
311	$linkKey = $node->url !== null ? Helpers::toLower(trim($node->url)) : null;	1✔
312
313	// Resolve the image
314	$this->resolveImageNode($imageNode);	1✔
315
316	// If link URL matches the original image reference (from :: syntax), resolve it too
317	if ($imageKey !== null && $linkKey === $imageKey && isset($this->definitions[$imageKey])) {	1✔
318	$node->url = $this->definitions[$imageKey]->url;	1✔
319	}
320	}
321	return null;	1✔
322	});	1✔
323	}	1✔
324
325
326	private function resolveImageNode(ImageNode $node): void	1✔
327	{
328	if ($node->url === null) {	1✔
UNCOV 329	return;	×
330	}
331
332	$key = Helpers::toLower(trim($node->url));	1✔
333	if (!isset($this->definitions[$key])) {	1✔
334	return;	1✔
335	}
336
337	$def = $this->definitions[$key];	1✔
338
339	$node->ref = trim($node->url); // keep the written reference name for analyzers	1✔
340	$node->url = $def->url;	1✔
341	$node->width ??= $def->width;	1✔
342	$node->height ??= $def->height;	1✔
343
344	// Merge modifier from definition if node doesn't have one
345	if ($def->modifier && !$node->modifier) {	1✔
UNCOV 346	$node->modifier = clone $def->modifier;	×
347	} elseif ($def->modifier) {	1✔
348	// Merge: node modifier takes precedence, but inherit missing values from definition
349	if ($node->modifier->title === null && $def->modifier->title !== null) {	1✔
350	$node->modifier->title = $def->modifier->title;	1✔
351	}
352	}
353	}	1✔
354
355
356	/**
357	* Get image definition by name (for LinkReferenceModule to resolve [img] links).
358	*/
359	public function getDefinition(string $name): ?ImageDefinitionNode	1✔
360	{
361	return $this->definitions[Helpers::toLower($name)] ?? null;	1✔
362	}
363
364
365	/**
366	* @deprecated use $texy->htmlOutput->imageRoot etc. instead
367	*/
368	public function &__get(string $name): mixed
369	{
UNCOV 370	return Compat\Legacy::ref($this->texy, Compat\Legacy::OfModule['imageModule'], '$texy->imageModule', $name, 'read');	×
371	}
372
373
374	/**
375	* @deprecated use $texy->htmlOutput->imageRoot etc. instead
376	*/
377	public function __set(string $name, mixed $value): void	1✔
378	{
379	Compat\Legacy::set($this->texy, Compat\Legacy::OfModule['imageModule'], '$texy->imageModule', $name, $value);	1✔
380	}	1✔
381
382
383	public function __isset(string $name): bool
384	{
UNCOV 385	return Compat\Legacy::isSet($this->texy, Compat\Legacy::OfModule['imageModule'], $name);	×
386	}
387	}

dg / texy / 29746802114

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous