TextContent.php

Go to the documentation of this file.

<?php
use MediaWiki\MediaWikiServices;

class TextContent extends AbstractContent {

    protected $mText;

    public function __construct( $text, $model_id = CONTENT_MODEL_TEXT ) {
        parent::__construct( $model_id );

        if ( $text === null || $text === false ) {
            wfWarn( "TextContent constructed with \$text = " . var_export( $text, true ) . "! "
                . "This may indicate an error in the caller's scope.", 2 );

            $text = '';
        }

        if ( !is_string( $text ) ) {
            throw new MWException( "TextContent expects a string in the constructor." );
        }

        $this->mText = $text;
    }

    public function copy() {
        return $this; # NOTE: this is ok since TextContent are immutable.
    }

    public function getTextForSummary( $maxlength = 250 ) {
        $text = $this->getText();

        $truncatedtext = MediaWikiServices::getInstance()->getContentLanguage()->
            truncateForDatabase( preg_replace( "/[\n\r]/", ' ', $text ), max( 0, $maxlength ) );

        return $truncatedtext;
    }

    public function getSize() {
        $text = $this->getText();

        return strlen( $text );
    }

    public function isCountable( $hasLinks = null ) {
        global $wgArticleCountMethod;

        if ( $this->isRedirect() ) {
            return false;
        }

        if ( $wgArticleCountMethod === 'any' ) {
            return true;
        }

        return false;
    }

    public function getNativeData() {
        return $this->getText();
    }

    public function getText() {
        return $this->mText;
    }

    public function getTextForSearchIndex() {
        return $this->getText();
    }

    public function getWikitextForTransclusion() {
        $wikitext = $this->convert( CONTENT_MODEL_WIKITEXT, 'lossy' );

        if ( $wikitext ) {
            return $wikitext->getText();
        } else {
            return false;
        }
    }

    public static function normalizeLineEndings( $text ) {
        return str_replace( [ "\r\n", "\r" ], "\n", rtrim( $text ) );
    }

    public function preSaveTransform( Title $title, User $user, ParserOptions $popts ) {
        $text = $this->getText();
        $pst = self::normalizeLineEndings( $text );

        return ( $text === $pst ) ? $this : new static( $pst, $this->getModel() );
    }

    public function diff( Content $that, Language $lang = null ) {
        $this->checkModelID( $that->getModel() );

        // @todo could implement this in DifferenceEngine and just delegate here?

        if ( !$lang ) {
            $lang = MediaWikiServices::getInstance()->getContentLanguage();
        }

        $otext = $this->getText();
        $ntext = $that->getText();

        # Note: Use native PHP diff, external engines don't give us abstract output
        $ota = explode( "\n", $lang->segmentForDiff( $otext ) );
        $nta = explode( "\n", $lang->segmentForDiff( $ntext ) );

        $diff = new Diff( $ota, $nta );

        return $diff;
    }

    protected function fillParserOutput( Title $title, $revId,
        ParserOptions $options, $generateHtml, ParserOutput &$output
    ) {
        global $wgTextModelsToParse;

        if ( in_array( $this->getModel(), $wgTextModelsToParse ) ) {
            // parse just to get links etc into the database, HTML is replaced below.
            $output = MediaWikiServices::getInstance()->getParser()
                ->parse( $this->getText(), $title, $options, true, true, $revId );
        }

        if ( $generateHtml ) {
            $html = $this->getHtml();
        } else {
            $html = '';
        }

        $output->clearWrapperDivClass();
        $output->setText( $html );
    }

    protected function getHtml() {
        return $this->getHighlightHtml();
    }

    protected function getHighlightHtml() {
        return htmlspecialchars( $this->getText() );
    }

    public function convert( $toModel, $lossy = '' ) {
        $converted = parent::convert( $toModel, $lossy );

        if ( $converted !== false ) {
            return $converted;
        }

        $toHandler = ContentHandler::getForModelID( $toModel );

        if ( $toHandler instanceof TextContentHandler ) {
            // NOTE: ignore content serialization format - it's just text anyway.
            $text = $this->getText();
            $converted = $toHandler->unserializeContent( $text );
        }

        return $converted;
    }

}