MediaWiki REL1_30
BlockLevelPass.php
Go to the documentation of this file.
1<?php
2
26 private $DTopen = false;
27 private $inPre = false;
28 private $lastSection = '';
29 private $linestart;
30 private $text;
31
32 # State constants for the definition list colon extraction
34 const COLON_STATE_TAG = 1;
41 const COLON_STATE_LC = 8;
42
50 public static function doBlockLevels( $text, $lineStart ) {
51 $pass = new self( $text, $lineStart );
52 return $pass->execute();
53 }
54
58 private function __construct( $text, $lineStart ) {
59 $this->text = $text;
60 $this->lineStart = $lineStart;
61 }
62
68 private function closeParagraph() {
69 $result = '';
70 if ( $this->lastSection !== '' ) {
71 $result = '</' . $this->lastSection . ">\n";
72 }
73 $this->inPre = false;
74 $this->lastSection = '';
75 return $result;
76 }
77
87 private function getCommon( $st1, $st2 ) {
88 $shorter = min( strlen( $st1 ), strlen( $st2 ) );
89
90 for ( $i = 0; $i < $shorter; ++$i ) {
91 if ( $st1[$i] !== $st2[$i] ) {
92 break;
93 }
94 }
95 return $i;
96 }
97
105 private function openList( $char ) {
106 $result = $this->closeParagraph();
107
108 if ( '*' === $char ) {
109 $result .= "<ul><li>";
110 } elseif ( '#' === $char ) {
111 $result .= "<ol><li>";
112 } elseif ( ':' === $char ) {
113 $result .= "<dl><dd>";
114 } elseif ( ';' === $char ) {
115 $result .= "<dl><dt>";
116 $this->DTopen = true;
117 } else {
118 $result = '<!-- ERR 1 -->';
119 }
120
121 return $result;
122 }
123
130 private function nextItem( $char ) {
131 if ( '*' === $char || '#' === $char ) {
132 return "</li>\n<li>";
133 } elseif ( ':' === $char || ';' === $char ) {
134 $close = "</dd>\n";
135 if ( $this->DTopen ) {
136 $close = "</dt>\n";
137 }
138 if ( ';' === $char ) {
139 $this->DTopen = true;
140 return $close . '<dt>';
141 } else {
142 $this->DTopen = false;
143 return $close . '<dd>';
144 }
145 }
146 return '<!-- ERR 2 -->';
147 }
148
155 private function closeList( $char ) {
156 if ( '*' === $char ) {
157 $text = "</li></ul>";
158 } elseif ( '#' === $char ) {
159 $text = "</li></ol>";
160 } elseif ( ':' === $char ) {
161 if ( $this->DTopen ) {
162 $this->DTopen = false;
163 $text = "</dt></dl>";
164 } else {
165 $text = "</dd></dl>";
166 }
167 } else {
168 return '<!-- ERR 3 -->';
169 }
170 return $text;
171 }
172
177 private function execute() {
179 # Parsing through the text line by line. The main thing
180 # happening here is handling of block-level elements p, pre,
181 # and making lists from lines starting with * # : etc.
182 $textLines = StringUtils::explode( "\n", $text );
183
184 $lastPrefix = $output = '';
185 $this->DTopen = $inBlockElem = false;
186 $prefixLength = 0;
187 $pendingPTag = false;
188 $inBlockquote = false;
189
190 foreach ( $textLines as $inputLine ) {
191 # Fix up $lineStart
192 if ( !$this->lineStart ) {
193 $output .= $inputLine;
194 $this->lineStart = true;
195 continue;
196 }
197 # * = ul
198 # # = ol
199 # ; = dt
200 # : = dd
201
202 $lastPrefixLength = strlen( $lastPrefix );
203 $preCloseMatch = preg_match( '/<\\/pre/i', $inputLine );
204 $preOpenMatch = preg_match( '/<pre/i', $inputLine );
205 # If not in a <pre> element, scan for and figure out what prefixes are there.
206 if ( !$this->inPre ) {
207 # Multiple prefixes may abut each other for nested lists.
208 $prefixLength = strspn( $inputLine, '*#:;' );
209 $prefix = substr( $inputLine, 0, $prefixLength );
210
211 # eh?
212 # ; and : are both from definition-lists, so they're equivalent
213 # for the purposes of determining whether or not we need to open/close
214 # elements.
215 $prefix2 = str_replace( ';', ':', $prefix );
216 $t = substr( $inputLine, $prefixLength );
217 $this->inPre = (bool)$preOpenMatch;
218 } else {
219 # Don't interpret any other prefixes in preformatted text
220 $prefixLength = 0;
221 $prefix = $prefix2 = '';
222 $t = $inputLine;
223 }
224
225 # List generation
226 if ( $prefixLength && $lastPrefix === $prefix2 ) {
227 # Same as the last item, so no need to deal with nesting or opening stuff
228 $output .= $this->nextItem( substr( $prefix, -1 ) );
229 $pendingPTag = false;
230
231 if ( substr( $prefix, -1 ) === ';' ) {
232 # The one nasty exception: definition lists work like this:
233 # ; title : definition text
234 # So we check for : in the remainder text to split up the
235 # title and definition, without b0rking links.
236 $term = $t2 = '';
237 if ( $this->findColonNoLinks( $t, $term, $t2 ) !== false ) {
238 $t = $t2;
239 $output .= $term . $this->nextItem( ':' );
240 }
241 }
242 } elseif ( $prefixLength || $lastPrefixLength ) {
243 # We need to open or close prefixes, or both.
244
245 # Either open or close a level...
246 $commonPrefixLength = $this->getCommon( $prefix, $lastPrefix );
247 $pendingPTag = false;
248
249 # Close all the prefixes which aren't shared.
250 while ( $commonPrefixLength < $lastPrefixLength ) {
251 $output .= $this->closeList( $lastPrefix[$lastPrefixLength - 1] );
252 --$lastPrefixLength;
253 }
254
255 # Continue the current prefix if appropriate.
256 if ( $prefixLength <= $commonPrefixLength && $commonPrefixLength > 0 ) {
257 $output .= $this->nextItem( $prefix[$commonPrefixLength - 1] );
258 }
259
260 # Close an open <dt> if we have a <dd> (":") starting on this line
261 if ( $this->DTopen && $commonPrefixLength > 0 && $prefix[$commonPrefixLength - 1] === ':' ) {
262 $output .= $this->nextItem( ':' );
263 }
264
265 # Open prefixes where appropriate.
266 if ( $lastPrefix && $prefixLength > $commonPrefixLength ) {
267 $output .= "\n";
268 }
269 while ( $prefixLength > $commonPrefixLength ) {
270 $char = $prefix[$commonPrefixLength];
271 $output .= $this->openList( $char );
272
273 if ( ';' === $char ) {
274 # @todo FIXME: This is dupe of code above
275 if ( $this->findColonNoLinks( $t, $term, $t2 ) !== false ) {
276 $t = $t2;
277 $output .= $term . $this->nextItem( ':' );
278 }
279 }
280 ++$commonPrefixLength;
281 }
282 if ( !$prefixLength && $lastPrefix ) {
283 $output .= "\n";
284 }
285 $lastPrefix = $prefix2;
286 }
287
288 # If we have no prefixes, go to paragraph mode.
289 if ( 0 == $prefixLength ) {
290 # No prefix (not in list)--go to paragraph mode
291 # @todo consider using a stack for nestable elements like span, table and div
292 $openMatch = preg_match(
293 '/(?:<table|<h1|<h2|<h3|<h4|<h5|<h6|<pre|<tr|'
294 . '<p|<ul|<ol|<dl|<li|<\\/tr|<\\/td|<\\/th)\\b/iS',
295 $t
296 );
297 $closeMatch = preg_match(
298 '/(?:<\\/table|<\\/h1|<\\/h2|<\\/h3|<\\/h4|<\\/h5|<\\/h6|'
299 . '<td|<th|<\\/?blockquote|<\\/?div|<hr|<\\/pre|<\\/p|<\\/mw:|'
300 . Parser::MARKER_PREFIX
301 . '-pre|<\\/li|<\\/ul|<\\/ol|<\\/dl|<\\/?center)\\b/iS',
302 $t
303 );
304
305 if ( $openMatch || $closeMatch ) {
306 $pendingPTag = false;
307 # @todo T7718: paragraph closed
308 $output .= $this->closeParagraph();
309 if ( $preOpenMatch && !$preCloseMatch ) {
310 $this->inPre = true;
311 }
312 $bqOffset = 0;
313 while ( preg_match( '/<(\\/?)blockquote[\s>]/i', $t,
314 $bqMatch, PREG_OFFSET_CAPTURE, $bqOffset )
315 ) {
316 $inBlockquote = !$bqMatch[1][0]; // is this a close tag?
317 $bqOffset = $bqMatch[0][1] + strlen( $bqMatch[0][0] );
318 }
319 $inBlockElem = !$closeMatch;
320 } elseif ( !$inBlockElem && !$this->inPre ) {
321 if ( ' ' == substr( $t, 0, 1 )
322 && ( $this->lastSection === 'pre' || trim( $t ) != '' )
323 && !$inBlockquote
324 ) {
325 # pre
326 if ( $this->lastSection !== 'pre' ) {
327 $pendingPTag = false;
328 $output .= $this->closeParagraph() . '<pre>';
329 $this->lastSection = 'pre';
330 }
331 $t = substr( $t, 1 );
332 } else {
333 # paragraph
334 if ( trim( $t ) === '' ) {
335 if ( $pendingPTag ) {
336 $output .= $pendingPTag . '<br />';
337 $pendingPTag = false;
338 $this->lastSection = 'p';
339 } else {
340 if ( $this->lastSection !== 'p' ) {
341 $output .= $this->closeParagraph();
342 $this->lastSection = '';
343 $pendingPTag = '<p>';
344 } else {
345 $pendingPTag = '</p><p>';
346 }
347 }
348 } else {
349 if ( $pendingPTag ) {
350 $output .= $pendingPTag;
351 $pendingPTag = false;
352 $this->lastSection = 'p';
353 } elseif ( $this->lastSection !== 'p' ) {
354 $output .= $this->closeParagraph() . '<p>';
355 $this->lastSection = 'p';
356 }
357 }
358 }
359 }
360 }
361 # somewhere above we forget to get out of pre block (T2785)
362 if ( $preCloseMatch && $this->inPre ) {
363 $this->inPre = false;
364 }
365 if ( $pendingPTag === false ) {
366 $output .= $t;
367 if ( $prefixLength === 0 ) {
368 $output .= "\n";
369 }
370 }
371 }
372 while ( $prefixLength ) {
373 $output .= $this->closeList( $prefix2[$prefixLength - 1] );
374 --$prefixLength;
375 if ( !$prefixLength ) {
376 $output .= "\n";
377 }
378 }
379 if ( $this->lastSection !== '' ) {
380 $output .= '</' . $this->lastSection . '>';
381 $this->lastSection = '';
382 }
383
384 return $output;
385 }
386
397 private function findColonNoLinks( $str, &$before, &$after ) {
398 if ( !preg_match( '/:|<|-\{/', $str, $m, PREG_OFFSET_CAPTURE ) ) {
399 # Nothing to find!
400 return false;
401 }
402
403 if ( $m[0][0] === ':' ) {
404 # Easy; no tag nesting to worry about
405 $colonPos = $m[0][1];
406 $before = substr( $str, 0, $colonPos );
407 $after = substr( $str, $colonPos + 1 );
408 return $colonPos;
409 }
410
411 # Ugly state machine to walk through avoiding tags.
412 $state = self::COLON_STATE_TEXT;
413 $ltLevel = 0;
414 $lcLevel = 0;
415 $len = strlen( $str );
416 for ( $i = $m[0][1]; $i < $len; $i++ ) {
417 $c = $str[$i];
418
419 switch ( $state ) {
421 switch ( $c ) {
422 case "<":
423 # Could be either a <start> tag or an </end> tag
425 break;
426 case ":":
427 if ( $ltLevel === 0 ) {
428 # We found it!
429 $before = substr( $str, 0, $i );
430 $after = substr( $str, $i + 1 );
431 return $i;
432 }
433 # Embedded in a tag; don't break it.
434 break;
435 default:
436 # Skip ahead looking for something interesting
437 if ( !preg_match( '/:|<|-\{/', $str, $m, PREG_OFFSET_CAPTURE, $i ) ) {
438 # Nothing else interesting
439 return false;
440 }
441 if ( $m[0][0] === '-{' ) {
442 $state = self::COLON_STATE_LC;
443 $lcLevel++;
444 $i = $m[0][1] + 1;
445 } else {
446 # Skip ahead to next interesting character.
447 $i = $m[0][1] - 1;
448 }
449 break;
450 }
451 break;
453 # In language converter markup -{ ... }-
454 if ( !preg_match( '/-\{|\}-/', $str, $m, PREG_OFFSET_CAPTURE, $i ) ) {
455 # Nothing else interesting to find; abort!
456 # We're nested in language converter markup, but there
457 # are no close tags left. Abort!
458 break 2;
459 } elseif ( $m[0][0] === '-{' ) {
460 $i = $m[0][1] + 1;
461 $lcLevel++;
462 } elseif ( $m[0][0] === '}-' ) {
463 $i = $m[0][1] + 1;
464 $lcLevel--;
465 if ( $lcLevel === 0 ) {
466 $state = self::COLON_STATE_TEXT;
467 }
468 }
469 break;
471 # In a <tag>
472 switch ( $c ) {
473 case ">":
474 $ltLevel++;
475 $state = self::COLON_STATE_TEXT;
476 break;
477 case "/":
478 # Slash may be followed by >?
480 break;
481 default:
482 # ignore
483 }
484 break;
486 switch ( $c ) {
487 case "/":
489 break;
490 case "!":
492 break;
493 case ">":
494 # Illegal early close? This shouldn't happen D:
495 $state = self::COLON_STATE_TEXT;
496 break;
497 default:
498 $state = self::COLON_STATE_TAG;
499 }
500 break;
502 # In a </tag>
503 if ( $c === ">" ) {
504 if ( $ltLevel > 0 ) {
505 $ltLevel--;
506 } else {
507 # ignore the excess close tag, but keep looking for
508 # colons. (This matches Parsoid behavior.)
509 wfDebug( __METHOD__ . ": Invalid input; too many close tags\n" );
510 }
511 $state = self::COLON_STATE_TEXT;
512 }
513 break;
515 if ( $c === ">" ) {
516 # Yes, a self-closed tag <blah/>
517 $state = self::COLON_STATE_TEXT;
518 } else {
519 # Probably we're jumping the gun, and this is an attribute
520 $state = self::COLON_STATE_TAG;
521 }
522 break;
524 if ( $c === "-" ) {
526 }
527 break;
529 if ( $c === "-" ) {
531 } else {
533 }
534 break;
536 if ( $c === ">" ) {
537 $state = self::COLON_STATE_TEXT;
538 } else {
540 }
541 break;
542 default:
543 throw new MWException( "State machine error in " . __METHOD__ );
544 }
545 }
546 if ( $ltLevel > 0 || $lcLevel > 0 ) {
547 wfDebug(
548 __METHOD__ . ": Invalid input; not enough close tags " .
549 "(level $ltLevel/$lcLevel, state $state)\n"
550 );
551 return false;
552 }
553 return false;
554 }
555}
wfDebug( $text, $dest='all', array $context=[])
Sends a line to the debug log if enabled or, optionally, to a comment in output.
openList( $char)
Open the list item element identified by the prefix character.
const COLON_STATE_COMMENTDASHDASH
__construct( $text, $lineStart)
Private constructor.
nextItem( $char)
Close the current list item and open the next one.
execute()
Execute the pass.
getCommon( $st1, $st2)
getCommon() returns the length of the longest common substring of both arguments, starting at the beg...
static doBlockLevels( $text, $lineStart)
Make lists from lines starting with ':', '*', '#', etc.
findColonNoLinks( $str, &$before, &$after)
Split up a string on ':', ignoring any occurrences inside tags to prevent illegal overlapping.
const COLON_STATE_COMMENTDASH
closeParagraph()
If a pre or p is open, return the corresponding close tag and update the state.
closeList( $char)
Close the current list item identified by the prefix character.
MediaWiki exception.
static explode( $separator, $subject)
Workalike for explode() with limited memory usage.
external whereas SearchGetNearMatch runs after $term
Definition hooks.txt:2814
namespace being checked & $result
Definition hooks.txt:2293
static configuration should be added through ResourceLoaderGetConfigVars instead can be used to get the real title after the basic globals have been set but before ordinary actions take place $output
Definition hooks.txt:2225