$isInline = false;
if ( $halignOpt === 'left' ) {
$classes[] = 'mw-halign-left';
}
break;
case 'right':
// PHP parser wraps in
$isInline = false;
if ( $halignOpt === 'right' ) {
$classes[] = 'mw-halign-right';
}
break;
}
if ( $isInline ) {
$valignOpt = $opts['valign']['v'] ?? null;
switch ( $valignOpt ) {
case 'middle':
$classes[] = 'mw-valign-middle';
break;
case 'baseline':
$classes[] = 'mw-valign-baseline';
break;
case 'sub':
$classes[] = 'mw-valign-sub';
break;
case 'super':
$classes[] = 'mw-valign-super';
break;
case 'top':
$classes[] = 'mw-valign-top';
break;
case 'text_top':
$classes[] = 'mw-valign-text-top';
break;
case 'bottom':
$classes[] = 'mw-valign-bottom';
break;
case 'text_bottom':
$classes[] = 'mw-valign-text-bottom';
break;
default:
break;
}
}
return [ 'classes' => $classes, 'isInline' => $isInline ];
}
/**
* Determine the name of an option.
*
* @param string $optStr
* @param Env $env
* @return array|null
* ck Canonical key for the image option.
* v Value of the option.
* ak Aliased key for the image option - includes `"$1"` for placeholder.
* s Whether it's a simple option or one with a value.
*/
private static function getOptionInfo( string $optStr, Env $env ): ?array {
$oText = trim( $optStr );
$siteConfig = $env->getSiteConfig();
$getOption = $siteConfig->getMediaPrefixParameterizedAliasMatcher();
// oText contains the localized name of this option. the
// canonical option names (from mediawiki upstream) are in
// English and contain an '(img|timedmedia)_' prefix. We drop the
// prefix before stuffing them in data-parsoid in order to
// save space (that's shortCanonicalOption)
$canonicalOption = $siteConfig->magicWordCanonicalName( $oText ) ?? '';
$shortCanonicalOption = preg_replace( '/^(img|timedmedia)_/', '', $canonicalOption, 1 );
// 'imgOption' is the key we'd put in opts; it names the 'group'
// for the option, and doesn't have an img_ prefix.
$imgOption = WikitextConstants::$Media['SimpleOptions'][$canonicalOption] ?? null;
$bits = $getOption( $oText );
$normalizedBit0 = $bits ? mb_strtolower( trim( $bits['k'] ) ) : null;
$key = $bits ? ( WikitextConstants::$Media['PrefixOptions'][$normalizedBit0] ?? null ) : null;
if ( !empty( $imgOption ) && $key === null ) {
return [
'ck' => $imgOption,
'v' => $shortCanonicalOption,
'ak' => $optStr,
's' => true
];
}
// bits.a has the localized name for the prefix option
// (with $1 as a placeholder for the value, which is in bits.v)
// 'normalizedBit0' is the canonical English option name
// (from mediawiki upstream) with a prefix.
// 'key' is the parsoid 'group' for the option; it doesn't
// have a prefix (it's the key we'd put in opts)
if ( $bits && $key ) {
$shortCanonicalOption = preg_replace( '/^(img|timedmedia)_/', '', $normalizedBit0, 1 );
// map short canonical name to the localized version used
// Note that we deliberately do entity decoding
// *after* splitting so that HTML-encoded pipes don't
// separate options. This matches PHP, whether or
// not it's a good idea.
return [
'ck' => $shortCanonicalOption,
'v' => Utils::decodeWtEntities( $bits['v'] ),
'ak' => $optStr,
's' => false
];
}
return null;
}
/**
* @param Env $env
* @param ?array &$optInfo
* @param string $prefix
* @param string $resultStr
* @return bool
*/
private static function isWikitextOpt( Env $env, ?array &$optInfo, string $prefix,
string $resultStr ): bool {
// link and alt options are allowed to contain arbitrary
// wikitext (even though only strings are supported in reality)
// SSS FIXME: Is this actually true of all options rather than
// just link and alt?
if ( $optInfo === null ) {
$optInfo = self::getOptionInfo( $prefix . $resultStr, $env );
}
return $optInfo !== null && preg_match( '/^(link|alt)$/D', $optInfo['ck'] );
}
/**
* Make option token streams into a stringy thing that we can recognize.
*
* @param array $tstream
* @param string $prefix Anything that came before this part of the recursive call stack.
* @param Env $env
* @return string|string[]|null
*/
private static function stringifyOptionTokens( array $tstream, string $prefix, Env $env ) {
// Seems like this should be a more general "stripTags"-like function?
$tokenType = null;
$tkHref = null;
$nextResult = null;
$skipToEndOf = null;
$optInfo = null;
$resultStr = '';
for ( $i = 0; $i < count( $tstream ); $i++ ) {
$currentToken = $tstream[$i];
if ( $skipToEndOf ) {
if ( $currentToken instanceof EndTagTk && $currentToken->getName() === $skipToEndOf ) {
$skipToEndOf = null;
}
continue;
}
if ( is_string( $currentToken ) ) {
$resultStr .= $currentToken;
} elseif ( is_array( $currentToken ) ) {
$nextResult = self::stringifyOptionTokens( $currentToken, $prefix . $resultStr, $env );
if ( $nextResult === null ) {
return null;
}
$resultStr .= $nextResult;
} elseif ( !( $currentToken instanceof EndTagTk ) ) {
// This is actually a token
if ( TokenUtils::hasDOMFragmentType( $currentToken ) ) {
if ( self::isWikitextOpt( $env, $optInfo, $prefix, $resultStr ) ) {
$str = TokenUtils::tokensToString( [ $currentToken ], false, [
'unpackDOMFragments' => true,
'env' => $env
]
);
// Entity encode pipes since we wouldn't have split on
// them from fragments and we're about to attempt to
// when this function returns.
// This is similar to getting the shadow "href" below.
// FIXME: Sneaking in `env` to avoid changing the signature
$resultStr .= preg_replace( '/\|/', '|', $str, 1 );
$optInfo = null; // might change the nature of opt
continue;
} else {
// if this is a nowiki, we must be in a caption
return null;
}
}
if ( $currentToken->getName() === 'mw-quote' ) {
if ( self::isWikitextOpt( $env, $optInfo, $prefix, $resultStr ) ) {
// just recurse inside
$optInfo = null; // might change the nature of opt
continue;
}
}
// Similar to TokenUtils.tokensToString()'s includeEntities
if ( TokenUtils::isEntitySpanToken( $currentToken ) ) {
$resultStr .= $currentToken->dataAttribs->src;
$skipToEndOf = 'span';
continue;
}
if ( $currentToken->getName() === 'a' ) {
if ( $optInfo === null ) {
$optInfo = self::getOptionInfo( $prefix . $resultStr, $env );
if ( $optInfo === null ) {
// An
tag before a valid option?
// This is most likely a caption.
$optInfo = null;
return null;
}
}
if ( self::isWikitextOpt( $env, $optInfo, $prefix, $resultStr ) ) {
$tokenType = $currentToken->getAttribute( 'rel' );
// Using the shadow since entities (think pipes) would
// have already been decoded.
$tkHref = $currentToken->getAttributeShadowInfo( 'href' )['value'];
$isLink = $optInfo && $optInfo['ck'] === 'link';
// Reset the optInfo since we're changing the nature of it
$optInfo = null;
// Figure out the proper string to put here and break.
if (
$tokenType === 'mw:ExtLink' &&
( $currentToken->dataAttribs->stx ?? '' ) === 'url'
) {
// Add the URL
$resultStr .= $tkHref;
// Tell our loop to skip to the end of this tag
$skipToEndOf = 'a';
} elseif ( $tokenType === 'mw:WikiLink/Interwiki' ) {
if ( $isLink ) {
$resultStr .= $currentToken->getAttribute( 'href' );
$i += 2;
continue;
}
// Nothing to do -- the link content will be
// captured by walking the rest of the tokens.
} elseif ( $tokenType === 'mw:WikiLink' || $tokenType === 'mw:MediaLink' ) {
// Nothing to do -- the link content will be
// captured by walking the rest of the tokens.
} else {
// There shouldn't be any other kind of link...
// This is likely a caption.
return null;
}
} else {
// Why would there be an a tag without a link?
return null;
}
}
}
}
return $resultStr;
}
/**
* Get the format for media.
*
* @param array $opts
* @return string|null
*/
private static function getFormat( array $opts ) {
if ( $opts['manualthumb'] ) {
return 'thumbnail';
}
return $opts['format']['v'] ?? null;
}
private $used;
/**
* This is the set of file options that apply to the container, rather
* than the media element itself (or, apply generically to a span).
* Other options depend on the fetched media type and won't necessary be
* applied.
*
* @return array
*/
private function getUsed(): array {
if ( $this->used ) {
return $this->used;
}
$this->used = PHPUtils::makeSet( [
'lang', 'width', 'class', 'upright',
'border', 'frameless', 'framed', 'thumbnail',
'left', 'right', 'center', 'none',
'baseline', 'sub', 'super', 'top', 'text_top', 'middle', 'bottom', 'text_bottom'
]
);
return $this->used;
}
/**
* @param array $toks
* @return bool
*/
private function hasTransclusion( array $toks ): bool {
foreach ( $toks as $t ) {
if (
$t instanceof SelfclosingTagTk &&
TokenUtils::hasTypeOf( $t, 'mw:Transclusion' )
) {
return true;
}
}
return false;
}
/**
* Render a file. This can be an image, a sound, a PDF etc.
*
* @param Token $token
* @param stdClass $target
* @return array
*/
private function renderFile( Token $token, stdClass $target ) {
$manager = $this->manager;
$env = $manager->env;
// FIXME: Re-enable use of media cache and figure out how that fits
// into this new processing model. See T98995
// const cachedMedia = env.mediaCache[token.dataAttribs.src];
$dataAttribs = Utils::clone( $token->dataAttribs );
$dataAttribs->optList = [];
// Account for the possibility of an expanded target
$dataMwAttr = $token->getAttribute( 'data-mw' );
$dataMw = $dataMwAttr ? PHPUtils::jsonDecode( $dataMwAttr, false ) : new stdClass;
$opts = [
'title' => [
'v' => $env->makeLink( $target->title ),
'src' => $token->getAttributeKV( 'href' )->vsrc
],
'size' => [
'v' => [
'height' => null,
'width' => null
]
],
// Initialize these properties to avoid isset checks
'caption' => null,
'format' => null,
'manualthumb' => null,
'class' => null
];
$hasExpandableOpt = false;
$optKVs = self::buildLinkAttrs( $token->attribs, true, null, null )['contentKVs'];
while ( count( $optKVs ) > 0 ) {
$oContent = array_shift( $optKVs );
Assert::invariant( $oContent instanceof KV, 'bad type' );
$origOptSrc = $oContent->v;
if ( is_array( $origOptSrc ) && count( $origOptSrc ) === 1 ) {
$origOptSrc = $origOptSrc[0];
}
$oText = TokenUtils::tokensToString( $origOptSrc, true, [ 'includeEntities' => true ] );
if ( !is_string( $oText ) ) {
// Might be that this is a valid option whose value is just
// complicated. Try to figure it out, step through all tokens.
$maybeOText = self::stringifyOptionTokens( $oText, '', $env );
if ( $maybeOText !== null ) {
$oText = $maybeOText;
}
}
$optInfo = null;
if ( is_string( $oText ) ) {
if ( preg_match( '/\|/', $oText ) ) {
// Split the pipe-separated string into pieces
// and convert each one into a KV obj and add them
// to the beginning of the array. Note that this is
// a hack to support templates that provide multiple
// image options as a pipe-separated string. We aren't
// really providing editing support for this yet, or
// ever, maybe.
//
// TODO(arlolra): Tables in captions suppress breaking on
// "linkdesc" pipes so `stringifyOptionTokens` should account
// for pipes in table cell content. For the moment, breaking
// here is acceptable since it matches the php implementation
// bug for bug.
$pieces = array_map( function ( $s ) {
return new KV( 'mw:maybeContent', $s );
}, explode( '|', $oText ) );
$optKVs = array_merge( $pieces, $optKVs );
// Record the fact that we won't provide editing support for this.
$dataAttribs->uneditable = true;
continue;
} else {
// We're being overly accepting of media options at this point,
// since we don't know the type yet. After the info request,
// we'll filter out those that aren't appropriate.
$optInfo = self::getOptionInfo( $oText, $env );
}
}
// For the values of the caption and options, see
// getOptionInfo's documentation above.
//
// If there are multiple captions, this code always
// picks the last entry. This is the spec; see
// "Image with multiple captions" parserTest.
if ( !is_string( $oText ) || $optInfo === null ||
// Deprecated options
in_array( $optInfo['ck'], [ 'noicon', 'noplayer', 'disablecontrols' ], true )
) {
// No valid option found!?
// Record for RT-ing
$optsCaption = [
'v' => $oContent->v,
'src' => $oContent->vsrc ?? $oText,
'srcOffsets' => $oContent->valueOffset(),
// remember the position
'pos' => count( $dataAttribs->optList )
];
// if there was a 'caption' previously, round-trip it as a
// "bogus option".
if ( !empty( $opts['caption'] ) ) {
// Wrap the caption opt in an array since the option itself is an array!
// Without the wrapping, the splicing will flatten the value.
array_splice( $dataAttribs->optList, $opts['caption']['pos'], 0, [ [
'ck' => 'bogus',
'ak' => $opts['caption']['src']
] ]
);
$optsCaption['pos']++;
}
$opts['caption'] = $optsCaption;
continue;
}
if ( isset( $opts[$optInfo['ck']] ) ) {
// first option wins, the rest are 'bogus'
$dataAttribs->optList[] = [
'ck' => 'bogus',
'ak' => $optInfo['ak']
];
continue;
}
$opt = [
'ck' => $optInfo['v'],
'ak' => $oContent->vsrc ?? $optInfo['ak']
];
if ( $optInfo['s'] === true ) {
// Default: Simple image option
$opts[$optInfo['ck']] = [ 'v' => $optInfo['v'] ];
} else {
// Map short canonical name to the localized version used.
$opt['ck'] = $optInfo['ck'];
// The MediaWiki magic word for image dimensions is called 'width'
// for historical reasons
// Unlike other options, use last-specified width.
if ( $optInfo['ck'] === 'width' ) {
// We support a trailing 'px' here for historical reasons
// (T15500, T53628)
$maybeDim = Utils::parseMediaDimensions( $optInfo['v'] );
if ( $maybeDim !== null ) {
$opts['size']['v'] = [
'width' => Utils::validateMediaParam( $maybeDim['x'] ) ? $maybeDim['x'] : null,
'height' => array_key_exists( 'y', $maybeDim ) &&
Utils::validateMediaParam( $maybeDim['y'] ) ? $maybeDim['y'] : null
];
// Only round-trip a valid size
$opts['size']['src'] = $oContent->vsrc ?? $optInfo['ak'];
}
} else {
$opts[$optInfo['ck']] = [
'v' => $optInfo['v'],
'src' => $oContent->vsrc ?? $optInfo['ak'],
'srcOffsets' => $oContent->valueOffset(),
];
}
}
// Collect option in dataAttribs (becomes data-parsoid later on)
// for faithful serialization.
$dataAttribs->optList[] = $opt;
// Collect source wikitext for image options for possible template expansion.
$maybeOpt = !isset( self::getUsed()[$opt['ck']] );
$expOpt = null;
// Links more often than not show up as arrays here because they're
// tokenized as `autourl`. To avoid unnecessarily considering them
// expanded, we'll use a more restrictive test, at the cost of
// perhaps missing some edgy behaviour.
if ( $opt['ck'] === 'link' ) {
$expOpt = is_array( $origOptSrc ) &&
$this->hasTransclusion( $origOptSrc );
} else {
$expOpt = is_array( $origOptSrc );
}
if ( $maybeOpt || $expOpt ) {
$val = [];
if ( $expOpt ) {
$hasExpandableOpt = true;
$val['html'] = $origOptSrc;
$val['srcOffsets'] = $oContent->valueOffset();
$val = PipelineUtils::expandValueToDOM(
$env, $manager->getFrame(), $val,
$this->options['expandTemplates'],
$this->options['inTemplate']
);
}
// This is a bit of an abuse of the "txt" property since
// `optInfo.v` isn't unnecessarily wikitext from source.
// It's a result of the specialized stringifying above, which
// if interpreted as wikitext upon serialization will result
// in some (acceptable) normalization.
//
// We're storing these options in data-mw because they aren't
// guaranteed to apply to all media types and we'd like to
// avoid the need to back them out later.
//
// Note that the caption in the legacy parser depends on the
// exact set of options parsed, which we aren't attempting to
// try and replicate after fetching the media info, since we
// consider that more of bug than a feature. It prevent anyone
// from ever safely adding media options in the future.
//
// See T163582
if ( $maybeOpt ) {
$val['txt'] = $optInfo['v'];
}
if ( !isset( $dataMw->attribs ) ) {
$dataMw->attribs = [];
}
$dataMw->attribs[] = [ $opt['ck'], $val ];
}
}
// Add the last caption in the right position if there is one
if ( $opts['caption'] ) {
// Wrap the caption opt in an array since the option itself is an array!
// Without the wrapping, the splicing will flatten the value.
array_splice( $dataAttribs->optList, $opts['caption']['pos'], 0, [ [
'ck' => 'caption',
'ak' => $opts['caption']['src']
] ]
);
}
// Handle image default sizes and upright option after extracting all
// options
// @phan-suppress-next-line PhanRedundantCondition
if ( !empty( $opts['format'] ) && $opts['format']['v'] === 'framed' ) {
// width and height is ignored for framed images
// https://phabricator.wikimedia.org/T64258
$opts['size']['v'] = [ 'width' => null, 'height' => null ];
} elseif ( $opts['format'] ) {
if ( !$opts['size']['v']['height'] && !$opts['size']['v']['width'] ) {
$defaultWidth = $env->getSiteConfig()->widthOption();
if ( isset( $opts['upright'] ) ) {
// FIXME: If non-numeric, should this option be treated as a caption?
if ( is_numeric( $opts['upright']['v'] ) && $opts['upright']['v'] > 0 ) {
$defaultWidth *= $opts['upright']['v'];
} else {
$defaultWidth *= 0.75;
}
// round to nearest 10 pixels
$defaultWidth = 10 * round( $defaultWidth / 10 );
}
$opts['size']['v']['width'] = $defaultWidth;
}
}
// FIXME: Default type, since we don't have the info. That right?
$rdfaType = 'mw:Image';
// If the format is something we *recognize*, add the subtype
$format = self::getFormat( $opts );
switch ( $format ) {
case 'thumbnail':
$rdfaType .= '/Thumb';
break;
case 'framed':
$rdfaType .= '/Frame';
break;
case 'frameless':
$rdfaType .= '/Frameless';
break;
}
// Tell VE that it shouldn't try to edit this
if ( !empty( $dataAttribs->uneditable ) ) {
$rdfaType .= ' mw:Placeholder';
} else {
unset( $dataAttribs->src );
}
$wrapperInfo = self::getWrapperInfo( $opts );
$isInline = $wrapperInfo['isInline'];
$containerName = $isInline ? 'figure-inline' : 'figure';
$classes = $wrapperInfo['classes'];
if ( !empty( $opts['class'] ) ) {
$classes = array_merge( $classes, explode( ' ', $opts['class']['v'] ) );
}
$attribs = [ new KV( 'typeof', $rdfaType ) ];
if ( count( $classes ) > 0 ) {
array_unshift( $attribs, new KV( 'class', implode( ' ', $classes ) ) );
}
$container = new TagTk( $containerName, $attribs, $dataAttribs );
$containerClose = new EndTagTk( $containerName );
if ( $hasExpandableOpt ) {
$container->addAttribute( 'about', $env->newAboutId() );
$container->addSpaceSeparatedAttribute( 'typeof', 'mw:ExpandedAttrs' );
} elseif ( preg_match( '/\bmw:ExpandedAttrs\b/', $token->getAttribute( 'typeof' ) ?? '' ) ) {
$container->addSpaceSeparatedAttribute( 'typeof', 'mw:ExpandedAttrs' );
}
$span = new TagTk( 'span', [] );
// "resource" and "lang" are allowed attributes on spans
$span->addNormalizedAttribute( 'resource', $opts['title']['v'], $opts['title']['src'] );
if ( isset( $opts['lang'] ) ) {
$span->addNormalizedAttribute( 'lang', $opts['lang']['v'], $opts['lang']['src'] );
}
// Token's KV attributes only accept strings, Tokens or arrays of those.
$size = $opts['size']['v'];
if ( !empty( $size['width'] ) ) {
$span->addAttribute( 'data-width', (string)$size['width'] );
}
if ( !empty( $size['height'] ) ) {
$span->addAttribute( 'data-height', (string)$size['height'] );
}
$anchor = new TagTk( 'a' );
$filePath = Sanitizer::sanitizeTitleURI( $target->title->getKey(), false );
$anchor->setAttribute( 'href', "./Special:FilePath/{$filePath}" );
$tokens = [
$container,
$anchor,
$span,
// FIXME: The php parser seems to put the link text here instead.
// The title can go on the `anchor` as the "title" attribute.
$target->title->getPrefixedText(),
new EndTagTk( 'span' ),
new EndTagTk( 'a' )
];
$optsCaption = $opts['caption'] ?? null;
if ( $isInline ) {
if ( $optsCaption ) {
if ( !is_array( $optsCaption['v'] ) ) {
$opts['caption']['v'] = $optsCaption['v'] = [ $optsCaption['v'] ];
}
// Parse the caption
$captionDOM = PipelineUtils::processContentInPipeline(
$this->manager->env,
$this->manager->getFrame(),
array_merge( $optsCaption['v'], [ new EOFTk() ] ),
[
'pipelineType' => 'tokens/x-mediawiki/expanded',
'pipelineOpts' => [
'inlineContext' => true,
'expandTemplates' => $this->options['expandTemplates'],
'inTemplate' => $this->options['inTemplate']
],
'srcOffsets' => $optsCaption['srcOffsets'] ?? null,
'sol' => true
]
);
// Use parsed DOM given in `captionDOM`
// FIXME: Does this belong in `dataMw.attribs`?
$dataMw->caption = ContentUtils::ppToXML(
DOMCompat::getBody( $captionDOM ), [ 'innerXML' => true ] );
}
} else {
// We always add a figcaption for blocks
$tsr = $optsCaption['srcOffsets'] ?? null;
$tokens[] = new TagTk( 'figcaption', [], (object)[ 'tsr' => $tsr ] );
if ( $optsCaption ) {
if ( is_string( $optsCaption['v'] ) ) {
$tokens[] = $optsCaption['v'];
} else {
$tokens[] = PipelineUtils::getDOMFragmentToken(
$optsCaption['v'],
$tsr,
[ 'inlineContext' => true, 'token' => $token ]
);
}
}
$tokens[] = new EndTagTk( 'figcaption' );
}
if ( count( array_keys( get_object_vars( $dataMw ) ) ) ) {
$container->addAttribute( 'data-mw', PHPUtils::jsonEncode( $dataMw ) );
}
return [ 'tokens' => array_merge( $tokens, [ $containerClose ] ) ];
}
/**
* @param Token $token
* @param stdClass $target
* @param array $errs
* @param array $info
* @return array
*/
private function linkToMedia( Token $token, stdClass $target, array $errs, array $info ): array {
// Only pass in the url, since media links should not link to the thumburl
$imgHref = preg_replace( '#^https?://#', '//', $info['url'], 1 ); // Copied from getPath
$imgHrefFileName = preg_replace( '#.*/#', '', $imgHref, 1 );
$link = new TagTk( 'a', [], Utils::clone( $token->dataAttribs ) );
$link->addAttribute( 'rel', 'mw:MediaLink' );
$link->addAttribute( 'href', $imgHref );
// html2wt will use the resource rather than try to parse the href.
$link->addNormalizedAttribute(
'resource',
$this->env->makeLink( $target->title ),
$target->hrefSrc
);
// Normalize title according to how PHP parser does it currently
$link->setAttribute( 'title', preg_replace( '/_/', ' ', $imgHrefFileName ) );
unset( $link->dataAttribs->src ); // clear src string since we can serialize this
$type = $token->getAttribute( 'typeof' );
if ( $type ) {
$link->addSpaceSeparatedAttribute( 'typeof', $type );
}
if ( count( $errs ) > 0 ) {
// Set RDFa type to mw:Error so VE and other clients
// can use this to do client-specific action on these.
$link->addAttribute( 'typeof', 'mw:Error' );
// Update data-mw
$dataMwAttr = $token->getAttribute( 'data-mw' );
$dataMw = $dataMwAttr ? PHPUtils::jsonDecode( $dataMwAttr, false ) : new stdClass;
if ( is_array( $dataMw->errors ?? null ) ) {
$errs = array_merge( $dataMw->errors, $errs );
}
$dataMw->errors = $errs;
$link->addAttribute( 'data-mw', PHPUtils::jsonEncode( $dataMw ) );
}
$content = preg_replace( '/^:/', '',
TokenUtils::tokensToString( $token->getAttribute( 'href' ) ), 1 );
$content = $token->getAttribute( 'mw:maybeContent' ) ?? [ $content ];
$tokens = array_merge( [ $link ], $content, [ new EndTagTk( 'a' ) ] );
return [ 'tokens' => $tokens ];
}
// FIXME: The media request here is only used to determine if this is a
// redlink and deserves to be handling in the redlink post-processing pass.
/**
* @param Token $token
* @param stdClass $target
* @return array
*/
private function renderMedia( Token $token, stdClass $target ) {
$env = $this->manager->env;
$title = $target->title;
$errs = [];
$temp2 = AddMediaInfo::requestInfo( $env, $title->getKey(), [
'height' => null, 'width' => null
] );
$err = $temp2['err'];
if ( $err ) {
$errs[] = $err;
}
$info = $temp2['info'];
return $this->linkToMedia( $token, $target, $errs, $info );
}
/** @inheritDoc */
public function onTag( Token $token ) {
switch ( $token->getName() ) {
case 'wikilink':
return $this->onWikiLink( $token );
case 'mw:redirect':
return $this->onRedirect( $token );
default:
return $token;
}
}
}