AbstractContent.php

Go to the documentation of this file.

<?php
abstract class AbstractContent implements Content {
    protected $model_id;
 
    public function __construct( $modelId = null ) {
        $this->model_id = $modelId;
    }
 
    public function getModel() {
        return $this->model_id;
    }
 
    protected function checkModelID( $modelId ) {
        if ( $modelId !== $this->model_id ) {
            throw new MWException(
                "Bad content model: " .
                "expected {$this->model_id} " .
                "but got $modelId."
            );
        }
    }
 
    public function getContentHandler() {
        return ContentHandler::getForContent( $this );
    }
 
    public function getDefaultFormat() {
        return $this->getContentHandler()->getDefaultFormat();
    }
 
    public function getSupportedFormats() {
        return $this->getContentHandler()->getSupportedFormats();
    }
 
    public function isSupportedFormat( $format ) {
        if ( !$format ) {
            return true; // this means "use the default"
        }
 
        return $this->getContentHandler()->isSupportedFormat( $format );
    }
 
    protected function checkFormat( $format ) {
        if ( !$this->isSupportedFormat( $format ) ) {
            throw new MWException(
                "Format $format is not supported for content model " .
                $this->getModel()
            );
        }
    }
 
    public function serialize( $format = null ) {
        return $this->getContentHandler()->serializeContent( $this, $format );
    }
 
    public function isEmpty() {
        return $this->getSize() === 0;
    }
 
    public function isValid() {
        return true;
    }
 
    public function equals( Content $that = null ) {
        if ( is_null( $that ) ) {
            return false;
        }
 
        if ( $that === $this ) {
            return true;
        }
 
        if ( $that->getModel() !== $this->getModel() ) {
            return false;
        }
 
        return $this->getNativeData() === $that->getNativeData();
    }
 
    public function getSecondaryDataUpdates( Title $title, Content $old = null,
        $recursive = true, ParserOutput $parserOutput = null
    ) {
        if ( $parserOutput === null ) {
            $parserOutput = $this->getParserOutput( $title, null, null, false );
        }
 
        $updates = [
            new LinksUpdate( $title, $parserOutput, $recursive )
        ];
 
        Hooks::run( 'SecondaryDataUpdates', [ $title, $old, $recursive, $parserOutput, &$updates ] );
 
        return $updates;
    }
 
    public function getRedirectChain() {
        global $wgMaxRedirects;
        $title = $this->getRedirectTarget();
        if ( is_null( $title ) ) {
            return null;
        }
        // recursive check to follow double redirects
        $recurse = $wgMaxRedirects;
        $titles = [ $title ];
        while ( --$recurse > 0 ) {
            if ( $title->isRedirect() ) {
                $page = WikiPage::factory( $title );
                $newtitle = $page->getRedirectTarget();
            } else {
                break;
            }
            // Redirects to some special pages are not permitted
            if ( $newtitle instanceof Title && $newtitle->isValidRedirectTarget() ) {
                // The new title passes the checks, so make that our current
                // title so that further recursion can be checked
                $title = $newtitle;
                $titles[] = $newtitle;
            } else {
                break;
            }
        }
 
        return $titles;
    }
 
    public function getRedirectTarget() {
        return null;
    }
 
    public function getUltimateRedirectTarget() {
        $titles = $this->getRedirectChain();
 
        return $titles ? array_pop( $titles ) : null;
    }
 
    public function isRedirect() {
        return $this->getRedirectTarget() !== null;
    }
 
    public function updateRedirect( Title $target ) {
        return $this;
    }
 
    public function getSection( $sectionId ) {
        return null;
    }
 
    public function replaceSection( $sectionId, Content $with, $sectionTitle = '' ) {
        return null;
    }
 
    public function preSaveTransform( Title $title, User $user, ParserOptions $popts ) {
        return $this;
    }
 
    public function addSectionHeader( $header ) {
        return $this;
    }
 
    public function preloadTransform( Title $title, ParserOptions $popts, $params = [] ) {
        return $this;
    }
 
    public function prepareSave( WikiPage $page, $flags, $parentRevId, User $user ) {
        if ( $this->isValid() ) {
            return Status::newGood();
        } else {
            return Status::newFatal( "invalid-content-data" );
        }
    }
 
    public function getDeletionUpdates( WikiPage $page, ParserOutput $parserOutput = null ) {
        return [
            new LinksDeletionUpdate( $page ),
        ];
    }
 
    public function matchMagicWord( MagicWord $word ) {
        return false;
    }
 
    public function convert( $toModel, $lossy = '' ) {
        if ( $this->getModel() === $toModel ) {
            // nothing to do, shorten out.
            return $this;
        }
 
        $lossy = ( $lossy === 'lossy' ); // string flag, convert to boolean for convenience
        $result = false;
 
        Hooks::run( 'ConvertContent', [ $this, $toModel, $lossy, &$result ] );
 
        return $result;
    }
 
    public function getParserOutput( Title $title, $revId = null,
        ParserOptions $options = null, $generateHtml = true
    ) {
        if ( $options === null ) {
            $options = ParserOptions::newCanonical( 'canonical' );
        }
 
        $po = new ParserOutput();
        $options->registerWatcher( [ $po, 'recordOption' ] );
 
        if ( Hooks::run( 'ContentGetParserOutput',
            [ $this, $title, $revId, $options, $generateHtml, &$po ] )
        ) {
            // Save and restore the old value, just in case something is reusing
            // the ParserOptions object in some weird way.
            $oldRedir = $options->getRedirectTarget();
            $options->setRedirectTarget( $this->getRedirectTarget() );
            $this->fillParserOutput( $title, $revId, $options, $generateHtml, $po );
            $options->setRedirectTarget( $oldRedir );
        }
 
        Hooks::run( 'ContentAlterParserOutput', [ $this, $title, $po ] );
        $options->registerWatcher( null );
 
        return $po;
    }
 
    protected function fillParserOutput( Title $title, $revId,
        ParserOptions $options, $generateHtml, ParserOutput &$output
    ) {
        // Don't make abstract, so subclasses that override getParserOutput() directly don't fail.
        throw new MWException( 'Subclasses of AbstractContent must override fillParserOutput!' );
    }
}