DelimiterParser::determineCanOpenOrClose() - Code Metrics - thephpleague/commonmark - Measure and Improve Code Quality continuously with Scrutinizer

DelimiterParser::determineCanOpenOrClose() C
last analyzed 2025-11-24 00:12 UTC

↳ Parent: DelimiterParser

Complexity

Conditions	14
Paths	208

Size

Total Lines	19
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	14
eloc	13
nc	208
nop	4
dl	0
loc	19
rs	5.3333
c	0
b	0
f	0

How to fix Complexity

<?php

declare(strict_types=1);

namespace League\CommonMark\Delimiter;

use League\CommonMark\Delimiter\Processor\DelimiterProcessorCollection;
use League\CommonMark\Delimiter\Processor\DelimiterProcessorInterface;
use League\CommonMark\Node\Inline\Text;
use League\CommonMark\Parser\Inline\InlineParserInterface;
use League\CommonMark\Parser\Inline\InlineParserMatch;
use League\CommonMark\Parser\InlineParserContext;
use League\CommonMark\Util\RegexHelper;

/**
 * Delimiter parsing is implemented as an Inline Parser with the lowest-possible priority
 *
 * @internal
 */
final class DelimiterParser implements InlineParserInterface
{
    private DelimiterProcessorCollection $collection;

    public function __construct(DelimiterProcessorCollection $collection)
    {
        $this->collection = $collection;
    }

    public function getMatchDefinition(): InlineParserMatch
    {
        return InlineParserMatch::oneOf(...$this->collection->getDelimiterCharacters());
    }

    public function parse(InlineParserContext $inlineContext): bool
    {
        $character = $inlineContext->getFullMatch();
        $numDelims = 0;
        $cursor    = $inlineContext->getCursor();
        $processor = $this->collection->getDelimiterProcessor($character);

        \assert($processor !== null); // Delimiter processor should never be null here

        $charBefore = $cursor->peek(-1);
        if ($charBefore === null) {
            $charBefore = "\n";
        }

        while ($cursor->peek($numDelims) === $character) {
            ++$numDelims;
        }

        if ($numDelims < $processor->getMinLength()) {
            return false;
        }

        $cursor->advanceBy($numDelims);

        $charAfter = $cursor->getCurrentCharacter();
        if ($charAfter === null) {
            $charAfter = "\n";
        }

        [$canOpen, $canClose] = self::determineCanOpenOrClose($charBefore, $charAfter, $character, $processor);

        if (! ($canOpen || $canClose)) {
            $inlineContext->getContainer()->appendChild(new Text(\str_repeat($character, $numDelims)));

            return true;
        }

        $node = new Text(\str_repeat($character, $numDelims), [
            'delim' => true,
        ]);
        $inlineContext->getContainer()->appendChild($node);

        // Add entry to stack to this opener
        $delimiter = new Delimiter($character, $numDelims, $node, $canOpen, $canClose, $inlineContext->getCursor()->getPosition());
        $inlineContext->getDelimiterStack()->push($delimiter);

        return true;
    }

