RevisionRenderer.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Revision;
 
use InvalidArgumentException;
use MediaWiki\Content\Renderer\ContentRenderer;
use MediaWiki\Html\Html;
use MediaWiki\Parser\ParserOptions;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Parser\ParserOutputFlags;
use MediaWiki\Permissions\Authority;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use Wikimedia\Rdbms\ILoadBalancer;
 
class RevisionRenderer implements LoggerAwareInterface {
 
    private $saveParseLogger;
 
    private $loadBalancer;
 
    private $roleRegistry;
 
    private $contentRenderer;
 
    private $dbDomain;
 
    public function __construct(
        ILoadBalancer $loadBalancer,
        SlotRoleRegistry $roleRegistry,
        ContentRenderer $contentRenderer,
        $dbDomain = false
    ) {
        $this->loadBalancer = $loadBalancer;
        $this->roleRegistry = $roleRegistry;
        $this->contentRenderer = $contentRenderer;
        $this->dbDomain = $dbDomain;
        $this->saveParseLogger = new NullLogger();
    }
 
    public function setLogger( LoggerInterface $saveParseLogger ): void {
        $this->saveParseLogger = $saveParseLogger;
    }
 
    public function getRenderedRevision(
        RevisionRecord $rev,
        ?ParserOptions $options = null,
        ?Authority $forPerformer = null,
        array $hints = []
    ) {
        if ( $rev->getWikiId() !== $this->dbDomain ) {
            throw new InvalidArgumentException(
                "Mismatching wiki ID rev={$rev->getWikiId()}, this={$this->dbDomain}"
            );
        }
 
        $audience = $hints['audience']
            ?? ( $forPerformer ? RevisionRecord::FOR_THIS_USER : RevisionRecord::FOR_PUBLIC );
 
        if ( !$rev->audienceCan( RevisionRecord::DELETED_TEXT, $audience, $forPerformer ) ) {
            // Returning null here is awkward, but consistent with the signature of
            // RevisionRecord::getContent().
            return null;
        }
 
        if ( !$options ) {
            $options = $forPerformer ?
                ParserOptions::newFromUser( $forPerformer->getUser() ) :
                ParserOptions::newFromAnon();
        }
 
        if ( isset( $hints['causeAction'] ) ) {
            $options->setRenderReason( $hints['causeAction'] );
        }
 
        $usePrimary = $hints['use-master'] ?? false;
 
        $dbIndex = $usePrimary
            ? DB_PRIMARY // use latest values
            : DB_REPLICA; // T154554
 
        $options->setSpeculativeRevIdCallback( function () use ( $dbIndex ) {
            return $this->getSpeculativeRevId( $dbIndex );
        } );
        $options->setSpeculativePageIdCallback( function () use ( $dbIndex ) {
            return $this->getSpeculativePageId( $dbIndex );
        } );
 
        if ( !$rev->getId() && $rev->getTimestamp() ) {
            // This is an unsaved revision with an already determined timestamp.
            // Make the "current" time used during parsing match that of the revision.
            // Any REVISION* parser variables will match up if the revision is saved.
            $options->setTimestamp( $rev->getTimestamp() );
        }
 
        $previousOutput = $hints['previous-output'] ?? null;
        $renderedRevision = new RenderedRevision(
            $rev,
            $options,
            $this->contentRenderer,
            function ( RenderedRevision $rrev, array $hints ) use ( $options, $previousOutput ) {
                $h = [ 'previous-output' => $previousOutput ] + $hints;
                return $this->combineSlotOutput( $rrev, $options, $h );
            },
            $audience,
            $forPerformer
        );
 
        $renderedRevision->setSaveParseLogger( $this->saveParseLogger );
 
        if ( isset( $hints['known-revision-output'] ) ) {
            $renderedRevision->setRevisionParserOutput( $hints['known-revision-output'] );
        }
 
        return $renderedRevision;
    }
 
    private function getSpeculativeRevId( int $dbIndex ): int {
        // Use a separate primary DB connection in order to see the latest data, by avoiding
        // stale data from REPEATABLE-READ snapshots.
        $flags = ILoadBalancer::CONN_TRX_AUTOCOMMIT;
 
        $db = $this->loadBalancer->getConnection( $dbIndex, [], $this->dbDomain, $flags );
 
        return 1 + (int)$db->newSelectQueryBuilder()
            ->select( 'MAX(rev_id)' )
            ->from( 'revision' )
            ->caller( __METHOD__ )->fetchField();
    }
 
