StripState.php

Go to the documentation of this file.

<?php
class StripState {
    protected $data;
    protected $regex;
 
    protected $parser;
 
    protected $circularRefGuard;
    protected $depth = 0;
    protected $highestDepth = 0;
    protected $expandSize = 0;
 
    protected $depthLimit = 20;
    protected $sizeLimit = 5000000;
 
    public function __construct( Parser $parser = null, $options = [] ) {
        $this->data = [
            'nowiki' => [],
            'general' => []
        ];
        $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 ) {
        $this->addItem( 'nowiki', $marker, $value );
    }
 
    public function addGeneral( $marker, $value ) {
        $this->addItem( 'general', $marker, $value );
    }
 
    protected function addItem( $type, $marker, $value ) {
        if ( !preg_match( $this->regex, $marker, $m ) ) {
            throw new MWException( "Invalid marker: $marker" );
        }
 
        $this->data[$type][$m[1]] = $value;
    }
 
    public function unstripGeneral( $text ) {
        return $this->unstripType( 'general', $text );
    }
 
    public function unstripNoWiki( $text ) {
        return $this->unstripType( 'nowiki', $text );
    }
 
    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 getSubState( $text ) {
        wfDeprecated( __METHOD__, '1.31' );
 
        $subState = new StripState;
        $pos = 0;
        while ( true ) {
            $startPos = strpos( $text, Parser::MARKER_PREFIX, $pos );
            $endPos = strpos( $text, Parser::MARKER_SUFFIX, $pos );
            if ( $startPos === false || $endPos === false ) {
                break;
            }
 
            $endPos += strlen( Parser::MARKER_SUFFIX );
            $marker = substr( $text, $startPos, $endPos - $startPos );
            if ( !preg_match( $this->regex, $marker, $m ) ) {
                continue;
            }
 
            $key = $m[1];
            if ( isset( $this->data['nowiki'][$key] ) ) {
                $subState->data['nowiki'][$key] = $this->data['nowiki'][$key];
            } elseif ( isset( $this->data['general'][$key] ) ) {
                $subState->data['general'][$key] = $this->data['general'][$key];
            }
            $pos = $endPos;
        }
        return $subState;
    }
 
    public function merge( $otherState, $texts ) {
        wfDeprecated( __METHOD__, '1.31' );
 
        $mergePrefix = wfRandomString( 16 );
 
        foreach ( $otherState->data as $type => $items ) {
            foreach ( $items as $key => $value ) {
                $this->data[$type]["$mergePrefix-$key"] = $value;
            }
        }
 
        $callback = function ( $m ) use ( $mergePrefix ) {
            $key = $m[1];
            return Parser::MARKER_PREFIX . $mergePrefix . '-' . $key . Parser::MARKER_SUFFIX;
        };
        $texts = preg_replace_callback( $otherState->regex, $callback, $texts );
        return $texts;
    }
 
    public function killMarkers( $text ) {
        return preg_replace( $this->regex, '', $text );
    }
}