StripState.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Parser;
 
use Closure;
use InvalidArgumentException;
use Wikimedia\Parsoid\Fragments\PFragment;
 
class StripState {
    protected $data;
    protected $extra;
    protected $regex;
 
    protected ?Parser $parser;
 
    protected $circularRefGuard;
    protected $depth = 0;
    protected $highestDepth = 0;
    protected $expandSize = 0;
 
    protected $depthLimit = 20;
    protected $sizeLimit = 5_000_000;
 
    public function __construct( ?Parser $parser = null, $options = [] ) {
        $this->data = [
            'nowiki' => [],
            'general' => []
        ];
        $this->extra = [];
        $this->regex = '/' . Parser::MARKER_PREFIX . "([^\x7f<>&'\"]+)" . Parser::MARKER_SUFFIX . '/';
        $this->circularRefGuard = [];
        $this->parser = $parser;
 
        if ( isset( $options['depthLimit'] ) ) {
            $this->depthLimit = $options['depthLimit'];
        }
        if ( isset( $options['sizeLimit'] ) ) {
            $this->sizeLimit = $options['sizeLimit'];
        }
    }
 
    public function addNoWiki( $marker, $value, ?string $extra = null ) {
        $this->addItem( 'nowiki', $marker, $value, $extra );
    }
 
    public function addGeneral( $marker, $value ) {
        $this->addItem( 'general', $marker, $value );
    }
 
    public function addExtTag( $marker, $value, $frame ) {
        $this->addItem( 'exttag', $marker, $value, $frame );
    }
 
    public function addParsoidOpaque( $marker, PFragment $extra ) {
        $this->addItem( 'parsoid', $marker, '<parsoid opaque>', $extra );
    }
 
    protected function addItem( $type, $marker, $value, $extra = null ) {
        if ( !preg_match( $this->regex, $marker, $m ) ) {
            throw new InvalidArgumentException( "Invalid marker: $marker" );
        }
 
        $this->data[$type][$m[1]] = $value;
        if ( $extra !== null ) {
            $this->extra[$type][$m[1]] = $extra;
        }
    }
 
    public function unstripGeneral( $text ) {
        return $this->unstripType( 'general', $text );
    }
 
    public function unstripNoWiki( $text ) {
        return $this->unstripType( 'nowiki', $text );
    }
 
    public function replaceNoWikis( string $text, callable $callback ): string {
        // Shortcut
        if ( !count( $this->data['nowiki'] ) ) {
            return $text;
        }
 
        $callback = function ( $m ) use ( $callback ) {
            $marker = $m[1];
            if ( isset( $this->data['nowiki'][$marker] ) ) {
                $value = $this->data['nowiki'][$marker];
                if ( $value instanceof Closure ) {
                    $value = $value();
                }
 
                $this->expandSize += strlen( $value );
                if ( $this->expandSize > $this->sizeLimit ) {
                    return $this->getLimitationWarning( 'unstrip-size', $this->sizeLimit );
                }
 
                $extra = $this->extra['nowiki'][$marker] ?? null;
                return $callback( $value, $extra );
            } else {
                return $m[0];
            }
        };
 
        return preg_replace_callback( $this->regex, $callback, $text );
    }
 
