MediaWiki  master
BlockLevelPass.php
Go to the documentation of this file.
1 <?php
2 
27  private $DTopen = false;
28  private $inPre = false;
29  private $lastParagraph = '';
30  private $lineStart;
31  private $text;
32 
33  # State constants for the definition list colon extraction
34  private const COLON_STATE_TEXT = 0;
35  private const COLON_STATE_TAG = 1;
36  private const COLON_STATE_TAGSTART = 2;
37  private const COLON_STATE_CLOSETAG = 3;
38  private const COLON_STATE_TAGSLASH = 4;
39  private const COLON_STATE_COMMENT = 5;
40  private const COLON_STATE_COMMENTDASH = 6;
41  private const COLON_STATE_COMMENTDASHDASH = 7;
42  private const COLON_STATE_LC = 8;
43 
52  public static function doBlockLevels( $text, $lineStart ) {
53  $pass = new self( $text, $lineStart );
54  return $pass->execute();
55  }
56 
61  private function __construct( $text, $lineStart ) {
62  $this->text = $text;
63  $this->lineStart = $lineStart;
64  }
65 
69  private function hasOpenParagraph() {
70  return $this->lastParagraph !== '';
71  }
72 
79  private function closeParagraph( $atTheEnd = false ) {
80  $result = '';
81  if ( $this->hasOpenParagraph() ) {
82  $result = '</' . $this->lastParagraph . '>';
83  if ( !$atTheEnd ) {
84  $result .= "\n";
85  }
86  }
87  $this->inPre = false;
88  $this->lastParagraph = '';
89  return $result;
90  }
91 
101  private function getCommon( $st1, $st2 ) {
102  $shorter = min( strlen( $st1 ), strlen( $st2 ) );
103 
104  for ( $i = 0; $i < $shorter; ++$i ) {
105  if ( $st1[$i] !== $st2[$i] ) {
106  break;
107  }
108  }
109  return $i;
110  }
111 
119  private function openList( $char ) {
120  $result = $this->closeParagraph();
121 
122  if ( $char === '*' ) {
123  $result .= "<ul><li>";
124  } elseif ( $char === '#' ) {
125  $result .= "<ol><li>";
126  } elseif ( $char === ':' ) {
127  $result .= "<dl><dd>";
128  } elseif ( $char === ';' ) {
129  $result .= "<dl><dt>";
130  $this->DTopen = true;
131  } else {
132  $result = '<!-- ERR 1 -->';
133  }
134 
135  return $result;
136  }
137 
144  private function nextItem( $char ) {
145  if ( $char === '*' || $char === '#' ) {
146  return "</li>\n<li>";
147  } elseif ( $char === ':' || $char === ';' ) {
148  $close = "</dd>\n";
149  if ( $this->DTopen ) {
150  $close = "</dt>\n";
151  }
152  if ( $char === ';' ) {
153  $this->DTopen = true;
154  return $close . '<dt>';
155  } else {
156  $this->DTopen = false;
157  return $close . '<dd>';
158  }
159  }
160  return '<!-- ERR 2 -->';
161  }
162 
169  private function closeList( $char ) {
170  if ( $char === '*' ) {
171  $text = "</li></ul>";
172  } elseif ( $char === '#' ) {
173  $text = "</li></ol>";
174  } elseif ( $char === ':' ) {
175  if ( $this->DTopen ) {
176  $this->DTopen = false;
177  $text = "</dt></dl>";
178  } else {
179  $text = "</dd></dl>";
180  }
181  } else {
182  return '<!-- ERR 3 -->';
183  }
184  return $text;
185  }
186 
191  private function execute() {
192  $text = $this->text;
193  # Parsing through the text line by line. The main thing
194  # happening here is handling of block-level elements p, pre,
195  # and making lists from lines starting with * # : etc.
196  $textLines = StringUtils::explode( "\n", $text );
197 
198  $lastPrefix = $output = '';
199  $this->DTopen = $inBlockElem = false;
200  $prefixLength = 0;
201  $pendingPTag = false;
202  $inBlockquote = false;
203 
204  for ( $textLines->rewind(); $textLines->valid(); ) {
205  $inputLine = $textLines->current();
206  $textLines->next();
207  $notLastLine = $textLines->valid();
208 
209  # Fix up $lineStart
210  if ( !$this->lineStart ) {
211  $output .= $inputLine;
212  $this->lineStart = true;
213  continue;
214  }
215  # * = ul
216  # # = ol
217  # ; = dt
218  # : = dd
219 
220  $lastPrefixLength = strlen( $lastPrefix );
221  $preCloseMatch = preg_match( '/<\\/pre/i', $inputLine );
222  $preOpenMatch = preg_match( '/<pre/i', $inputLine );
223  # If not in a <pre> element, scan for and figure out what prefixes are there.
224  if ( !$this->inPre ) {
225  # Multiple prefixes may abut each other for nested lists.
226  $prefixLength = strspn( $inputLine, '*#:;' );
227  $prefix = substr( $inputLine, 0, $prefixLength );
228 
229  # eh?
230  # ; and : are both from definition-lists, so they're equivalent
231  # for the purposes of determining whether or not we need to open/close
232  # elements.
233  $prefix2 = str_replace( ';', ':', $prefix );
234  $t = substr( $inputLine, $prefixLength );
235  $this->inPre = (bool)$preOpenMatch;
236  } else {
237  # Don't interpret any other prefixes in preformatted text
238  $prefixLength = 0;
239  $prefix = $prefix2 = '';
240  $t = $inputLine;
241  }
242 
243  # List generation
244  if ( $prefixLength && $lastPrefix === $prefix2 ) {
245  # Same as the last item, so no need to deal with nesting or opening stuff
246  $output .= $this->nextItem( substr( $prefix, -1 ) );
247  $pendingPTag = false;
248 
249  if ( substr( $prefix, -1 ) === ';' ) {
250  # The one nasty exception: definition lists work like this:
251  # ; title : definition text
252  # So we check for : in the remainder text to split up the
253  # title and definition, without b0rking links.
254  $term = $t2 = '';
255  if ( $this->findColonNoLinks( $t, $term, $t2 ) !== false ) {
256  $t = $t2;
257  // Trim whitespace in list items
258  $output .= trim( $term ) . $this->nextItem( ':' );
259  }
260  }
261  } elseif ( $prefixLength || $lastPrefixLength ) {
262  # We need to open or close prefixes, or both.
263 
264  # Either open or close a level...
265  $commonPrefixLength = $this->getCommon( $prefix, $lastPrefix );
266  $pendingPTag = false;
267 
268  # Close all the prefixes which aren't shared.
269  while ( $commonPrefixLength < $lastPrefixLength ) {
270  // @phan-suppress-next-line PhanTypeInvalidDimOffset
271  $output .= $this->closeList( $lastPrefix[$lastPrefixLength - 1] );
272  --$lastPrefixLength;
273  }
274 
275  # Continue the current prefix if appropriate.
276  if ( $prefixLength <= $commonPrefixLength && $commonPrefixLength > 0 ) {
277  $output .= $this->nextItem( $prefix[$commonPrefixLength - 1] );
278  }
279 
280  # Close an open <dt> if we have a <dd> (":") starting on this line
281  if ( $this->DTopen && $commonPrefixLength > 0 && $prefix[$commonPrefixLength - 1] === ':' ) {
282  $output .= $this->nextItem( ':' );
283  }
284 
285  # Open prefixes where appropriate.
286  if ( $lastPrefix && $prefixLength > $commonPrefixLength ) {
287  $output .= "\n";
288  }
289  while ( $prefixLength > $commonPrefixLength ) {
290  $char = $prefix[$commonPrefixLength];
291  $output .= $this->openList( $char );
292 
293  if ( $char === ';' ) {
294  # @todo FIXME: This is dupe of code above
295  if ( $this->findColonNoLinks( $t, $term, $t2 ) !== false ) {
296  $t = $t2;
297  // Trim whitespace in list items
298  $output .= trim( $term ) . $this->nextItem( ':' );
299  }
300  }
301  ++$commonPrefixLength;
302  }
303  if ( !$prefixLength && $lastPrefix ) {
304  $output .= "\n";
305  }
306  $lastPrefix = $prefix2;
307  }
308 
309  # If we have no prefixes, go to paragraph mode.
310  if ( $prefixLength == 0 ) {
311  # No prefix (not in list)--go to paragraph mode
312  # @todo consider using a stack for nestable elements like span, table and div
313 
314  // P-wrapping and indent-pre are suppressed inside, not outside
315  $blockElems = 'table|h1|h2|h3|h4|h5|h6|pre|p|ul|ol|dl';
316  // P-wrapping and indent-pre are suppressed outside, not inside
317  $antiBlockElems = 'td|th';
318 
319  $openMatch = preg_match(
320  '/<('
321  . "({$blockElems})|\\/({$antiBlockElems})|"
322  // Always suppresses
323  . '\\/?(tr|caption|dt|dd|li)'
324  . ')\\b/iS',
325  $t
326  );
327  $closeMatch = preg_match(
328  '/<('
329  . "\\/({$blockElems})|({$antiBlockElems})|"
330  // Never suppresses
331  . '\\/?(center|blockquote|div|hr|mw:|aside|figure)|'
332  // Used as Parser::TOC_PLACEHOLDER
333  . 'meta property="mw:'
334  . ')\\b/iS',
335  $t
336  );
337 
338  // Any match closes the paragraph, but only when `!$closeMatch`
339  // do we enter block mode. The oddities with table rows and
340  // cells are to avoid paragraph wrapping in interstitial spaces
341  // leading to fostered content.
342 
343  if ( $openMatch || $closeMatch ) {
344  $pendingPTag = false;
345  // Only close the paragraph if we're not inside a <pre> tag, or if
346  // that <pre> tag has just been opened
347  if ( !$this->inPre || $preOpenMatch ) {
348  // @todo T7718: paragraph closed
349  $output .= $this->closeParagraph();
350  }
351  if ( $preOpenMatch && !$preCloseMatch ) {
352  $this->inPre = true;
353  }
354  $bqOffset = 0;
355  while ( preg_match( '/<(\\/?)blockquote[\s>]/i', $t,
356  $bqMatch, PREG_OFFSET_CAPTURE, $bqOffset )
357  ) {
358  $inBlockquote = !$bqMatch[1][0]; // is this a close tag?
359  $bqOffset = $bqMatch[0][1] + strlen( $bqMatch[0][0] );
360  }
361  $inBlockElem = !$closeMatch;
362  } elseif ( !$inBlockElem && !$this->inPre ) {
363  if ( substr( $t, 0, 1 ) == ' '
364  && ( $this->lastParagraph === 'pre' || trim( $t ) != '' )
365  && !$inBlockquote
366  ) {
367  # pre
368  if ( $this->lastParagraph !== 'pre' ) {
369  $pendingPTag = false;
370  $output .= $this->closeParagraph() . '<pre>';
371  $this->lastParagraph = 'pre';
372  }
373  $t = substr( $t, 1 );
374  } elseif ( preg_match( '/^(?:<style\\b[^>]*>.*?<\\/style>\s*|<link\\b[^>]*>\s*)+$/iS', $t ) ) {
375  # T186965: <style> or <link> by itself on a line shouldn't open or close paragraphs.
376  # But it should clear $pendingPTag.
377  if ( $pendingPTag ) {
378  $output .= $this->closeParagraph();
379  $pendingPTag = false;
380  }
381  } else {
382  # paragraph
383  if ( trim( $t ) === '' ) {
384  if ( $pendingPTag ) {
385  $output .= $pendingPTag . '<br />';
386  $pendingPTag = false;
387  $this->lastParagraph = 'p';
388  } elseif ( $this->lastParagraph !== 'p' ) {
389  $output .= $this->closeParagraph();
390  $pendingPTag = '<p>';
391  } else {
392  $pendingPTag = '</p><p>';
393  }
394  } elseif ( $pendingPTag ) {
395  $output .= $pendingPTag;
396  $pendingPTag = false;
397  $this->lastParagraph = 'p';
398  } elseif ( $this->lastParagraph !== 'p' ) {
399  $output .= $this->closeParagraph() . '<p>';
400  $this->lastParagraph = 'p';
401  }
402  }
403  }
404  }
405  # somewhere above we forget to get out of pre block (T2785)
406  if ( $preCloseMatch && $this->inPre ) {
407  $this->inPre = false;
408  }
409  if ( $pendingPTag === false ) {
410  if ( $prefixLength === 0 ) {
411  $output .= $t;
412  // Add a newline if there's an open paragraph
413  // or we've yet to reach the last line.
414  if ( $notLastLine || $this->hasOpenParagraph() ) {
415  $output .= "\n";
416  }
417  } else {
418  // Trim whitespace in list items
419  $output .= trim( $t );
420  }
421  }
422  }
423  while ( $prefixLength ) {
424  // @phan-suppress-next-line PhanTypeArraySuspicious $prefix set if $prefixLength is set
425  $output .= $this->closeList( $prefix2[$prefixLength - 1] );
426  --$prefixLength;
427  // Note that a paragraph is only ever opened when `prefixLength`
428  // is zero, but we'll choose to be overly cautious.
429  if ( !$prefixLength && $this->hasOpenParagraph() ) {
430  $output .= "\n";
431  }
432  }
433  $output .= $this->closeParagraph( true );
434  return $output;
435  }
436 
447  private function findColonNoLinks( $str, &$before, &$after ) {
448  if ( !preg_match( '/:|<|-\{/', $str, $m, PREG_OFFSET_CAPTURE ) ) {
449  # Nothing to find!
450  return false;
451  }
452 
453  if ( $m[0][0] === ':' ) {
454  # Easy; no tag nesting to worry about
455  $colonPos = $m[0][1];
456  $before = substr( $str, 0, $colonPos );
457  $after = substr( $str, $colonPos + 1 );
458  return $colonPos;
459  }
460 
461  # Ugly state machine to walk through avoiding tags.
462  $state = self::COLON_STATE_TEXT;
463  $ltLevel = 0;
464  $lcLevel = 0;
465  $len = strlen( $str );
466  for ( $i = $m[0][1]; $i < $len; $i++ ) {
467  $c = $str[$i];
468 
469  switch ( $state ) {
470  case self::COLON_STATE_TEXT:
471  switch ( $c ) {
472  case "<":
473  # Could be either a <start> tag or an </end> tag
474  $state = self::COLON_STATE_TAGSTART;
475  break;
476  case ":":
477  if ( $ltLevel === 0 ) {
478  # We found it!
479  $before = substr( $str, 0, $i );
480  $after = substr( $str, $i + 1 );
481  return $i;
482  }
483  # Embedded in a tag; don't break it.
484  break;
485  default:
486  # Skip ahead looking for something interesting
487  if ( !preg_match( '/:|<|-\{/', $str, $m, PREG_OFFSET_CAPTURE, $i ) ) {
488  # Nothing else interesting
489  return false;
490  }
491  if ( $m[0][0] === '-{' ) {
492  $state = self::COLON_STATE_LC;
493  $lcLevel++;
494  $i = $m[0][1] + 1;
495  } else {
496  # Skip ahead to next interesting character.
497  $i = $m[0][1] - 1;
498  }
499  break;
500  }
501  break;
502  case self::COLON_STATE_LC:
503  # In language converter markup -{ ... }-
504  if ( !preg_match( '/-\{|\}-/', $str, $m, PREG_OFFSET_CAPTURE, $i ) ) {
505  # Nothing else interesting to find; abort!
506  # We're nested in language converter markup, but there
507  # are no close tags left. Abort!
508  break 2;
509  }
510  if ( $m[0][0] === '-{' ) {
511  $i = $m[0][1] + 1;
512  $lcLevel++;
513  } elseif ( $m[0][0] === '}-' ) {
514  $i = $m[0][1] + 1;
515  $lcLevel--;
516  if ( $lcLevel === 0 ) {
517  $state = self::COLON_STATE_TEXT;
518  }
519  }
520  break;
521  case self::COLON_STATE_TAG:
522  # In a <tag>
523  switch ( $c ) {
524  case ">":
525  $ltLevel++;
526  $state = self::COLON_STATE_TEXT;
527  break;
528  case "/":
529  # Slash may be followed by >?
530  $state = self::COLON_STATE_TAGSLASH;
531  break;
532  default:
533  # ignore
534  }
535  break;
536  case self::COLON_STATE_TAGSTART:
537  switch ( $c ) {
538  case "/":
539  $state = self::COLON_STATE_CLOSETAG;
540  break;
541  case "!":
542  $state = self::COLON_STATE_COMMENT;
543  break;
544  case ">":
545  # Illegal early close? This shouldn't happen D:
546  $state = self::COLON_STATE_TEXT;
547  break;
548  default:
549  $state = self::COLON_STATE_TAG;
550  }
551  break;
552  case self::COLON_STATE_CLOSETAG:
553  # In a </tag>
554  if ( $c === ">" ) {
555  if ( $ltLevel > 0 ) {
556  $ltLevel--;
557  } else {
558  # ignore the excess close tag, but keep looking for
559  # colons. (This matches Parsoid behavior.)
560  wfDebug( __METHOD__ . ": Invalid input; too many close tags" );
561  }
562  $state = self::COLON_STATE_TEXT;
563  }
564  break;
565  case self::COLON_STATE_TAGSLASH:
566  if ( $c === ">" ) {
567  # Yes, a self-closed tag <blah/>
568  $state = self::COLON_STATE_TEXT;
569  } else {
570  # Probably we're jumping the gun, and this is an attribute
571  $state = self::COLON_STATE_TAG;
572  }
573  break;
574  case self::COLON_STATE_COMMENT:
575  if ( $c === "-" ) {
576  $state = self::COLON_STATE_COMMENTDASH;
577  }
578  break;
579  case self::COLON_STATE_COMMENTDASH:
580  if ( $c === "-" ) {
581  $state = self::COLON_STATE_COMMENTDASHDASH;
582  } else {
583  $state = self::COLON_STATE_COMMENT;
584  }
585  break;
586  case self::COLON_STATE_COMMENTDASHDASH:
587  if ( $c === ">" ) {
588  $state = self::COLON_STATE_TEXT;
589  } else {
590  $state = self::COLON_STATE_COMMENT;
591  }
592  break;
593  default:
594  throw new MWException( "State machine error in " . __METHOD__ );
595  }
596  }
597  if ( $ltLevel > 0 || $lcLevel > 0 ) {
598  wfDebug(
599  __METHOD__ . ": Invalid input; not enough close tags " .
600  "(level $ltLevel/$lcLevel, state $state)"
601  );
602  return false;
603  }
604  return false;
605  }
606 }
wfDebug( $text, $dest='all', array $context=[])
Sends a line to the debug log if enabled or, optionally, to a comment in output.
static doBlockLevels( $text, $lineStart)
Make lists from lines starting with ':', '*', '#', etc.
MediaWiki exception.
Definition: MWException.php:32
static explode( $separator, $subject)
Workalike for explode() with limited memory usage.