TextSlotDiffRenderer.php

Go to the documentation of this file.

<?php
use MediaWiki\Diff\TextDiffer\ManifoldTextDiffer;
use MediaWiki\Diff\TextDiffer\TextDiffer;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Html\Html;
use MediaWiki\MediaWikiServices;
use MediaWiki\Status\Status;
use MediaWiki\Title\Title;
use OOUI\ToggleSwitchWidget;
 
class TextSlotDiffRenderer extends SlotDiffRenderer {
 
    public const ENGINE_PHP = 'php';
 
    public const ENGINE_WIKIDIFF2 = 'wikidiff2';
 
    public const ENGINE_WIKIDIFF2_INLINE = 'wikidiff2inline';
 
    public const ENGINE_EXTERNAL = 'external';
 
    public const INLINE_LEGEND_KEY = '10_mw-diff-inline-legend';
 
    public const INLINE_SWITCHER_KEY = '60_mw-diff-inline-switch';
 
    private $statsdDataFactory;
 
    private $hookRunner;
 
    private $format;
 
    private $contentModel;
 
    private $textDiffer;
 
    private $inlineToggleEnabled = false;
 
    public function getExtraCacheKeys() {
        return $this->textDiffer->getCacheKeys( [ $this->format ] );
    }
 
    public static function diff( $oldText, $newText, $options = [] ) {
        $slotDiffRenderer = MediaWikiServices::getInstance()
            ->getContentHandlerFactory()
            ->getContentHandler( CONTENT_MODEL_TEXT )
            ->getSlotDiffRenderer( RequestContext::getMain(), $options );
        '@phan-var TextSlotDiffRenderer $slotDiffRenderer';
        return $slotDiffRenderer->getTextDiff( $oldText, $newText );
    }
 
    public function setStatsdDataFactory( IBufferingStatsdDataFactory $statsdDataFactory ) {
        $this->statsdDataFactory = $statsdDataFactory;
    }
 
    public function setLanguage( Language $language ) {
        wfDeprecated( __METHOD__, '1.41' );
    }
 
    public function setHookContainer( HookContainer $hookContainer ): void {
        $this->hookRunner = new HookRunner( $hookContainer );
    }
 
    public function setContentModel( string $contentModel ) {
        $this->contentModel = $contentModel;
    }
 
    public function setEngine( $type, $executable = null ) {
        if ( $executable !== null ) {
            throw new \InvalidArgumentException(
                'The $executable parameter is no longer supported and must be null'
            );
        }
        switch ( $type ) {
            case self::ENGINE_PHP:
                $engine = 'php';
                $format = 'table';
                break;
 
            case self::ENGINE_WIKIDIFF2:
                $engine = 'wikidiff2';
                $format = 'table';
                break;
 
            case self::ENGINE_EXTERNAL:
                $engine = 'external';
                $format = 'external';
                break;
 
            case self::ENGINE_WIKIDIFF2_INLINE:
                $engine = 'wikidiff2';
                $format = 'inline';
                break;
 
            default:
                throw new \InvalidArgumentException( '$type ' .
                    'must be one of the TextSlotDiffRenderer::ENGINE_* constants' );
        }
        if ( $this->textDiffer instanceof ManifoldTextDiffer ) {
            $this->textDiffer->setEngine( $engine );
        }
        $this->setFormat( $format );
    }
 
    public function setFormat( $format ) {
        $this->format = $format;
    }
 
    public function setTextDiffer( TextDiffer $textDiffer ) {
        $this->textDiffer = $textDiffer;
    }
 
    private function getTextDiffer(): TextDiffer {
        return $this->textDiffer;
    }
 
    public function setInlineToggleEnabled( $enabled = true ) {
        $this->inlineToggleEnabled = $enabled;
    }
 
    public function getContentModel(): string {
        return $this->contentModel;
    }
 
    public function getDiff( Content $oldContent = null, Content $newContent = null ) {
        $this->normalizeContents( $oldContent, $newContent, TextContent::class );
 
        $oldText = $oldContent->serialize();
        $newText = $newContent->serialize();
 
        return $this->getTextDiff( $oldText, $newText );
    }
 
    public function localizeDiff( $diff, $options = [] ) {
        return $this->textDiffer->localize( $this->format, $diff, $options );
    }
 
    public function getTablePrefix( IContextSource $context, Title $newTitle ): array {
        $parts = $this->getTextDiffer()->getTablePrefixes( $this->format );
 
        $showDiffToggleSwitch = $this->inlineToggleEnabled && $this->getTextDiffer()->hasFormat( 'inline' );
        // If we support the inline type, add a toggle switch
        if ( $showDiffToggleSwitch ) {
            $values = $context->getRequest()->getValues();
            $isInlineDiffType = $this->format === 'inline';
            $values[ 'diff-type' ] = $isInlineDiffType ? 'table' : 'inline';
            unset( $values[ 'title' ] );
            $parts[self::INLINE_SWITCHER_KEY] = Html::rawElement( 'div',
                [ 'class' => 'mw-diffPage-inlineToggle-container' ],
                new OOUI\FieldLayout(
                    new ToggleSwitchWidget( [
                        'id' => 'mw-diffPage-inline-toggle-switch',
                        'href' => $newTitle->getLocalURL( $values ),
                        'value' => $isInlineDiffType
                    ] ),
                    [
                        'id' => 'mw-diffPage-inline-toggle-switch-layout',
                        'label' => $context->msg( 'diff-inline-format-label' )->plain(),
                        'infusable' => true
                    ]
                ),
            );
        }
        // Add an empty placeholder for the legend is added when it's not in
        // use and other items have been added.
        $parts += [ self::INLINE_LEGEND_KEY => null, self::INLINE_SWITCHER_KEY => null ];
 
        // Allow extensions to add other parts to this area (or modify the legend).
        $this->hookRunner->onTextSlotDiffRendererTablePrefix( $this, $context, $parts );
        if ( count( $parts ) > 1 && $parts[self::INLINE_LEGEND_KEY] === null ) {
            $parts[self::INLINE_LEGEND_KEY] = Html::element( 'div' );
        }
        return $parts;
    }
 
    public function getTextDiff( string $oldText, string $newText ) {
        $diff = function () use ( $oldText, $newText ) {
            $time = microtime( true );
 
            $result = $this->getTextDiffInternal( $oldText, $newText );
 
            $time = intval( ( microtime( true ) - $time ) * 1000 );
            if ( $this->statsdDataFactory ) {
                $this->statsdDataFactory->timing( 'diff_time', $time );
            }
 
            return $result;
        };
 
        $error = static function ( $status ) {
            throw new FatalError( $status->getWikiText() );
        };
 
        // Use PoolCounter if the diff looks like it can be expensive
        if ( strlen( $oldText ) + strlen( $newText ) > 20000 ) {
            $work = new PoolCounterWorkViaCallback( 'diff',
                md5( $oldText ) . md5( $newText ),
                [ 'doWork' => $diff, 'error' => $error ]
            );
            return $work->execute();
        }
 
        return $diff();
    }
 
    protected function getTextDiffInternal( $oldText, $newText ) {
        $oldText = str_replace( "\r\n", "\n", $oldText );
        $newText = str_replace( "\r\n", "\n", $newText );
 
        if ( $oldText === $newText ) {
            return '';
        }
 
        $textDiffer = $this->getTextDiffer();
        $diffText = $textDiffer->render( $oldText, $newText, $this->format );
        return $textDiffer->addRowWrapper( $this->format, $diffText );
    }
 
}