Page MenuHomeWickedGov Phorge

MetaHandler.php
No OneTemporary

Size
10 KB
Referenced Files
None
Subscribers
None

MetaHandler.php

<?php
declare( strict_types = 1 );
namespace Wikimedia\Parsoid\Html2Wt\DOMHandlers;
use Wikimedia\Parsoid\DOM\Element;
use Wikimedia\Parsoid\DOM\Node;
use Wikimedia\Parsoid\DOM\Text;
use Wikimedia\Parsoid\Html2Wt\DiffUtils;
use Wikimedia\Parsoid\Html2Wt\SerializerState;
use Wikimedia\Parsoid\Html2Wt\WTSUtils;
use Wikimedia\Parsoid\Utils\DiffDOMUtils;
use Wikimedia\Parsoid\Utils\DOMCompat;
use Wikimedia\Parsoid\Utils\DOMDataUtils;
use Wikimedia\Parsoid\Utils\DOMUtils;
use Wikimedia\Parsoid\Utils\WTUtils;
class MetaHandler extends DOMHandler {
public function __construct() {
parent::__construct( false );
}
/** @inheritDoc */
public function handle(
Element $node, SerializerState $state, bool $wrapperUnmodified = false
): ?Node {
$property = DOMCompat::getAttribute( $node, 'property' ) ?? '';
$dp = DOMDataUtils::getDataParsoid( $node );
$dmw = DOMDataUtils::getDataMw( $node );
if ( isset( $dp->src ) &&
DOMUtils::matchTypeOf( $node, '#^mw:Placeholder(/|$)#' )
) {
$this->emitPlaceholderSrc( $node, $state );
return $node->nextSibling;
}
// Check for property before type so that page properties with
// templated attrs roundtrip properly.
// Ex: {{DEFAULTSORT:{{1x|foo}} }}
if ( $property ) {
preg_match( '#^mw\:PageProp/(.*)$#D', $property, $switchType );
if ( $switchType ) {
$out = $switchType[1];
$cat = preg_match( '/^(?:category)?(.*)/', $out, $catMatch );
if ( $cat && (
// Need this b/c support while RESTBase has Parsoid HTML
// in storage with meta tags for these.
// Can be removed as part of T335843
$catMatch[1] === 'defaultsort' || $catMatch[1] === 'displaytitle'
) ) {
$contentInfo = $state->serializer->serializedAttrVal( $node, 'content' );
if ( WTUtils::hasExpandedAttrsType( $node ) ) {
$out = '{{' . $contentInfo['value'] . '}}';
} elseif ( isset( $dp->src ) ) {
$colon = strpos( $dp->src, ':', 2 );
$out = preg_replace( '/^([^:}]+).*$/D', "$1", $dp->src, 1 );
if ( ( $colon === false ) && ( $contentInfo['value'] === '' ) ) {
$out .= '}}';
} else {
$out .= ':' . $contentInfo['value'] . '}}';
}
} else {
$magicWord = mb_strtoupper( $catMatch[1] );
$out = '{{' . $magicWord . ':' . $contentInfo['value'] . '}}';
}
} else {
$out = $state->getEnv()->getSiteConfig()->getMagicWordWT(
$switchType[1], $dp->magicSrc ?? '' );
}
$state->emitChunk( $out, $node );
} else {
( new FallbackHTMLHandler )->handle( $node, $state );
}
} elseif ( WTUtils::isAnnotationStartMarkerMeta( $node ) ) {
$annType = WTUtils::extractAnnotationType( $node );
if ( $this->needToWriteStartMeta( $state, $node ) ) {
$datamw = DOMDataUtils::getDataMw( $node );
$attrs = "";
if ( isset( $datamw->attrs ) ) {
foreach ( get_object_vars( $datamw->attrs ) as $k => $v ) {
if ( $v === "" ) {
$attrs .= ' ' . $k;
} else {
$attrs .= ' ' . $k . '="' . $v . '"';
}
}
}
// Follow-up on attributes sanitation to happen in T295168
$state->emitChunk( '<' . $annType . $attrs . '>', $node );
$state->openAnnotationRange( $annType, $datamw->extendedRange ?? false );
}
} elseif ( WTUtils::isAnnotationEndMarkerMeta( $node ) ) {
if ( $this->needToWriteEndMeta( $state, $node ) ) {
$annType = WTUtils::extractAnnotationType( $node );
$state->emitChunk( '</' . $annType . '>', $node );
$state->closeAnnotationRange( $annType );
}
} else {
switch ( DOMCompat::getAttribute( $node, 'typeof' ) ) {
case 'mw:Includes/IncludeOnly':
// Remove the dp.src when older revisions of HTML expire in RESTBase
$state->emitChunk( $dmw->src ?? $dp->src ?? '', $node );
break;
case 'mw:Includes/IncludeOnly/End':
// Just ignore.
break;
case 'mw:Includes/NoInclude':
$state->emitChunk( $dp->src ?? '<noinclude>', $node );
break;
case 'mw:Includes/NoInclude/End':
$state->emitChunk( $dp->src ?? '</noinclude>', $node );
break;
case 'mw:Includes/OnlyInclude':
$state->emitChunk( $dp->src ?? '<onlyinclude>', $node );
break;
case 'mw:Includes/OnlyInclude/End':
$state->emitChunk( $dp->src ?? '</onlyinclude>', $node );
break;
case 'mw:DiffMarker/inserted':
case 'mw:DiffMarker/deleted':
case 'mw:DiffMarker/moved':
case 'mw:Separator':
// just ignore it
break;
default:
( new FallbackHTMLHandler() )->handle( $node, $state );
}
}
return $node->nextSibling;
}
/**
* Decides if we need to write an annotation start meta at the place we encounter it
* @param SerializerState $state
* @param Element $node
* @return bool
*/
private function needToWriteStartMeta( SerializerState $state, Element $node ): bool {
if ( !$state->selserMode ) {
return true;
}
if ( WTUtils::isMovedMetaTag( $node ) ) {
$nextContentSibling = DOMCompat::getNextElementSibling( $node );
// If the meta tag has been moved, it comes from its next element.... "almost".
// First exception is if we have several marker annotations in a row - then we need
// to pass them all. Second exception is if we have fostered content: then we're
// interested in what happens in the table, which happens _after_ the fostered content.
while ( $nextContentSibling !== null &&
( WTUtils::isMarkerAnnotation( $nextContentSibling ) ||
!empty( DOMDataUtils::getDataParsoid( $nextContentSibling )->fostered )
)
) {
$nextContentSibling = DOMCompat::getNextElementSibling( $nextContentSibling );
}
if ( $nextContentSibling !== null ) {
// When the content from which the meta tag comes gets
// deleted or modified, we emit _now_ so that we don't risk losing it. The range
// stays extended in the round-tripped version of the wikitext.
$nextdiffdata = DOMDataUtils::getDataParsoidDiff( $nextContentSibling );
if ( DiffUtils::isDiffMarker( $nextContentSibling ) ||
( $nextdiffdata->diff ?? null ) ) {
return true;
}
return !WTSUtils::origSrcValidInEditedContext( $state, $nextContentSibling );
}
}
return true;
}
/**
* Decides if we need to write an annotation end meta at the place we encounter it
* @param SerializerState $state
* @param Element $node
* @return bool
*/
private function needToWriteEndMeta( SerializerState $state, Element $node ): bool {
if ( !$state->selserMode ) {
return true;
}
if ( WTUtils::isMovedMetaTag( $node ) ) {
$prevElementSibling = DOMCompat::getPreviousElementSibling( $node );
while ( $prevElementSibling !== null &&
WTUtils::isMarkerAnnotation( $prevElementSibling )
) {
$prevElementSibling = DOMCompat::getPreviousElementSibling( $prevElementSibling );
}
if ( $prevElementSibling ) {
$prevdiffdata = DOMDataUtils::getDataParsoidDiff( $prevElementSibling );
if (
DiffUtils::isDiffMarker( $prevElementSibling ) ||
( $prevdiffdata !== null && $prevdiffdata->diff !== null )
) {
return true;
}
return !WTSUtils::origSrcValidInEditedContext( $state, $prevElementSibling );
}
}
return true;
}
/**
* We create a newline (or two) if:
* * the previous element is a block element
* * the previous element is text, AND we're not in an inline-text situation: this
* corresponds to text having been added in VE without creating a paragraph, which happens
* when inserting a new line before the <meta> tag in VE. The "we're not in an inline text"
* is a heuristic and doesn't work for the ends of line for instance, but it shouldn't add
* semantic whitespace either.
* @param Node $meta
* @param Node $otherNode
* @return bool
*/
private function needNewLineSepBeforeMeta( Node $meta, Node $otherNode ) {
return ( $otherNode !== $meta->parentNode
&& (
( $otherNode instanceof Element && DOMUtils::isWikitextBlockNode( $otherNode ) ) ||
( $otherNode instanceof Text &&
DOMUtils::isWikitextBlockNode( DiffDOMUtils::nextNonSepSibling( $meta ) )
)
) );
}
/** @inheritDoc */
public function before( Element $node, Node $otherNode, SerializerState $state ): array {
if ( WTUtils::isAnnotationStartMarkerMeta( $node ) ) {
if ( $this->needNewLineSepBeforeMeta( $node, $otherNode ) ) {
return [ 'min' => 2 ];
} else {
return [];
}
}
if ( WTUtils::isAnnotationEndMarkerMeta( $node ) ) {
if ( $this->needNewLineSepBeforeMeta( $node, $otherNode ) ) {
return [
'min' => 1
];
} else {
return [];
}
}
$type = DOMCompat::getAttribute( $node, 'typeof' ) ??
DOMCompat::getAttribute( $node, 'property' );
if ( $type && str_contains( $type, 'mw:PageProp/categorydefaultsort' ) ) {
if ( $otherNode instanceof Element
&& DOMCompat::nodeName( $otherNode ) === 'p'
&& ( DOMDataUtils::getDataParsoid( $otherNode )->stx ?? null ) !== 'html'
) {
// Since defaultsort is outside the p-tag, we need 2 newlines
// to ensure that it go back into the p-tag when parsed.
return [ 'min' => 2 ];
} else {
return [ 'min' => 1 ];
}
} elseif ( WTUtils::isNewElt( $node ) &&
// Placeholder and annotation metas or <*include*> tags don't need to be serialized on
// their own line
!DOMUtils::matchTypeOf( $node, '#^mw:(Placeholder|Includes|Annotation)(/|$)#' )
) {
return [ 'min' => 1 ];
} else {
return [];
}
}
/** @inheritDoc */
public function after( Element $node, Node $otherNode, SerializerState $state ): array {
if ( WTUtils::isAnnotationEndMarkerMeta( $node ) ) {
if ( $otherNode !== $node->parentNode && $otherNode instanceof Element &&
DOMUtils::isWikitextBlockNode( $otherNode ) ) {
return [ 'min' => 2 ];
} else {
return [];
}
}
if ( WTUtils::isAnnotationStartMarkerMeta( $node ) ) {
if ( $otherNode !== $node->parentNode && $otherNode instanceof Element &&
DOMUtils::isWikitextBlockNode( $otherNode ) ) {
return [ 'min' => 1 ];
} else {
return [];
}
}
// No diffs
if ( WTUtils::isNewElt( $node ) &&
// Placeholder and annotation metas or <*include*> tags don't need to be serialized on
// their own line
!DOMUtils::matchTypeOf( $node, '#^mw:(Placeholder|Includes|Annotation)(/|$)#' )
) {
return [ 'min' => 1 ];
} else {
return [];
}
}
}

File Metadata

Mime Type
text/x-php
Expires
Sun, Nov 22, 13:47 (4 h, 48 m ago)
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
59/d8/468581e1b90663d0a50330d53f14
Default Alt Text
MetaHandler.php (10 KB)

Event Timeline