    private function getSpeculativePageId( int $dbIndex ): int {
        // Use a separate primary DB connection in order to see the latest data, by avoiding
        // stale data from REPEATABLE-READ snapshots.
        $flags = ILoadBalancer::CONN_TRX_AUTOCOMMIT;
 
        $db = $this->loadBalancer->getConnection( $dbIndex, [], $this->dbDomain, $flags );
 
        return 1 + (int)$db->newSelectQueryBuilder()
            ->select( 'MAX(page_id)' )
            ->from( 'page' )
            ->caller( __METHOD__ )->fetchField();
    }
 
    private function combineSlotOutput( RenderedRevision $rrev, ParserOptions $options, array $hints = [] ) {
        $revision = $rrev->getRevision();
        $slots = $revision->getSlots()->getSlots();
 
        $withHtml = $hints['generate-html'] ?? true;
        $previousOutputs = $this->splitSlotOutput( $rrev, $options, $hints['previous-output'] ?? null );
 
        // short circuit if there is only the main slot
        // T351026 hack: if use-parsoid is set, only return main slot output for now
        // T351113 will remove this hack.
        if ( array_keys( $slots ) === [ SlotRecord::MAIN ] || $options->getUseParsoid() ) {
            $h = [ 'previous-output' => $previousOutputs[SlotRecord::MAIN] ] + $hints;
            return $rrev->getSlotParserOutput( SlotRecord::MAIN, $h );
        }
 
        // move main slot to front
        if ( isset( $slots[SlotRecord::MAIN] ) ) {
            $slots = [ SlotRecord::MAIN => $slots[SlotRecord::MAIN] ] + $slots;
        }
 
        $combinedOutput = new ParserOutput( null );
        $slotOutput = [];
 
        $options = $rrev->getOptions();
        $options->registerWatcher( $combinedOutput->recordOption( ... ) );
 
        foreach ( $slots as $role => $slot ) {
            $h = [ 'previous-output' => $previousOutputs[$role] ] + $hints;
            $out = $rrev->getSlotParserOutput( $role, $h );
            $slotOutput[$role] = $out;
 
            // XXX: should the SlotRoleHandler be able to intervene here?
            // XXX: this should probably just use ParserOutput::collectMetadata
            $combinedOutput->mergeInternalMetaDataFrom( $out );
            $combinedOutput->mergeTrackingMetaDataFrom( $out );
        }
 
        if ( $withHtml ) {
            $html = '';
            $first = true;
            foreach ( $slotOutput as $role => $out ) {
                $roleHandler = $this->roleRegistry->getRoleHandler( $role );
 
                // TODO: put more fancy layout logic here, see T200915.
                $layout = $roleHandler->getOutputLayoutHints();
                $display = $layout['display'] ?? 'section';
 
                if ( $display === 'none' ) {
                    continue;
                }
 
                if ( $first ) {
                    // skip header for the first slot
                    $first = false;
                } else {
                    // NOTE: this placeholder is hydrated by ParserOutput::getText().
                    $headText = Html::element( 'mw:slotheader', [], $role );
                    $html .= Html::rawElement( 'h1', [ 'class' => 'mw-slot-header' ], $headText );
                    $combinedOutput->setOutputFlag( ParserOutputFlags::HAS_SLOT_HEADERS );
                }
 
                // XXX: do we want to put a wrapper div around the output?
                // Do we want to let $roleHandler do that?
                $html .= $out->getContentHolderText();
                $combinedOutput->mergeHtmlMetaDataFrom( $out );
            }
 
            $combinedOutput->setContentHolderText( $html );
        }
 
        $options->registerWatcher( null );
        return $combinedOutput;
    }
 
    private function splitSlotOutput( RenderedRevision $rrev, ParserOptions $options, ?ParserOutput $previousOutput ) {
        // If there is no previous parse, then there is nothing to split.
        $revision = $rrev->getRevision();
        $revslots = $revision->getSlots();
        if ( $previousOutput === null ) {
            return array_fill_keys( $revslots->getSlotRoles(), null );
        }
 
        // short circuit if there is only the main slot
        // T351026 hack: if use-parsoid is set, only return main slot output for now
        // T351113 will remove this hack.
        if ( $revslots->getSlotRoles() === [ SlotRecord::MAIN ] || $options->getUseParsoid() ) {
            return [ SlotRecord::MAIN => $previousOutput ];
        }
 
        // @todo Currently slot combination is not reversible
        return array_fill_keys( $revslots->getSlotRoles(), null );
    }
}