| Server IP : 167.235.224.122 / Your IP : 216.73.216.110 Web Server : Apache/2.4.58 (Ubuntu) System : Linux newplayground 6.8.0-136-generic #136-Ubuntu SMP PREEMPT_DYNAMIC Wed Jul 1 21:33:11 UTC 2026 aarch64 User : deploy ( 1000) PHP Version : 8.4.23 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /var/www/html/wiki/extensions/SemanticMediaWiki/includes/ |
Upload File : |
<?php
use MediaWiki\Output\OutputPage;
use MediaWiki\Parser\Parser;
use MediaWiki\Parser\ParserOutput;
/**
* This class attempts to provide safe yet simple means for managing data that is relevant
* for the final HTML output of MediaWiki. In particular, this concerns additions to the HTML
* header in the form of scripts of stylesheets.
*
* The problem is that many components in SMW create hypertext that should eventually be displayed.
* The normal way of accessing such text are functions of the form getText() which return a
* (hypertext) string. Such a string, however, might refer to styles or scripts that are also
* needed. It is not possible to directly add those scripts to the MediaWiki output, since the form
* of this output depends on the context in which the function is called. Many functions might be
* called both during parsing and directly in special pages that do not use the usual parsing and
* caching mechanisms.
*
* Ideally, all functions that generate hypertext with dependencies would also include parameters to
* record required scripts. Since this would require major API changes, the current solution is to have
* a "temporal" global storage for the required items, managed in this class. It is not safe to use
* such a global store across hooks -- you never know what happens in between! Hence, every function
* that creates SMW outputs that may require head items must afterwards clear the temporal store by
* writing its contents to the according output.
*
* @ingroup SMW
*
* @author Markus Krötzsch
*/
class SMWOutputs {
/**
* Protected member for temporarily storing header items.
* Format $id => $headItem where $id is used only to avoid duplicate
* items in the time before they are forwarded to the output.
*/
protected static $headItems = [];
/**
* Protected member for temporarily storing additional Javascript
* snippets. Format $id => $scriptText where $id is used only to
* avoid duplicate scripts in the time before they are forwarded
* to the output.
*/
protected static $scripts = [];
/**
* Protected member for temporarily storing resource modules.
*
* @var array
*/
protected static $resourceModules = [];
/**
* Protected member for temporarily storing resource modules.
*
* @var array
*/
protected static $resourceStyles = [];
/**
* Adds a resource module to the parser output.
*
* @since 1.5.3
*
* @param string $moduleName
*/
public static function requireResource( $moduleName ) {
self::$resourceModules[$moduleName] = $moduleName;
}
/**
* @since 3.0
*
* @param string $stylesName
*/
public static function requireStyle( $stylesName ) {
self::$resourceStyles[$stylesName] = $stylesName;
}
/**
* Require the presence of header scripts, provided as strings with
* enclosing script tags. Note that the same could be achieved with
* requireHeadItems, but scripts use a special method "addScript" in
* MediaWiki OutputPage, hence we distinguish them.
*
* The id is used to avoid that the requirement for one script is
* recorded multiple times in SMWOutputs.
*
* @param string $id
* @param string $script
*/
public static function requireScript( $id, $script ) {
self::$scripts[$id] = $script;
}
/**
* Adds head items that are not Resource Loader modules. Should only
* be used for custom head items such as RSS fedd links.
*
* The id is used to avoid that the requirement for one script is
* recorded multiple times in SMWOutputs.
*
* Support for calling this with the old constants SMW_HEADER_STYLE
* and SMW_HEADER_TOOLTIP will vanish in SMW 1.7 at the latest.
*
* @param mixed $id
* @param string $item
*/
public static function requireHeadItem( $id, $item = '' ) {
if ( is_numeric( $id ) ) {
switch ( $id ) {
case SMW_HEADER_TOOLTIP:
self::requireStyle( 'ext.smw.styles' );
self::requireStyle( 'ext.smw.tooltip.styles' );
self::requireResource( 'ext.smw.tooltip' );
break;
case SMW_HEADER_STYLE:
self::requireStyle( 'ext.smw.styles' );
break;
}
} else {
self::$headItems[$id] = $item;
}
}
/**
* This function takes output requirements as can be found in a given ParserOutput
* object and puts them back in to the internal temporal requirement list from
* which they can be committed to some other output. It is needed when code that
* would normally call SMWOutputs::requireHeadItem() has need to use a full
* independent parser call (Parser::parse()) that produces its own parseroutput.
* If omitted, all output items potentially committed to this parseroutput during
* parsing will not be passed on to higher levels.
*
* Note that this is not required if the $parseroutput is further processed by
* MediaWiki, but there are cases where the output is discarded and only its text
* is used.
*
* @param ParserOutput $parserOutput
*/
public static function requireFromParserOutput( ParserOutput $parserOutput ) {
// Note: we do not attempt to recover which head items where scripts here.
$parserOutputHeadItems = $parserOutput->getHeadItems();
self::$headItems = array_merge( (array)self::$headItems, $parserOutputHeadItems );
/// TODO Is the following needed?
if ( $parserOutput->getModules() ) {
foreach ( $parserOutput->getModules() as $module ) {
self::$resourceModules[$module] = $module;
}
}
}
/**
* Actually commit the collected requirements to a given parser that is about to parse
* what will later be the HTML output. This makes sure that HTML output based on the
* parser results contains all required output items.
*
* If the parser creates output for a normal wiki page, then the committed items will
* also become part of the page cache so that they will correctly be added to all page
* outputs built from this cache later on.
*
* @param Parser $parser
*/
public static function commitToParser( Parser $parser ) {
$po = $parser->getOutput();
if ( isset( $po ) ) {
self::commitToParserOutput( $po );
}
}
/**
* Similar to SMWOutputs::commitToParser() but acting on a ParserOutput object.
*
* @param ParserOutput $parserOutput
*/
public static function commitToParserOutput( ParserOutput $parserOutput ) {
foreach ( self::$scripts as $key => $script ) {
$parserOutput->addHeadItem( $script . "\n", $key );
}
foreach ( self::$headItems as $key => $item ) {
$parserOutput->addHeadItem( "\t\t" . $item . "\n", $key );
}
$parserOutput->addModuleStyles( array_values( self::$resourceStyles ) );
$parserOutput->addModules( array_values( self::$resourceModules ) );
self::$resourceStyles = [];
self::$resourceModules = [];
self::$headItems = [];
}
/**
* Actually commit the collected requirements to a given OutputPage object that
* will later generate the HTML output. This makes sure that HTML output contains
* all required output items. Note that there is no parser caching at this level of
* processing. In particular, data should not be committed to $wgOut in methods
* that run during page parsing, since these would not run next time when the page
* is produced from parser cache.
*
* @param OutputPage $output
*/
public static function commitToOutputPage( OutputPage $output ) {
foreach ( self::$scripts as $script ) {
$output->addScript( $script );
}
foreach ( self::$headItems as $key => $item ) {
$output->addHeadItem( $key, "\t\t" . $item . "\n" );
}
$output->addModuleStyles( array_values( self::$resourceStyles ) );
$output->addModules( array_values( self::$resourceModules ) );
self::$resourceStyles = [];
self::$resourceModules = [];
self::$headItems = [];
}
}