    public function split( string $text, bool $keepExtTag = false ): array {
        $result = [];
        $pieces = preg_split( $this->regex, $text, -1, PREG_SPLIT_DELIM_CAPTURE );
        for ( $i = 0; $i < count( $pieces ); $i++ ) {
            if ( $i % 2 === 0 ) {
                $result[] = [
                    'type' => 'string',
                    'content' => $pieces[$i],
                ];
                continue;
            }
            $marker = $pieces[$i];
            foreach ( $this->data as $type => $items ) {
                if ( isset( $items[$marker] ) ) {
                    $value = $items[$marker];
                    $extra = $this->extra[$type][$marker] ?? null;
                    if ( $value instanceof Closure ) {
                        $value = $value();
                    }
 
                    if ( $type === 'exttag' ) {
                        // Catch circular refs / enforce depth limits
                        // similar to code in unstripType().
                        if ( isset( $this->circularRefGuard[$marker] ) ) {
                            $result[] = [
                                'type' => 'string',
                                'content' => $this->getWarning( 'parser-unstrip-loop-warning' )
                            ];
                            continue;
                        }
 
                        if ( $this->depth > $this->highestDepth ) {
                            $this->highestDepth = $this->depth;
                        }
                        if ( $this->depth >= $this->depthLimit ) {
                            $result[] = [
                                'type' => 'string',
                                'content' => $this->getLimitationWarning( 'unstrip-depth', $this->depthLimit )
                            ];
                            continue;
                        }
 
                        // For exttag types, the output size should include the output of
                        // the extension, but don't think unstripType is doing that, and so
                        // we aren't doing that either here. But this is kinda broken.
                        // See T380758#10355050.
                        $this->expandSize += strlen( $value );
                        if ( $this->expandSize > $this->sizeLimit ) {
                            $result[] = [
                                'type' => 'string',
                                'content' => $this->getLimitationWarning( 'unstrip-size', $this->sizeLimit )
                            ];
                            continue;
                        }
 
                        $this->circularRefGuard[$marker] = true;
                        $this->depth++;
                        if ( $keepExtTag ) {
                            $result[] = [
                                'type' => 'exttag',
                                'content' => $value,
                                'extra' => $extra,
                                'marker' => Parser::MARKER_PREFIX . $marker . Parser::MARKER_SUFFIX,
                            ];
                        } else {
                            $result = array_merge( $result, $this->split( $value ) );
                        }
                        $this->depth--;
                        unset( $this->circularRefGuard[$marker] );
                    } else {
                        $result[] = [
                            'type' => $type,
                            'content' => $value,
                            'extra' => $extra,
                            'marker' => Parser::MARKER_PREFIX . $marker . Parser::MARKER_SUFFIX,
                        ];
                    }
                    continue 2;
                }
            }
            $result[] = [
                'type' => 'unknown',
                'content' => null,
                'marker' => Parser::MARKER_PREFIX . $marker . Parser::MARKER_SUFFIX,
            ];
        }
        return $result;
    }
 
    public function unstripBoth( $text ) {
        $text = $this->unstripType( 'general', $text );
        $text = $this->unstripType( 'nowiki', $text );
        return $text;
    }
 
    protected function unstripType( $type, $text ) {
        // Shortcut
        if ( !count( $this->data[$type] ) ) {
            return $text;
        }
 
        $callback = function ( $m ) use ( $type ) {
            $marker = $m[1];
            if ( isset( $this->data[$type][$marker] ) ) {
                if ( isset( $this->circularRefGuard[$marker] ) ) {
                    return $this->getWarning( 'parser-unstrip-loop-warning' );
                }
 
                if ( $this->depth > $this->highestDepth ) {
                    $this->highestDepth = $this->depth;
                }
                if ( $this->depth >= $this->depthLimit ) {
                    return $this->getLimitationWarning( 'unstrip-depth', $this->depthLimit );
                }
 
                $value = $this->data[$type][$marker];
                if ( $value instanceof Closure ) {
                    $value = $value();
                }
 
                $this->expandSize += strlen( $value );
                if ( $this->expandSize > $this->sizeLimit ) {
                    return $this->getLimitationWarning( 'unstrip-size', $this->sizeLimit );
                }
 
                $this->circularRefGuard[$marker] = true;
                $this->depth++;
                $ret = $this->unstripType( $type, $value );
                $this->depth--;
                unset( $this->circularRefGuard[$marker] );
 
                return $ret;
            } else {
                return $m[0];
            }
        };
 
        $text = preg_replace_callback( $this->regex, $callback, $text );
        return $text;
    }
 
    private function getLimitationWarning( $type, $max = '' ) {
        if ( $this->parser ) {
            $this->parser->limitationWarn( $type, $max );
        }
        return $this->getWarning( "$type-warning", $max );
    }
 
    private function getWarning( $message, $max = '' ) {
        return '<span class="error">' .
            wfMessage( $message )
                ->numParams( $max )->inContentLanguage()->text() .
            '</span>';
    }
 
    public function getLimitReport() {
        return [
            [ 'limitreport-unstrip-depth',
                [
                    $this->highestDepth,
                    $this->depthLimit
                ],
            ],
            [ 'limitreport-unstrip-size',
                [
                    $this->expandSize,
                    $this->sizeLimit
                ],
            ]
        ];
    }
 
    public function killMarkers( $text ) {
        return preg_replace( $this->regex, '', $text );
    }
}
 
class_alias( StripState::class, 'StripState' );