1 | <?php |
||
2 | |||
3 | declare(strict_types=1); |
||
4 | |||
5 | /* |
||
6 | * This is part of the league/commonmark package. |
||
7 | * |
||
8 | * (c) Martin Hasoň <[email protected]> |
||
9 | * (c) Webuni s.r.o. <[email protected]> |
||
10 | * (c) Colin O'Dell <[email protected]> |
||
11 | * |
||
12 | * For the full copyright and license information, please view the LICENSE |
||
13 | * file that was distributed with this source code. |
||
14 | */ |
||
15 | |||
16 | namespace League\CommonMark\Extension\Table; |
||
17 | |||
18 | use League\CommonMark\Node\Block\AbstractBlock; |
||
19 | use League\CommonMark\Parser\Block\AbstractBlockContinueParser; |
||
20 | use League\CommonMark\Parser\Block\BlockContinue; |
||
21 | use League\CommonMark\Parser\Block\BlockContinueParserInterface; |
||
22 | use League\CommonMark\Parser\Cursor; |
||
23 | use League\CommonMark\Parser\InlineParserEngineInterface; |
||
24 | use League\CommonMark\Util\ArrayCollection; |
||
25 | |||
26 | final class TableParser extends AbstractBlockContinueParser |
||
27 | { |
||
28 | /** |
||
29 | * @var Table |
||
30 | * |
||
31 | * @psalm-readonly |
||
32 | */ |
||
33 | private $block; |
||
34 | |||
35 | /** |
||
36 | * @var ArrayCollection<string> |
||
37 | * |
||
38 | * @psalm-readonly-allow-private-mutation |
||
39 | */ |
||
40 | private $bodyLines; |
||
41 | |||
42 | /** |
||
43 | * @var array<int, string|null> |
||
44 | * |
||
45 | * @psalm-readonly |
||
46 | */ |
||
47 | private $columns; |
||
48 | |||
49 | /** |
||
50 | * @var array<int, string> |
||
51 | * |
||
52 | * @psalm-readonly-allow-private-mutation |
||
53 | */ |
||
54 | private $headerCells; |
||
55 | |||
56 | /** |
||
57 | * @var bool |
||
58 | * |
||
59 | * @psalm-readonly-allow-private-mutation |
||
60 | */ |
||
61 | private $nextIsSeparatorLine = true; |
||
62 | |||
63 | /** |
||
64 | * @param array<int, string|null> $columns |
||
65 | * @param array<int, string> $headerCells |
||
66 | */ |
||
67 | 72 | public function __construct(array $columns, array $headerCells) |
|
68 | { |
||
69 | 72 | $this->block = new Table(); |
|
70 | 72 | $this->bodyLines = new ArrayCollection(); |
|
71 | 72 | $this->columns = $columns; |
|
72 | 72 | $this->headerCells = $headerCells; |
|
73 | 72 | } |
|
74 | |||
75 | 12 | public function canHaveLazyContinuationLines(): bool |
|
76 | { |
||
77 | 12 | return true; |
|
78 | } |
||
79 | |||
80 | /** |
||
81 | * @return Table |
||
82 | */ |
||
83 | 72 | public function getBlock(): AbstractBlock |
|
84 | { |
||
85 | 72 | return $this->block; |
|
86 | } |
||
87 | |||
88 | 69 | public function tryContinue(Cursor $cursor, BlockContinueParserInterface $activeBlockParser): ?BlockContinue |
|
89 | { |
||
90 | 69 | if (\strpos($cursor->getLine(), '|') === false) { |
|
91 | 24 | return BlockContinue::none(); |
|
1 ignored issue
–
show
|
|||
92 | } |
||
93 | |||
94 | 69 | return BlockContinue::at($cursor); |
|
95 | } |
||
96 | |||
97 | 72 | public function addLine(string $line): void |
|
98 | { |
||
99 | 72 | if ($this->nextIsSeparatorLine) { |
|
100 | 72 | $this->nextIsSeparatorLine = false; |
|
101 | } else { |
||
102 | 69 | $this->bodyLines[] = $line; |
|
103 | } |
||
104 | 72 | } |
|
105 | |||
106 | 72 | public function parseInlines(InlineParserEngineInterface $inlineParser): void |
|
107 | { |
||
108 | 72 | $headerColumns = \count($this->headerCells); |
|
109 | |||
110 | 72 | $head = new TableSection(TableSection::TYPE_HEAD); |
|
111 | 72 | $this->block->appendChild($head); |
|
112 | |||
113 | 72 | $headerRow = new TableRow(); |
|
114 | 72 | $head->appendChild($headerRow); |
|
115 | 72 | for ($i = 0; $i < $headerColumns; $i++) { |
|
116 | 72 | $cell = $this->headerCells[$i]; |
|
117 | 72 | $tableCell = $this->parseCell($cell, $i, $inlineParser); |
|
118 | 72 | $tableCell->setType(TableCell::TYPE_HEAD); |
|
119 | 72 | $headerRow->appendChild($tableCell); |
|
120 | } |
||
121 | |||
122 | 72 | $body = null; |
|
123 | 72 | foreach ($this->bodyLines as $rowLine) { |
|
124 | 69 | $cells = self::split($rowLine); |
|
125 | 69 | $row = new TableRow(); |
|
126 | |||
127 | // Body can not have more columns than head |
||
128 | 69 | for ($i = 0; $i < $headerColumns; $i++) { |
|
129 | 69 | $cell = $cells[$i] ?? ''; |
|
130 | 69 | $tableCell = $this->parseCell($cell, $i, $inlineParser); |
|
131 | 69 | $row->appendChild($tableCell); |
|
132 | } |
||
133 | |||
134 | 69 | if ($body === null) { |
|
135 | // It's valid to have a table without body. In that case, don't add an empty TableBody node. |
||
136 | 69 | $body = new TableSection(); |
|
137 | 69 | $this->block->appendChild($body); |
|
138 | } |
||
139 | |||
140 | 69 | $body->appendChild($row); |
|
141 | } |
||
142 | 72 | } |
|
143 | |||
144 | 72 | private function parseCell(string $cell, int $column, InlineParserEngineInterface $inlineParser): TableCell |
|
145 | { |
||
146 | 72 | $tableCell = new TableCell(); |
|
147 | |||
148 | 72 | if ($column < \count($this->columns)) { |
|
149 | 72 | $tableCell->setAlign($this->columns[$column]); |
|
150 | } |
||
151 | |||
152 | 72 | $inlineParser->parse(\trim($cell), $tableCell); |
|
153 | |||
154 | 72 | return $tableCell; |
|
155 | } |
||
156 | |||
157 | /** |
||
158 | * @internal |
||
159 | * |
||
160 | * @return array<int, string> |
||
161 | */ |
||
162 | 75 | public static function split(string $line): array |
|
163 | { |
||
164 | 75 | $cursor = new Cursor(\trim($line)); |
|
165 | |||
166 | 75 | if ($cursor->getCharacter() === '|') { |
|
167 | 54 | $cursor->advanceBy(1); |
|
168 | } |
||
169 | |||
170 | 75 | $cells = []; |
|
171 | 75 | $sb = ''; |
|
172 | |||
173 | 75 | while (! $cursor->isAtEnd()) { |
|
174 | 75 | switch ($c = $cursor->getCharacter()) { |
|
175 | 75 | case '\\': |
|
176 | 12 | if ($cursor->peek() === '|') { |
|
177 | // Pipe is special for table parsing. An escaped pipe doesn't result in a new cell, but is |
||
178 | // passed down to inline parsing as an unescaped pipe. Note that that applies even for the `\|` |
||
179 | // in an input like `\\|` - in other words, table parsing doesn't support escaping backslashes. |
||
180 | 12 | $sb .= '|'; |
|
181 | 12 | $cursor->advanceBy(1); |
|
182 | } else { |
||
183 | // Preserve backslash before other characters or at end of line. |
||
184 | 3 | $sb .= '\\'; |
|
185 | } |
||
186 | |||
187 | 12 | break; |
|
188 | 75 | case '|': |
|
189 | 75 | $cells[] = $sb; |
|
190 | 75 | $sb = ''; |
|
191 | 75 | break; |
|
192 | default: |
||
193 | 75 | $sb .= $c; |
|
194 | } |
||
195 | |||
196 | 75 | $cursor->advanceBy(1); |
|
197 | } |
||
198 | |||
199 | 75 | if ($sb !== '') { |
|
200 | 36 | $cells[] = $sb; |
|
201 | } |
||
202 | |||
203 | 75 | return $cells; |
|
204 | } |
||
205 | } |
||
206 |
This check looks for function or method calls that always return null and whose return value is used.
The method
getObject()
can return nothing but null, so it makes no sense to use the return value.The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes.