CloseBracketParser   A
last analyzed

Complexity

Total Complexity 23

Size/Duplication

Total Lines 196
Duplicated Lines 0 %

Coupling/Cohesion

Components 1
Dependencies 12

Test Coverage

Coverage 98.63%

Importance

Changes 0
Metric Value
wmc 23
lcom 1
cbo 12
dl 0
loc 196
ccs 72
cts 73
cp 0.9863
rs 10
c 0
b 0
f 0

7 Methods

Rating   Name   Duplication   Size   Complexity  
A getCharacters() 0 4 1
A setEnvironment() 0 4 1
A tryParseLink() 0 14 3
B parse() 0 56 6
A tryParseReference() 0 23 5
A createInline() 0 8 2
A tryParseInlineLinkAndTitle() 0 34 5
1
<?php
2
3
/*
4
 * This file is part of the league/commonmark package.
5
 *
6
 * (c) Colin O'Dell <[email protected]>
7
 *
8
 * Original code based on the CommonMark JS reference parser (https://bitly.com/commonmark-js)
9
 *  - (c) John MacFarlane
10
 *
11
 * For the full copyright and license information, please view the LICENSE
12
 * file that was distributed with this source code.
13
 */
14
15
namespace League\CommonMark\Inline\Parser;
16
17
use League\CommonMark\Cursor;
18
use League\CommonMark\Delimiter\DelimiterInterface;
19
use League\CommonMark\EnvironmentAwareInterface;
20
use League\CommonMark\EnvironmentInterface;
21
use League\CommonMark\Inline\AdjacentTextMerger;
22
use League\CommonMark\Inline\Element\AbstractWebResource;
23
use League\CommonMark\Inline\Element\Image;
24
use League\CommonMark\Inline\Element\Link;
25
use League\CommonMark\InlineParserContext;
26
use League\CommonMark\Reference\ReferenceInterface;
27
use League\CommonMark\Reference\ReferenceMapInterface;
28
use League\CommonMark\Util\LinkParserHelper;
29
use League\CommonMark\Util\RegexHelper;
30
31
final class CloseBracketParser implements InlineParserInterface, EnvironmentAwareInterface
32
{
33
    /**
34
     * @var EnvironmentInterface
35
     */
36
    private $environment;
37
38
    /**
39
     * @return string[]
40
     */
41 2064
    public function getCharacters(): array
42
    {
43 2064
        return [']'];
44
    }
45
46
    /**
47
     * @param InlineParserContext $inlineContext
48
     *
49
     * @return bool
50
     */
51 432
    public function parse(InlineParserContext $inlineContext): bool
52
    {
53
        // Look through stack of delimiters for a [ or !
54 432
        $opener = $inlineContext->getDelimiterStack()->searchByCharacter(['[', '!']);
55 432
        if ($opener === null) {
56 12
            return false;
57
        }
58
59 423
        if (!$opener->isActive()) {
60
            // no matched opener; remove from emphasis stack
61 18
            $inlineContext->getDelimiterStack()->removeDelimiter($opener);
62
63 18
            return false;
64
        }
65
66 423
        $cursor = $inlineContext->getCursor();
67
68 423
        $startPos = $cursor->getPosition();
69 423
        $previousState = $cursor->saveState();
70
71 423
        $cursor->advance();
72
73
        // Check to see if we have a link/image
74 423
        if (!($link = $this->tryParseLink($cursor, $inlineContext->getReferenceMap(), $opener, $startPos))) {
75
            // No match
76 108
            $inlineContext->getDelimiterStack()->removeDelimiter($opener); // Remove this opener from stack
77 108
            $cursor->restoreState($previousState);
78
79 108
            return false;
80
        }
81
82 345
        $isImage = $opener->getChar() === '!';
83
84 345
        $inline = $this->createInline($link['url'], $link['title'], $isImage);
85 345
        $opener->getInlineNode()->replaceWith($inline);
86 345
        while (($label = $inline->next()) !== null) {
87 342
            $inline->appendChild($label);
88
        }
89
90
        // Process delimiters such as emphasis inside link/image
91 345
        $delimiterStack = $inlineContext->getDelimiterStack();
92 345
        $stackBottom = $opener->getPrevious();
93 345
        $delimiterStack->processDelimiters($stackBottom, $this->environment->getDelimiterProcessors());
94 345
        $delimiterStack->removeAll($stackBottom);
95
96
        // Merge any adjacent Text nodes together
97 345
        AdjacentTextMerger::mergeChildNodes($inline);
98
99
        // processEmphasis will remove this and later delimiters.
100
        // Now, for a link, we also remove earlier link openers (no links in links)
101 345
        if (!$isImage) {
102 291
            $inlineContext->getDelimiterStack()->removeEarlierMatches('[');
103
        }
104
105 345
        return true;
106
    }
107
108
    /**
109
     * @param EnvironmentInterface $environment
110
     */
111 2064
    public function setEnvironment(EnvironmentInterface $environment)
112
    {
113 2064
        $this->environment = $environment;
114 2064
    }
115
116
    /**
117
     * @param Cursor                $cursor
118
     * @param ReferenceMapInterface $referenceMap
119
     * @param DelimiterInterface    $opener
120
     * @param int                   $startPos
121
     *
122
     * @return array|bool
123
     */
124 423
    private function tryParseLink(Cursor $cursor, ReferenceMapInterface $referenceMap, DelimiterInterface $opener, int $startPos)
125
    {
126
        // Check to see if we have a link/image
127
        // Inline link?
128 423
        if ($result = $this->tryParseInlineLinkAndTitle($cursor)) {
129 153
            return $result;
130
        }
131
132 285
        if ($link = $this->tryParseReference($cursor, $referenceMap, $opener, $startPos)) {
133 198
            return ['url' => $link->getDestination(), 'title' => $link->getTitle()];
134
        }
135
136 108
        return false;
137
    }
138
139
    /**
140
     * @param Cursor $cursor
141
     *
142
     * @return array|bool
143
     */
144 423
    private function tryParseInlineLinkAndTitle(Cursor $cursor)
145
    {
146 423
        if ($cursor->getCharacter() !== '(') {
147 249
            return false;
148
        }
149
150 183
        $previousState = $cursor->saveState();
151
152 183
        $cursor->advance();
153 183
        $cursor->advanceToNextNonSpaceOrNewline();
154 183
        if (($dest = LinkParserHelper::parseLinkDestination($cursor)) === null) {
155 9
            $cursor->restoreState($previousState);
156
157 9
            return false;
158
        }
159
160 177
        $cursor->advanceToNextNonSpaceOrNewline();
161
162 177
        $title = '';
163
        // make sure there's a space before the title:
164 177
        if (\preg_match(RegexHelper::REGEX_WHITESPACE_CHAR, $cursor->peek(-1))) {
165 54
            $title = LinkParserHelper::parseLinkTitle($cursor) ?? '';
166
        }
167
168 177
        $cursor->advanceToNextNonSpaceOrNewline();
169
170 177
        if ($cursor->match('/^\\)/') === null) {
171 30
            $cursor->restoreState($previousState);
172
173 30
            return false;
174
        }
175
176 153
        return ['url' => $dest, 'title' => $title];
177
    }
178
179
    /**
180
     * @param Cursor                $cursor
181
     * @param ReferenceMapInterface $referenceMap
182
     * @param DelimiterInterface    $opener
183
     * @param int                   $startPos
184
     *
185
     * @return ReferenceInterface|null
186
     */
187 285
    private function tryParseReference(Cursor $cursor, ReferenceMapInterface $referenceMap, DelimiterInterface $opener, int $startPos): ?ReferenceInterface
188
    {
189 285
        if ($opener->getIndex() === null) {
190
            return null;
191
        }
192
193 285
        $savePos = $cursor->saveState();
194 285
        $beforeLabel = $cursor->getPosition();
195 285
        $n = LinkParserHelper::parseLinkLabel($cursor);
196 285
        if ($n === 0 || $n === 2) {
197
            // Empty or missing second label
198 234
            $reflabel = \mb_substr($cursor->getLine(), $opener->getIndex(), $startPos - $opener->getIndex(), 'utf-8');
199
        } else {
200 63
            $reflabel = \mb_substr($cursor->getLine(), $beforeLabel + 1, $n - 2, 'utf-8');
201
        }
202
203 285
        if ($n === 0) {
204
            // If shortcut reference link, rewind before spaces we skipped
205 210
            $cursor->restoreState($savePos);
206
        }
207
208 285
        return $referenceMap->getReference($reflabel);
209
    }
210
211
    /**
212
     * @param string $url
213
     * @param string $title
214
     * @param bool   $isImage
215
     *
216
     * @return AbstractWebResource
217
     */
218 345
    private function createInline(string $url, string $title, bool $isImage)
219
    {
220 345
        if ($isImage) {
221 72
            return new Image($url, null, $title);
222
        }
223
224 291
        return new Link($url, null, $title);
225
    }
226
}
227