226 lines
7.5 KiB
PHP
226 lines
7.5 KiB
PHP
<?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 = [];
|
|
}
|
|
|
|
}
|