    /**
     * @return bool[]
     */
    private static function determineCanOpenOrClose(string $charBefore, string $charAfter, string $character, DelimiterProcessorInterface $delimiterProcessor): array
    {
        $afterIsWhitespace   = \preg_match(RegexHelper::REGEX_UNICODE_WHITESPACE_CHAR, $charAfter);
        $afterIsPunctuation  = \preg_match(RegexHelper::REGEX_PUNCTUATION, $charAfter);
        $beforeIsWhitespace  = \preg_match(RegexHelper::REGEX_UNICODE_WHITESPACE_CHAR, $charBefore);
        $beforeIsPunctuation = \preg_match(RegexHelper::REGEX_PUNCTUATION, $charBefore);

        $leftFlanking  = ! $afterIsWhitespace && (! $afterIsPunctuation || $beforeIsWhitespace || $beforeIsPunctuation);
        $rightFlanking = ! $beforeIsWhitespace && (! $beforeIsPunctuation || $afterIsWhitespace || $afterIsPunctuation);

        if ($character === '_') {
            $canOpen  = $leftFlanking && (! $rightFlanking || $beforeIsPunctuation);
            $canClose = $rightFlanking && (! $leftFlanking || $afterIsPunctuation);
        } else {
            $canOpen  = $leftFlanking && $character === $delimiterProcessor->getOpeningCharacter();
            $canClose = $rightFlanking && $character === $delimiterProcessor->getClosingCharacter();
        }

        return [$canOpen, $canClose];
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace League\CommonMark\Delimiter;
6
7			use League\CommonMark\Delimiter\Processor\DelimiterProcessorCollection;
8			use League\CommonMark\Delimiter\Processor\DelimiterProcessorInterface;
9			use League\CommonMark\Node\Inline\Text;
10			use League\CommonMark\Parser\Inline\InlineParserInterface;
11			use League\CommonMark\Parser\Inline\InlineParserMatch;
12			use League\CommonMark\Parser\InlineParserContext;
13			use League\CommonMark\Util\RegexHelper;
14
15			/**
16			* Delimiter parsing is implemented as an Inline Parser with the lowest-possible priority
17			*
18			* @internal
19			*/
20			final class DelimiterParser implements InlineParserInterface
21			{
22			private DelimiterProcessorCollection $collection;
23
24			public function __construct(DelimiterProcessorCollection $collection)
25			{
26			$this->collection = $collection;
27			}
28
29			public function getMatchDefinition(): InlineParserMatch
30			{
31			return InlineParserMatch::oneOf(...$this->collection->getDelimiterCharacters());
32			}
33
34			public function parse(InlineParserContext $inlineContext): bool
35			{
36			$character = $inlineContext->getFullMatch();
37			$numDelims = 0;
38			$cursor = $inlineContext->getCursor();
39			$processor = $this->collection->getDelimiterProcessor($character);
40
41			\assert($processor !== null); // Delimiter processor should never be null here
42
43			$charBefore = $cursor->peek(-1);
44			if ($charBefore === null) {
45			$charBefore = "\n";
46			}
47
48			while ($cursor->peek($numDelims) === $character) {
49			++$numDelims;
50			}
51
52			if ($numDelims < $processor->getMinLength()) {
53			return false;
54			}
55
56			$cursor->advanceBy($numDelims);
57
58			$charAfter = $cursor->getCurrentCharacter();
59			if ($charAfter === null) {
60			$charAfter = "\n";
61			}
62
63			[$canOpen, $canClose] = self::determineCanOpenOrClose($charBefore, $charAfter, $character, $processor);
64
65			if (! ($canOpen \|\| $canClose)) {
66			$inlineContext->getContainer()->appendChild(new Text(\str_repeat($character, $numDelims)));
67
68			return true;
69			}
70
71			$node = new Text(\str_repeat($character, $numDelims), [
72			'delim' => true,
73			]);
74			$inlineContext->getContainer()->appendChild($node);
75
76			// Add entry to stack to this opener
77			$delimiter = new Delimiter($character, $numDelims, $node, $canOpen, $canClose, $inlineContext->getCursor()->getPosition());
78			$inlineContext->getDelimiterStack()->push($delimiter);
79
80			return true;
81			}
82
83			/**
84			* @return bool[]
85			*/
86			private static function determineCanOpenOrClose(string $charBefore, string $charAfter, string $character, DelimiterProcessorInterface $delimiterProcessor): array
87			{
88			$afterIsWhitespace = \preg_match(RegexHelper::REGEX_UNICODE_WHITESPACE_CHAR, $charAfter);
89			$afterIsPunctuation = \preg_match(RegexHelper::REGEX_PUNCTUATION, $charAfter);
90			$beforeIsWhitespace = \preg_match(RegexHelper::REGEX_UNICODE_WHITESPACE_CHAR, $charBefore);
91			$beforeIsPunctuation = \preg_match(RegexHelper::REGEX_PUNCTUATION, $charBefore);
92
93			$leftFlanking = ! $afterIsWhitespace && (! $afterIsPunctuation \|\| $beforeIsWhitespace \|\| $beforeIsPunctuation);
94			$rightFlanking = ! $beforeIsWhitespace && (! $beforeIsPunctuation \|\| $afterIsWhitespace \|\| $afterIsPunctuation);
95
96			if ($character === '_') {
97			$canOpen = $leftFlanking && (! $rightFlanking \|\| $beforeIsPunctuation);
98			$canClose = $rightFlanking && (! $leftFlanking \|\| $afterIsPunctuation);
99			} else {
100			$canOpen = $leftFlanking && $character === $delimiterProcessor->getOpeningCharacter();
101			$canClose = $rightFlanking && $character === $delimiterProcessor->getClosingCharacter();
102			}
103
104			return [$canOpen, $canClose];
105			}
106			}
107

thephpleague / commonmark

DelimiterParser::determineCanOpenOrClose() C last analyzed 2025-11-24 00:12 UTC

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like

DelimiterParser::determineCanOpenOrClose() C
last analyzed 2025-11-24 00:12 UTC