8983c9d862
getTablePrefix() is used to show the inline legend and inline switcher. It is not yet part of a released stable interface. Theoretically there may be multiple text slots on a page, and we don't want multiple inline legends. There was already a fragment assembly system, for the benefit of hook handlers, so move that up to the page level, so that it can also deduplicate prefix fragments coming from each slot. Add tests. Bug: T324759 Change-Id: I9baa5c24128c63bc318ba13e83a024843f4ab15e
390 lines
12 KiB
PHP
390 lines
12 KiB
PHP
<?php
|
|
/**
|
|
* Renders a slot diff by doing a text diff on the native representation.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
* http://www.gnu.org/copyleft/gpl.html
|
|
*
|
|
* @file
|
|
* @ingroup DifferenceEngine
|
|
*/
|
|
|
|
use MediaWiki\HookContainer\HookContainer;
|
|
use MediaWiki\HookContainer\HookRunner;
|
|
use MediaWiki\Html\Html;
|
|
use MediaWiki\MainConfigNames;
|
|
use MediaWiki\MediaWikiServices;
|
|
use MediaWiki\Shell\Shell;
|
|
use MediaWiki\Title\Title;
|
|
use OOUI\ButtonGroupWidget;
|
|
use OOUI\ButtonWidget;
|
|
use Wikimedia\Assert\Assert;
|
|
use Wikimedia\Diff\Diff;
|
|
use Wikimedia\Diff\TableDiffFormatter;
|
|
|
|
/**
|
|
* Renders a slot diff by doing a text diff on the native representation.
|
|
*
|
|
* If you want to use this without content objects (to call getTextDiff() on some
|
|
* non-content-related texts), obtain an instance with
|
|
* ContentHandler::getForModelID( CONTENT_MODEL_TEXT )
|
|
* ->getSlotDiffRenderer( RequestContext::getMain() )
|
|
*
|
|
* @ingroup DifferenceEngine
|
|
*/
|
|
class TextSlotDiffRenderer extends SlotDiffRenderer {
|
|
|
|
/** Use the PHP diff implementation (DiffEngine). */
|
|
public const ENGINE_PHP = 'php';
|
|
|
|
/** Use the wikidiff2 PHP module. */
|
|
public const ENGINE_WIKIDIFF2 = 'wikidiff2';
|
|
|
|
/** Use the wikidiff2 PHP module. */
|
|
public const ENGINE_WIKIDIFF2_INLINE = 'wikidiff2inline';
|
|
|
|
/** Use an external executable. */
|
|
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';
|
|
|
|
/** @var IBufferingStatsdDataFactory|null */
|
|
private $statsdDataFactory;
|
|
|
|
/** @var Language|null The language this content is in. */
|
|
private $language;
|
|
|
|
/** @var HookRunner|null */
|
|
private $hookRunner;
|
|
|
|
/** @var string One of the ENGINE_* constants. */
|
|
private $engine = self::ENGINE_PHP;
|
|
|
|
/** @var string|null Path to an executable to be used as the diff engine. */
|
|
private $externalEngine;
|
|
|
|
/** @var string */
|
|
private $contentModel;
|
|
|
|
/** @inheritDoc */
|
|
public function getExtraCacheKeys() {
|
|
// Tell DifferenceEngine this is a different variant from the standard wikidiff2 variant
|
|
return $this->engine === self::ENGINE_WIKIDIFF2_INLINE ? [
|
|
phpversion( 'wikidiff2' ), 'inline'
|
|
] : [];
|
|
}
|
|
|
|
/**
|
|
* Convenience helper to use getTextDiff without an instance.
|
|
* @param string $oldText
|
|
* @param string $newText
|
|
* @return string
|
|
*/
|
|
public static function diff( $oldText, $newText ) {
|
|
/** @var TextSlotDiffRenderer $slotDiffRenderer */
|
|
$slotDiffRenderer = MediaWikiServices::getInstance()
|
|
->getContentHandlerFactory()
|
|
->getContentHandler( CONTENT_MODEL_TEXT )
|
|
->getSlotDiffRenderer( RequestContext::getMain() );
|
|
'@phan-var TextSlotDiffRenderer $slotDiffRenderer';
|
|
return $slotDiffRenderer->getTextDiff( $oldText, $newText );
|
|
}
|
|
|
|
/**
|
|
* @param IBufferingStatsdDataFactory $statsdDataFactory
|
|
*/
|
|
public function setStatsdDataFactory( IBufferingStatsdDataFactory $statsdDataFactory ) {
|
|
$this->statsdDataFactory = $statsdDataFactory;
|
|
}
|
|
|
|
/**
|
|
* @param Language $language
|
|
*/
|
|
public function setLanguage( Language $language ) {
|
|
$this->language = $language;
|
|
}
|
|
|
|
/**
|
|
* @since 1.41
|
|
* @param HookContainer $hookContainer
|
|
*/
|
|
public function setHookContainer( HookContainer $hookContainer ): void {
|
|
$this->hookRunner = new HookRunner( $hookContainer );
|
|
}
|
|
|
|
/**
|
|
* @param string $contentModel
|
|
* @since 1.41
|
|
*/
|
|
public function setContentModel( string $contentModel ) {
|
|
$this->contentModel = $contentModel;
|
|
}
|
|
|
|
/**
|
|
* Set which diff engine to use.
|
|
* @param string $type One of the ENGINE_* constants.
|
|
* @param string|null $executable Path to an external executable, only when type is ENGINE_EXTERNAL.
|
|
*/
|
|
public function setEngine( $type, $executable = null ) {
|
|
$engines = [ self::ENGINE_PHP, self::ENGINE_WIKIDIFF2, self::ENGINE_EXTERNAL,
|
|
self::ENGINE_WIKIDIFF2_INLINE ];
|
|
Assert::parameter( in_array( $type, $engines, true ), '$type',
|
|
'must be one of the TextSlotDiffRenderer::ENGINE_* constants' );
|
|
if ( $type === self::ENGINE_EXTERNAL ) {
|
|
Assert::parameter( is_string( $executable ) && is_executable( $executable ), '$executable',
|
|
'must be a path to a valid executable' );
|
|
} else {
|
|
Assert::parameter( $executable === null, '$executable',
|
|
'must not be set unless $type is ENGINE_EXTERNAL' );
|
|
}
|
|
$this->engine = $type;
|
|
$this->externalEngine = $executable;
|
|
}
|
|
|
|
/**
|
|
* Get the content model ID that this renderer acts on
|
|
*
|
|
* @since 1.41
|
|
* @return string
|
|
*/
|
|
public function getContentModel(): string {
|
|
return $this->contentModel;
|
|
}
|
|
|
|
/** @inheritDoc */
|
|
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 );
|
|
}
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
public function getTablePrefix( IContextSource $context, Title $newTitle ): array {
|
|
$legend = null;
|
|
$inlineSwitcher = null;
|
|
|
|
$showDiffToggleSwitch = $context->getConfig()->get( MainConfigNames::ShowDiffToggleSwitch );
|
|
|
|
if ( $showDiffToggleSwitch ) {
|
|
// wikidiff2 inline type gets a legend to explain the highlighting colours and show an inline toggle
|
|
if ( $this->engine === self::ENGINE_WIKIDIFF2 ||
|
|
$this->engine === self::ENGINE_WIKIDIFF2_INLINE ) {
|
|
$ins = Html::element( 'span',
|
|
[ 'class' => 'mw-diff-inline-legend-ins' ],
|
|
$context->msg( 'diff-inline-tooltip-ins' )->plain()
|
|
);
|
|
$del = Html::element( 'span',
|
|
[ 'class' => 'mw-diff-inline-legend-del' ],
|
|
$context->msg( 'diff-inline-tooltip-del' )->plain()
|
|
);
|
|
$hideDiffClass = $this->engine === self::ENGINE_WIKIDIFF2 ? 'mw-diff-element-hidden' : '';
|
|
$legend = Html::rawElement( 'div',
|
|
[ 'class' => 'mw-diff-inline-legend ' . $hideDiffClass ], "$ins $del"
|
|
);
|
|
|
|
$values = $context->getRequest()->getValues();
|
|
$isInlineDiffType = isset( $values['diff-type'] ) && $values['diff-type'] === 'inline';
|
|
unset( $values[ 'diff-type' ] );
|
|
unset( $values[ 'title' ] );
|
|
$inlineSwitcher = Html::rawElement( 'div',
|
|
[ 'class' => 'mw-diffPage-inlineToggle-container' ],
|
|
// Will be replaced by a ButtonSelectWidget in JS
|
|
new ButtonGroupWidget( [
|
|
'items' => [
|
|
new ButtonWidget( [
|
|
'active' => $isInlineDiffType,
|
|
'label' => $context->msg( 'diff-inline-format-label' )->plain(),
|
|
'href' => $newTitle->getLocalURL( $values ) . '&diff-type=inline'
|
|
] ),
|
|
new ButtonWidget( [
|
|
'active' => !$isInlineDiffType,
|
|
'label' => $context->msg( 'diff-table-format-label' )->plain(),
|
|
'href' => $newTitle->getLocalURL( $values )
|
|
] )
|
|
]
|
|
] )
|
|
);
|
|
}
|
|
}
|
|
// Allow extensions to add other parts to this area (or modify the legend).
|
|
// 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 => $legend, self::INLINE_SWITCHER_KEY => $inlineSwitcher ];
|
|
|
|
$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;
|
|
}
|
|
|
|
/**
|
|
* Diff the text representations of two content objects (or just two pieces of text in general).
|
|
* @param string $oldText
|
|
* @param string $newText
|
|
* @return string HTML. One or more <tr> tags, or an empty string if the inputs are identical.
|
|
*/
|
|
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 );
|
|
}
|
|
|
|
// TODO reimplement this using T142313
|
|
/*
|
|
// Log requests slower than 99th percentile
|
|
if ( $time > 100 && $this->mOldPage && $this->mNewPage ) {
|
|
wfDebugLog( 'diff',
|
|
"$time ms diff: {$this->mOldid} -> {$this->mNewid} {$this->mNewPage}" );
|
|
}
|
|
*/
|
|
|
|
return $result;
|
|
};
|
|
|
|
/**
|
|
* @param Status $status
|
|
* @throws FatalError
|
|
* @return never
|
|
*/
|
|
$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();
|
|
}
|
|
|
|
/**
|
|
* Diff the text representations of two content objects (or just two pieces of text in general).
|
|
* This does the actual diffing, getTextDiff() wraps it with logging and resource limiting.
|
|
* @param string $oldText
|
|
* @param string $newText
|
|
* @return string
|
|
* @throws Exception
|
|
*/
|
|
protected function getTextDiffInternal( $oldText, $newText ) {
|
|
// TODO move most of this into three parallel implementations of a text diff generator
|
|
// class, choose which one to use via dependency injection
|
|
|
|
$oldText = str_replace( "\r\n", "\n", $oldText );
|
|
$newText = str_replace( "\r\n", "\n", $newText );
|
|
|
|
if ( $oldText === $newText ) {
|
|
return '';
|
|
}
|
|
|
|
// Better external diff engine, the 2 may some day be dropped
|
|
// This one does the escaping and segmenting itself
|
|
if ( $this->engine === self::ENGINE_WIKIDIFF2 ) {
|
|
$wikidiff2Version = phpversion( 'wikidiff2' );
|
|
if (
|
|
$wikidiff2Version !== false &&
|
|
version_compare( $wikidiff2Version, '1.5.0', '>=' ) &&
|
|
version_compare( $wikidiff2Version, '1.8.0', '<' )
|
|
) {
|
|
$text = wikidiff2_do_diff(
|
|
$oldText,
|
|
$newText,
|
|
2,
|
|
0
|
|
);
|
|
} else {
|
|
// Don't pass the 4th parameter introduced in version 1.5.0 and removed in version 1.8.0
|
|
$text = wikidiff2_do_diff(
|
|
$oldText,
|
|
$newText,
|
|
2
|
|
);
|
|
}
|
|
|
|
return $text;
|
|
} elseif ( $this->engine === self::ENGINE_EXTERNAL ) {
|
|
# Diff via the shell
|
|
$tmpDir = wfTempDir();
|
|
$tempName1 = tempnam( $tmpDir, 'diff_' );
|
|
$tempName2 = tempnam( $tmpDir, 'diff_' );
|
|
|
|
$tempFile1 = fopen( $tempName1, "w" );
|
|
if ( !$tempFile1 ) {
|
|
throw new Exception( "Could not create temporary file $tempName1 for external diffing" );
|
|
}
|
|
$tempFile2 = fopen( $tempName2, "w" );
|
|
if ( !$tempFile2 ) {
|
|
throw new Exception( "Could not create temporary file $tempName2 for external diffing" );
|
|
}
|
|
fwrite( $tempFile1, $oldText );
|
|
fwrite( $tempFile2, $newText );
|
|
fclose( $tempFile1 );
|
|
fclose( $tempFile2 );
|
|
$cmd = [ $this->externalEngine, $tempName1, $tempName2 ];
|
|
$result = Shell::command( $cmd )
|
|
->execute();
|
|
$exitCode = $result->getExitCode();
|
|
if ( $exitCode !== 0 ) {
|
|
throw new Exception( "External diff command returned code {$exitCode}. Stderr: "
|
|
. wfEscapeWikiText( $result->getStderr() )
|
|
);
|
|
}
|
|
$difftext = $result->getStdout();
|
|
unlink( $tempName1 );
|
|
unlink( $tempName2 );
|
|
|
|
return $difftext;
|
|
} elseif ( $this->engine === self::ENGINE_PHP ) {
|
|
if ( $this->language ) {
|
|
$oldText = $this->language->segmentForDiff( $oldText );
|
|
$newText = $this->language->segmentForDiff( $newText );
|
|
}
|
|
$ota = explode( "\n", $oldText );
|
|
$nta = explode( "\n", $newText );
|
|
$diffs = new Diff( $ota, $nta );
|
|
$formatter = new TableDiffFormatter();
|
|
$difftext = $formatter->format( $diffs );
|
|
if ( $this->language ) {
|
|
$difftext = $this->language->unsegmentForDiff( $difftext );
|
|
}
|
|
|
|
return $difftext;
|
|
} elseif ( $this->engine === self::ENGINE_WIKIDIFF2_INLINE ) {
|
|
// Note wikidiff2_inline_diff returns an element sans table.
|
|
// Due to the way other diffs work (return a table with before and after), we need to wrap
|
|
// the output in a row that spans the 4 columns that are expected, so that our diff appears in
|
|
// the correct place!
|
|
return '<tr><td colspan="4">' . wikidiff2_inline_diff( $oldText, $newText, 2 ) . '</td></tr>';
|
|
}
|
|
throw new LogicException( 'Invalid engine: ' . $this->engine );
|
|
}
|
|
|
|
}
|