Parsedown::blockMedia() - Code Metrics - Inspection of "WIP" - Cecilapp/Cecil - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — images ( 63cf70...07e871 )

by Arnaud

created 2022-09-28 23:54 UTC

Parsedown::blockMedia() D

↳ Parent: Parsedown

Complexity

Conditions	16
Paths	194

Size

Total Lines	129
Code Lines	74

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	2	Features	0

Metric	Value
cc	16
eloc	74
nc	194
nop	1
dl	0
loc	129
rs	4.7833
c	2
b	2
f	0

How to fix Long Method Complexity

<?php

declare(strict_types=1);

/*
 * This file is part of Cecil.
 *
 * Copyright (c) Arnaud Ligny <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Cecil\Converter;

use Cecil\Assets\Asset;
use Cecil\Assets\Image;
use Cecil\Builder;
use Cecil\Exception\RuntimeException;
use Cecil\Util;
use Highlight\Highlighter;

class Parsedown extends \ParsedownToC
{
    /** @var Builder */
    protected $builder;

    /** {@inheritdoc} */
    protected $regexAttribute = '(?:[#.][-\w:\\\]+[ ]*|[-\w:\\\]+(?:=(?:["\'][^\n]*?["\']|[^\s]+)?)?[ ]*)';

    /** Valid a media block (image, audio or video) */
    protected $MarkdownMediaRegex = "~^!\[.*?\]\(.*?\)~";

    /** @var Highlighter */
    protected $highlighter;

    public function __construct(Builder $builder)
    {
        $this->builder = $builder;

        // "insert" line block: ++text++ -> <ins>text</ins>
        $this->InlineTypes['+'][] = 'Insert';
        $this->inlineMarkerList = implode('', array_keys($this->InlineTypes));
        $this->specialCharacters[] = '+';

        // Media (image, audio or video) block
        $this->BlockTypes['!'][] = 'Media';

        // "notes" block
        $this->BlockTypes[':'][] = 'Note';

        // code highlight
        $this->highlighter = new Highlighter();

        // Table of Content
        parent::__construct(['selectors' => $this->builder->getConfig()->get('body.toc')]);
    }

    /**
     * Insert inline.
     * e.g.: ++text++ -> <ins>text</ins>.
     */
    protected function inlineInsert($Excerpt)
    {
        if (!isset($Excerpt['text'][1])) {
            return;
        }

        if ($Excerpt['text'][1] === '+' && preg_match('/^\+\+(?=\S)(.+?)(?<=\S)\+\+/', $Excerpt['text'], $matches)) {
            return [
                'extent'  => strlen($matches[0]),
                'element' => [
                    'name'    => 'ins',
                    'text'    => $matches[1],
                    'handler' => 'line',
                ],
            ];
        }
    }

    /**
     * {@inheritdoc}
     */
    protected function inlineImage($Excerpt)
    {
        $image = parent::inlineImage($Excerpt);
        if (!isset($image)) {
            return null;
        }

        // clean source path / URL
        $image['element']['attributes']['src'] = $this->cleanUrl($image['element']['attributes']['src']);

        // should be lazy loaded?
        if ($this->builder->getConfig()->get('body.images.lazy.enabled')) {
            $image['element']['attributes']['loading'] = 'lazy';
        }

        // disable remote image handling?
        if (Util\Url::isUrl($image['element']['attributes']['src']) && !$this->builder->getConfig()->get('body.images.remote.enabled') ?? true) {
            return $image;
        }

        // create asset
        $asset = new Asset($this->builder, $image['element']['attributes']['src'], ['force_slash' => false]);
        $image['element']['attributes']['src'] = $asset;
        $width = null;
        $height = null;

        /**
         * Should be resized?
         */
        $assetResized = null;
        if ($this->builder->getConfig()->get('body.images.resize.enabled')
            && (
                (isset($image['element']['attributes']['width']) && (int) $image['element']['attributes']['width'] < $asset->getWidth())
                || (isset($image['element']['attributes']['height']) && (int) $image['element']['attributes']['height'] < $asset->getHeight())
            )
        ) {
            if (isset($image['element']['attributes']['width'])) {
                $width = (int) $image['element']['attributes']['width'];
            }
            if (isset($image['element']['attributes']['height'])) {
                $height = (int) $image['element']['attributes']['height'];
            }

            try {
                $assetResized = $asset->resize($width, $height);
                $image['element']['attributes']['src'] = $assetResized;
            } catch (\Exception $e) {
                $this->builder->getLogger()->debug($e->getMessage());

                return $image;
            }
        }

        // set width
        if (!isset($image['element']['attributes']['width']) && $asset['type'] == 'image') {
            $image['element']['attributes']['width'] = ($assetResized ?? $asset)->getWidth();
        }
        // set height
        if (!isset($image['element']['attributes']['height']) && $asset['type'] == 'image') {
            $image['element']['attributes']['height'] = ($assetResized ?? $asset)->getHeight();
        }

        /**
         * Should be responsive?
         */
        if ($this->builder->getConfig()->get('body.images.responsive.enabled') && false === false) {
            if ($srcset = Image::buildSrcset(
                $assetResized ?? $asset,
                $this->builder->getConfig()->get('assets.images.responsive.widths') ?? [480, 640, 768, 1024, 1366, 1600, 1920]
            )) {
                $image['element']['attributes']['srcset'] = $srcset;
                $image['element']['attributes']['sizes'] = $this->builder->getConfig()->get('assets.images.responsive.sizes.default');
            }
        }

        return $image;
    }

    /**
     * Media block support:
     * 1. <picture>/<source> for WebP images
     * 2. <audio> and <video> elements
     * 3. <figure>/<figcaption> for element with a title.
     */
    protected function blockMedia($Excerpt)
    {
        if (1 !== preg_match($this->MarkdownMediaRegex, $Excerpt['text'])) {
            return;
        }

        $InlineImage = $this->inlineImage($Excerpt);
        if (!isset($InlineImage)) {
            return;
        }
        $block = $InlineImage;

        switch ($block['element']['attributes']['alt']) {
            case 'audio':
                $audio = [];
                $audio['element'] = [
                    'name'    => 'audio',
                    'handler' => 'element',
                ];
                $audio['element']['attributes'] = $block['element']['attributes'];
                unset($audio['element']['attributes']['loading']);
                $block = $audio;
                unset($block['element']['attributes']['alt']);
                break;
            case 'video':
                $video = [];
                $video['element'] = [
                    'name'       => 'video',
                    'handler'    => 'element',
                ];
                $video['element']['attributes'] = $block['element']['attributes'];
                unset($video['element']['attributes']['loading']);
                if (isset($block['element']['attributes']['poster'])) {
                    $video['element']['attributes']['poster'] = new Asset($this->builder, $block['element']['attributes']['poster'], ['force_slash' => false]);
                }
                $block = $video;
                unset($block['element']['attributes']['alt']);
        }

        /*
        <!-- if image has a title: a <figure> is required for <figcaption> -->
        <figure>
            <!-- if WebP: a <picture> is required for <source> -->
            <picture>
                <source type="image/webp"
                    srcset="..."
                    sizes="..."
                >
                <img src="..."
                    srcset="..."
                    sizes="..."
                >
            </picture>
            <!-- title -->
            <figcaption>...</figcaption>
        </figure>
        */

        // creates a <picture> used to add WebP <source> in addition to the image <img> element
        if ($this->builder->getConfig()->get('body.images.webp.enabled') ?? false
            && ($InlineImage['element']['attributes']['src'])['type'] == 'image'
            && ($InlineImage['element']['attributes']['src'])['subtype'] != 'image/webp') {
            try {
                // Image src must be an Asset instance
                if (is_string($InlineImage['element']['attributes']['src'])) {
                    throw new RuntimeException(\sprintf('Asset "%s" can\'t be converted to WebP', $InlineImage['element']['attributes']['src']));
                }
                // Image asset is an animated GIF
                if (Image::isAnimatedGif($InlineImage['element']['attributes']['src'])) {
                    throw new RuntimeException(\sprintf('Asset "%s" is an animated GIF and can\'t be converted to WebP', $InlineImage['element']['attributes']['src']));
                }
                $assetWebp = Image::convertTopWebp($InlineImage['element']['attributes']['src'], $this->builder->getConfig()->get('assets.images.quality') ?? 75);
                $srcset = '';
                if ($this->builder->getConfig()->get('body.images.responsive.enabled')) {
                    $srcset = Image::buildSrcset(
                        $assetWebp,
                        $this->builder->getConfig()->get('assets.images.responsive.widths') ?? [480, 640, 768, 1024, 1366, 1600, 1920]
                    );
                }
                if (empty($srcset)) {
                    $srcset = (string) $assetWebp;
                }
                $PictureBlock = [
                    'element' => [
                        'name'    => 'picture',
                        'handler' => 'elements',
                    ],
                ];
                $source = [
                    'element' => [
                        'name'       => 'source',
                        'attributes' => [
                            'type'   => 'image/webp',
                            'srcset' => $srcset,
                            'sizes'  => $this->builder->getConfig()->get('assets.images.responsive.sizes.default'),
                        ],
                    ],
                ];
                $PictureBlock['element']['text'][] = $source['element'];
                $PictureBlock['element']['text'][] = $InlineImage['element'];
                $block = $PictureBlock;
            } catch (\Exception $e) {
                $this->builder->getLogger()->debug($e->getMessage());
            }
        }

        // if there is a title: put the <img> (or <picture>) in a <figure> element to use the <figcaption>
        if ($this->builder->getConfig()->get('body.images.caption.enabled') && !empty($InlineImage['element']['attributes']['title'])) {
            $FigureBlock = [
                'element' => [
                    'name'    => 'figure',
                    'handler' => 'elements',
                    'text'    => [
                        $block['element'],
                    ],
                ],
            ];
            $InlineFigcaption = [
                'element' => [
                    'name' => 'figcaption',
                    'text' => $InlineImage['element']['attributes']['title'],
                ],
            ];
            $FigureBlock['element']['text'][] = $InlineFigcaption['element'];

            return $FigureBlock;
        }

        return $block;
    }

    /**
     * Note block-level markup.
     *
     * :::tip
     * **Tip:** This is an advice.
     * :::
     *
     * Code inspired by https://github.com/sixlive/parsedown-alert from TJ Miller (@sixlive).
     */
    protected function blockNote($block)
    {
        if (preg_match('/:::(.*)/', $block['text'], $matches)) {
            $block = [
                'char'    => ':',
                'element' => [
                    'name'       => 'aside',
                    'text'       => '',
                    'attributes' => [
                        'class' => 'note',
                    ],
                ],
            ];
            if (!empty($matches[1])) {
                $block['element']['attributes']['class'] .= " note-{$matches[1]}";
            }

            return $block;
        }
    }

    protected function blockNoteContinue($line, $block)
    {
        if (isset($block['complete'])) {
            return;
        }
        if (preg_match('/:::/', $line['text'])) {
            $block['complete'] = true;

            return $block;
        }
        $block['element']['text'] .= $line['text']."\n";

        return $block;
    }

    protected function blockNoteComplete($block)
    {
        $block['element']['rawHtml'] = $this->text($block['element']['text']);
        unset($block['element']['text']);

        return $block;
    }

    /**
     * Apply Highlight to code blocks.
     */
    protected function blockFencedCodeComplete($block)
    {
        if (!$this->builder->getConfig()->get('body.highlight.enabled')) {
            return $block;
        }
        if (!isset($block['element']['text']['attributes'])) {
            return $block;
        }

        $code = $block['element']['text']['text'];
        unset($block['element']['text']['text']);
        $languageClass = $block['element']['text']['attributes']['class'];
        $language = explode('-', $languageClass);
        $highlighted = $this->highlighter->highlight($language[1], $code);
        $block['element']['text']['attributes']['class'] = vsprintf('%s hljs %s', [
            $languageClass,
            $highlighted->language,
        ]);
        $block['element']['text']['rawHtml'] = $highlighted->value;
        $block['element']['text']['allowRawHtmlInSafeMode'] = true;

        return $block;
    }

    /**
     * {@inheritdoc}
     */
    protected function parseAttributeData($attributeString)
    {
        $attributes = preg_split('/[ ]+/', $attributeString, -1, PREG_SPLIT_NO_EMPTY);
        $Data = [];
        $HtmlAtt = [];

        foreach ($attributes as $attribute) {
            switch ($attribute[0]) {
                case '#': // ID
                    $Data['id'] = substr($attribute, 1);
                    break;
                case '.': // Classes
                    $classes[] = substr($attribute, 1);
                    break;
                default:  // Attributes
                    parse_str($attribute, $parsed);
                    $HtmlAtt = array_merge($HtmlAtt, $parsed);
            }
        }

        if (isset($classes)) {
            $Data['class'] = implode(' ', $classes);
        }
        if (!empty($HtmlAtt)) {
            foreach ($HtmlAtt as $a => $v) {
                $Data[$a] = trim($v, '"');
            }
        }

        return $Data;
    }

    /**
     * Returns URL without query string.
     */
    private function cleanUrl(string $path): string
    {
        return strtok(trim($path), '?') ?: trim($path);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of Cecil.
7			*
8			* Copyright (c) Arnaud Ligny <[email protected]>
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace Cecil\Converter;
15
16			use Cecil\Assets\Asset;
17			use Cecil\Assets\Image;
18			use Cecil\Builder;
19			use Cecil\Exception\RuntimeException;
20			use Cecil\Util;
21			use Highlight\Highlighter;
22
23			class Parsedown extends \ParsedownToC
24			{
25			/** @var Builder */
26			protected $builder;
27
28			/** {@inheritdoc} */
29			protected $regexAttribute = '(?:[#.][-\w:\\\]+[ ]\|[-\w:\\\]+(?:=(?:["\'][^\n]?["\']\|[^\s]+)?)?[ ]*)';
30
31			/** Valid a media block (image, audio or video) */
32			protected $MarkdownMediaRegex = "~^!\[.?\]\(.?\)~";
33
34			/** @var Highlighter */
35			protected $highlighter;
36
37			public function __construct(Builder $builder)
38			{
39			$this->builder = $builder;
40
41			// "insert" line block: ++text++ -> <ins>text</ins>
42			$this->InlineTypes['+'][] = 'Insert';
43			$this->inlineMarkerList = implode('', array_keys($this->InlineTypes));
44			$this->specialCharacters[] = '+';
45
46			// Media (image, audio or video) block
47			$this->BlockTypes['!'][] = 'Media';
48
49			// "notes" block
50			$this->BlockTypes[':'][] = 'Note';
51
52			// code highlight
53			$this->highlighter = new Highlighter();
54
55			// Table of Content
56			parent::__construct(['selectors' => $this->builder->getConfig()->get('body.toc')]);
57			}
58
59			/**
60			* Insert inline.
61			* e.g.: ++text++ -> <ins>text</ins>.
62			*/
63			protected function inlineInsert($Excerpt)
64			{
65			if (!isset($Excerpt['text'][1])) {
66			return;
67			}
68
69			if ($Excerpt['text'][1] === '+' && preg_match('/^\+\+(?=\S)(.+?)(?<=\S)\+\+/', $Excerpt['text'], $matches)) {
70			return [
71			'extent' => strlen($matches[0]),
72			'element' => [
73			'name' => 'ins',
74			'text' => $matches[1],
75			'handler' => 'line',
76			],
77			];
78			}
79			}
80
81			/**
82			* {@inheritdoc}
83			*/
84			protected function inlineImage($Excerpt)
85			{
86			$image = parent::inlineImage($Excerpt);
87			if (!isset($image)) {
88			return null;
89			}
90
91			// clean source path / URL
92			$image['element']['attributes']['src'] = $this->cleanUrl($image['element']['attributes']['src']);
93
94			// should be lazy loaded?
95			if ($this->builder->getConfig()->get('body.images.lazy.enabled')) {
96			$image['element']['attributes']['loading'] = 'lazy';
97			}
98
99			// disable remote image handling?
100			if (Util\Url::isUrl($image['element']['attributes']['src']) && !$this->builder->getConfig()->get('body.images.remote.enabled') ?? true) {
101			return $image;
102			}
103
104			// create asset
105			$asset = new Asset($this->builder, $image['element']['attributes']['src'], ['force_slash' => false]);
106			$image['element']['attributes']['src'] = $asset;
107			$width = null;
108			$height = null;
109
110			/**
111			* Should be resized?
112			*/
113			$assetResized = null;
114			if ($this->builder->getConfig()->get('body.images.resize.enabled')
115			&& (
116			(isset($image['element']['attributes']['width']) && (int) $image['element']['attributes']['width'] < $asset->getWidth())
117			\|\| (isset($image['element']['attributes']['height']) && (int) $image['element']['attributes']['height'] < $asset->getHeight())
118			)
119			) {
120			if (isset($image['element']['attributes']['width'])) {
121			$width = (int) $image['element']['attributes']['width'];
122			}
123			if (isset($image['element']['attributes']['height'])) {
124			$height = (int) $image['element']['attributes']['height'];
125			}
126
127			try {
128			$assetResized = $asset->resize($width, $height);
129			$image['element']['attributes']['src'] = $assetResized;
130			} catch (\Exception $e) {
131			$this->builder->getLogger()->debug($e->getMessage());
132
133			return $image;
134			}
135			}
136
137			// set width
138			if (!isset($image['element']['attributes']['width']) && $asset['type'] == 'image') {
139			$image['element']['attributes']['width'] = ($assetResized ?? $asset)->getWidth();
140			}
141			// set height
142			if (!isset($image['element']['attributes']['height']) && $asset['type'] == 'image') {
143			$image['element']['attributes']['height'] = ($assetResized ?? $asset)->getHeight();
144			}
145
146			/**
147			* Should be responsive?
148			*/
149			if ($this->builder->getConfig()->get('body.images.responsive.enabled') && false === false) {
150			if ($srcset = Image::buildSrcset(
151			$assetResized ?? $asset,
152			$this->builder->getConfig()->get('assets.images.responsive.widths') ?? [480, 640, 768, 1024, 1366, 1600, 1920]
153			)) {
154			$image['element']['attributes']['srcset'] = $srcset;
155			$image['element']['attributes']['sizes'] = $this->builder->getConfig()->get('assets.images.responsive.sizes.default');
156			}
157			}
158
159			return $image;
160			}
161
162			/**
163			* Media block support:
164			* 1. <picture>/<source> for WebP images
165			* 2. <audio> and <video> elements
166			* 3. <figure>/<figcaption> for element with a title.
167			*/
168			protected function blockMedia($Excerpt)
169			{
170			if (1 !== preg_match($this->MarkdownMediaRegex, $Excerpt['text'])) {
171			return;
172			}
173
174			$InlineImage = $this->inlineImage($Excerpt);
175			if (!isset($InlineImage)) {
176			return;
177			}
178			$block = $InlineImage;
179
180			switch ($block['element']['attributes']['alt']) {
181			case 'audio':
182			$audio = [];
183			$audio['element'] = [
184			'name' => 'audio',
185			'handler' => 'element',
186			];
187			$audio['element']['attributes'] = $block['element']['attributes'];
188			unset($audio['element']['attributes']['loading']);
189			$block = $audio;
190			unset($block['element']['attributes']['alt']);
191			break;
192			case 'video':
193			$video = [];
194			$video['element'] = [
195			'name' => 'video',
196			'handler' => 'element',
197			];
198			$video['element']['attributes'] = $block['element']['attributes'];
199			unset($video['element']['attributes']['loading']);
200			if (isset($block['element']['attributes']['poster'])) {
201			$video['element']['attributes']['poster'] = new Asset($this->builder, $block['element']['attributes']['poster'], ['force_slash' => false]);
202			}
203			$block = $video;
204			unset($block['element']['attributes']['alt']);
205			}
206
207			/*
208			<!-- if image has a title: a <figure> is required for <figcaption> -->
209			<figure>
210			<!-- if WebP: a <picture> is required for <source> -->
211			<picture>
212			<source type="image/webp"
213			srcset="..."
214			sizes="..."
215			>
216			<img src="..."
217			srcset="..."
218			sizes="..."
219			>
220			</picture>
221			<!-- title -->
222			<figcaption>...</figcaption>
223			</figure>
224			*/
225
226			// creates a <picture> used to add WebP <source> in addition to the image <img> element
227			if ($this->builder->getConfig()->get('body.images.webp.enabled') ?? false
228			&& ($InlineImage['element']['attributes']['src'])['type'] == 'image'
229			&& ($InlineImage['element']['attributes']['src'])['subtype'] != 'image/webp') {
230			try {
231			// Image src must be an Asset instance
232			if (is_string($InlineImage['element']['attributes']['src'])) {
233			throw new RuntimeException(\sprintf('Asset "%s" can\'t be converted to WebP', $InlineImage['element']['attributes']['src']));
234			}
235			// Image asset is an animated GIF
236			if (Image::isAnimatedGif($InlineImage['element']['attributes']['src'])) {
237			throw new RuntimeException(\sprintf('Asset "%s" is an animated GIF and can\'t be converted to WebP', $InlineImage['element']['attributes']['src']));
238			}
239			$assetWebp = Image::convertTopWebp($InlineImage['element']['attributes']['src'], $this->builder->getConfig()->get('assets.images.quality') ?? 75);
240			$srcset = '';
241			if ($this->builder->getConfig()->get('body.images.responsive.enabled')) {
242			$srcset = Image::buildSrcset(
243			$assetWebp,
244			$this->builder->getConfig()->get('assets.images.responsive.widths') ?? [480, 640, 768, 1024, 1366, 1600, 1920]
245			);
246			}
247			if (empty($srcset)) {
248			$srcset = (string) $assetWebp;
249			}
250			$PictureBlock = [
251			'element' => [
252			'name' => 'picture',
253			'handler' => 'elements',
254			],
255			];
256			$source = [
257			'element' => [
258			'name' => 'source',
259			'attributes' => [
260			'type' => 'image/webp',
261			'srcset' => $srcset,
262			'sizes' => $this->builder->getConfig()->get('assets.images.responsive.sizes.default'),
263			],
264			],
265			];
266			$PictureBlock['element']['text'][] = $source['element'];
267			$PictureBlock['element']['text'][] = $InlineImage['element'];
268			$block = $PictureBlock;
269			} catch (\Exception $e) {
270			$this->builder->getLogger()->debug($e->getMessage());
271			}
272			}
273
274			// if there is a title: put the <img> (or <picture>) in a <figure> element to use the <figcaption>
275			if ($this->builder->getConfig()->get('body.images.caption.enabled') && !empty($InlineImage['element']['attributes']['title'])) {
276			$FigureBlock = [
277			'element' => [
278			'name' => 'figure',
279			'handler' => 'elements',
280			'text' => [
281			$block['element'],
282			],
283			],
284			];
285			$InlineFigcaption = [
286			'element' => [
287			'name' => 'figcaption',
288			'text' => $InlineImage['element']['attributes']['title'],
289			],
290			];
291			$FigureBlock['element']['text'][] = $InlineFigcaption['element'];
292
293			return $FigureBlock;
294			}
295
296			return $block;
297			}
298
299			/**
300			* Note block-level markup.
301			*
302			* :::tip
303			* Tip: This is an advice.
304			* :::
305			*
306			* Code inspired by https://github.com/sixlive/parsedown-alert from TJ Miller (@sixlive).
307			*/
308			protected function blockNote($block)
309			{
310			if (preg_match('/:::(.*)/', $block['text'], $matches)) {
311			$block = [
312			'char' => ':',
313			'element' => [
314			'name' => 'aside',
315			'text' => '',
316			'attributes' => [
317			'class' => 'note',
318			],
319			],
320			];
321			if (!empty($matches[1])) {
322			$block['element']['attributes']['class'] .= " note-{$matches[1]}";
323			}
324
325			return $block;
326			}
327			}
328
329			protected function blockNoteContinue($line, $block)
330			{
331			if (isset($block['complete'])) {
332			return;
333			}
334			if (preg_match('/:::/', $line['text'])) {
335			$block['complete'] = true;
336
337			return $block;
338			}
339			$block['element']['text'] .= $line['text']."\n";
340
341			return $block;
342			}
343
344			protected function blockNoteComplete($block)
345			{
346			$block['element']['rawHtml'] = $this->text($block['element']['text']);
347			unset($block['element']['text']);
348
349			return $block;
350			}
351
352			/**
353			* Apply Highlight to code blocks.
354			*/
355			protected function blockFencedCodeComplete($block)
356			{
357			if (!$this->builder->getConfig()->get('body.highlight.enabled')) {
358			return $block;
359			}
360			if (!isset($block['element']['text']['attributes'])) {
361			return $block;
362			}
363
364			$code = $block['element']['text']['text'];
365			unset($block['element']['text']['text']);
366			$languageClass = $block['element']['text']['attributes']['class'];
367			$language = explode('-', $languageClass);
368			$highlighted = $this->highlighter->highlight($language[1], $code);
369			$block['element']['text']['attributes']['class'] = vsprintf('%s hljs %s', [
370			$languageClass,
371			$highlighted->language,
372			]);
373			$block['element']['text']['rawHtml'] = $highlighted->value;
374			$block['element']['text']['allowRawHtmlInSafeMode'] = true;
375
376			return $block;
377			}
378
379			/**
380			* {@inheritdoc}
381			*/
382			protected function parseAttributeData($attributeString)
383			{
384			$attributes = preg_split('/[ ]+/', $attributeString, -1, PREG_SPLIT_NO_EMPTY);
385			$Data = [];
386			$HtmlAtt = [];
387
388			foreach ($attributes as $attribute) {
389			switch ($attribute[0]) {
390			case '#': // ID
391			$Data['id'] = substr($attribute, 1);
392			break;
393			case '.': // Classes
394			$classes[] = substr($attribute, 1);
395			break;
396			default: // Attributes
397			parse_str($attribute, $parsed);
398			$HtmlAtt = array_merge($HtmlAtt, $parsed);
399			}
400			}
401
402			if (isset($classes)) {
403			$Data['class'] = implode(' ', $classes);
404			}
405			if (!empty($HtmlAtt)) {
406			foreach ($HtmlAtt as $a => $v) {
407			$Data[$a] = trim($v, '"');
408			}
409			}
410
411			return $Data;
412			}
413
414			/**
415			* Returns URL without query string.
416			*/
417			private function cleanUrl(string $path): string
418			{
419			return strtok(trim($path), '?') ?: trim($path);
420			}
421			}
422

Cecilapp / Cecil

Push — images ( 63cf70...07e871 )

Parsedown::blockMedia() D

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like