mirror of
https://gerrit.wikimedia.org/r/mediawiki/extensions/SyntaxHighlight_GeSHi
synced 2024-11-15 18:49:22 +00:00
58c81408f5
Style modules currently added through addModuleStyles default
to being in the head ("top" position). This is an unhealthy default,
since only critical styles that are needed at pageload should be
in the head. In order to be able to switch the default to "bottom",
existing module positions have to be defined explicitly.
Bug: T97410
Change-Id: Ie120a781ac1950abd7963d6f722aa316b5542b51
564 lines
16 KiB
PHP
564 lines
16 KiB
PHP
<?php
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
|
|
class SyntaxHighlight_GeSHi {
|
|
/**
|
|
* Has GeSHi been initialised this session?
|
|
*/
|
|
private static $initialised = false;
|
|
|
|
/**
|
|
* List of languages available to GeSHi
|
|
* @var array
|
|
*/
|
|
private static $languages = null;
|
|
|
|
/**
|
|
* Executed after processing extension.json
|
|
* @todo we should figure out how to make this a real config setting.
|
|
*/
|
|
public static function registerExtension() {
|
|
global $wgVersion;
|
|
if ( version_compare( $wgVersion, '1.25', '<' ) ) {
|
|
die( 'This version of SyntaxHighlight GeSHi requires MediaWiki 1.25' );
|
|
}
|
|
|
|
global $wgGeSHiSupportedLanguages;
|
|
if ( !$wgGeSHiSupportedLanguages ) {
|
|
// If not set already, load it (@see ExtensionRegistry::exportExtractedData)
|
|
require_once __DIR__ . '/SyntaxHighlight_GeSHi.langs.php';
|
|
}
|
|
// @fixme we shouldn't be loading this on every request
|
|
require_once __DIR__ . '/geshi/geshi.php';
|
|
}
|
|
|
|
/**
|
|
* Register parser hook
|
|
*
|
|
* @param $parser Parser
|
|
* @return bool
|
|
*/
|
|
public static function configureParser( &$parser ) {
|
|
$parser->setHook( 'source', array( 'SyntaxHighlight_GeSHi', 'parserHook' ) );
|
|
$parser->setHook( 'syntaxhighlight', array( 'SyntaxHighlight_GeSHi', 'parserHook' ) );
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Parser hook
|
|
*
|
|
* @param string $text
|
|
* @param array $args
|
|
* @param Parser $parser
|
|
* @return string
|
|
*/
|
|
public static function parserHook( $text, $args = array(), $parser ) {
|
|
global $wgSyntaxHighlightDefaultLang, $wgUseTidy;
|
|
self::initialise();
|
|
$text = rtrim( $text );
|
|
// Don't trim leading spaces away, just the linefeeds
|
|
$text = preg_replace( '/^\n+/', '', $text );
|
|
|
|
// Validate language
|
|
if ( isset( $args['lang'] ) && $args['lang'] ) {
|
|
$lang = $args['lang'];
|
|
} else {
|
|
// language is not specified. Check if default exists, if yes, use it.
|
|
if ( !is_null( $wgSyntaxHighlightDefaultLang ) ) {
|
|
$lang = $wgSyntaxHighlightDefaultLang;
|
|
} else {
|
|
$error = self::formatLanguageError( $text );
|
|
return $error;
|
|
}
|
|
}
|
|
$lang = strtolower( $lang );
|
|
if ( !preg_match( '/^[a-z_0-9-]*$/', $lang ) ) {
|
|
$error = self::formatLanguageError( $text );
|
|
return $error;
|
|
}
|
|
$geshi = self::prepare( $text, $lang );
|
|
if ( !$geshi instanceof GeSHi ) {
|
|
$error = self::formatLanguageError( $text );
|
|
return $error;
|
|
}
|
|
|
|
$enclose = self::getEncloseType( $args );
|
|
|
|
// Line numbers
|
|
if ( isset( $args['line'] ) ) {
|
|
$geshi->enable_line_numbers( GESHI_FANCY_LINE_NUMBERS );
|
|
}
|
|
// Highlighting specific lines
|
|
if ( isset( $args['highlight'] ) ) {
|
|
$lines = self::parseHighlightLines( $args['highlight'] );
|
|
if ( count( $lines ) ) {
|
|
$geshi->highlight_lines_extra( $lines );
|
|
}
|
|
}
|
|
// Starting line number
|
|
if ( isset( $args['start'] ) ) {
|
|
$geshi->start_line_numbers_at( $args['start'] );
|
|
}
|
|
$geshi->set_header_type( $enclose );
|
|
// Strict mode
|
|
if ( isset( $args['strict'] ) ) {
|
|
$geshi->enable_strict_mode();
|
|
}
|
|
// Format
|
|
$out = $geshi->parse_code();
|
|
if ( $geshi->error == GESHI_ERROR_NO_SUCH_LANG ) {
|
|
// Common error :D
|
|
$error = self::formatLanguageError( $text );
|
|
return $error;
|
|
}
|
|
$err = $geshi->error();
|
|
if ( $err ) {
|
|
// Other unknown error!
|
|
$error = self::formatError( $err );
|
|
return $error;
|
|
}
|
|
// Armour for Parser::doBlockLevels()
|
|
if ( $enclose === GESHI_HEADER_DIV ) {
|
|
$out = str_replace( "\n", '', $out );
|
|
}
|
|
// HTML Tidy will convert tabs to spaces incorrectly (bug 30930).
|
|
// But the conversion from tab to space occurs while reading the input,
|
|
// before the conversion from 	 to tab, so we can armor it that way.
|
|
if ( $wgUseTidy ) {
|
|
$out = str_replace( "\t", '	', $out );
|
|
}
|
|
// Register CSS
|
|
$parser->getOutput()->addModuleStyles( array( "ext.geshi.language.$lang", 'ext.geshi.local' ) );
|
|
|
|
$encloseTag = $enclose === GESHI_HEADER_NONE ? 'span' : 'div';
|
|
$attribs = Sanitizer::validateTagAttributes( $args, $encloseTag );
|
|
|
|
//lang is valid in HTML context, but also used on GeSHi
|
|
unset( $attribs['lang'] );
|
|
|
|
if ( $enclose === GESHI_HEADER_NONE ) {
|
|
$attribs = self::addAttribute( $attribs, 'class', 'mw-geshi ' . $lang . ' source-' . $lang );
|
|
} else {
|
|
// Default dir="ltr" (but allow dir="rtl", although unsure if needed)
|
|
$attribs['dir'] = isset( $attribs['dir'] ) && $attribs['dir'] === 'rtl' ? 'rtl' : 'ltr';
|
|
$attribs = self::addAttribute( $attribs, 'class', 'mw-geshi mw-code mw-content-' . $attribs['dir'] );
|
|
}
|
|
$out = Html::rawElement( $encloseTag, $attribs, $out );
|
|
|
|
return $out;
|
|
}
|
|
|
|
/**
|
|
* @param $attribs array
|
|
* @param $name string
|
|
* @param $value string
|
|
* @return array
|
|
*/
|
|
private static function addAttribute( $attribs, $name, $value ) {
|
|
if ( isset( $attribs[$name] ) ) {
|
|
$attribs[$name] = $value . ' ' . $attribs[$name];
|
|
} else {
|
|
$attribs[$name] = $value;
|
|
}
|
|
return $attribs;
|
|
}
|
|
|
|
/**
|
|
* Take an input specifying a list of lines to highlight, returning
|
|
* a raw list of matching line numbers.
|
|
*
|
|
* Input is comma-separated list of lines or line ranges.
|
|
*
|
|
* @param $arg string
|
|
* @return array of ints
|
|
*/
|
|
protected static function parseHighlightLines( $arg ) {
|
|
$lines = array();
|
|
$values = array_map( 'trim', explode( ',', $arg ) );
|
|
foreach ( $values as $value ) {
|
|
if ( ctype_digit($value) ) {
|
|
$lines[] = (int) $value;
|
|
} elseif ( strpos( $value, '-' ) !== false ) {
|
|
list( $start, $end ) = array_map( 'trim', explode( '-', $value ) );
|
|
if ( self::validHighlightRange( $start, $end ) ) {
|
|
for ($i = intval( $start ); $i <= $end; $i++ ) {
|
|
$lines[] = $i;
|
|
}
|
|
} else {
|
|
wfDebugLog( 'geshi', "Invalid range: $value\n" );
|
|
}
|
|
} else {
|
|
wfDebugLog( 'geshi', "Invalid line: $value\n" );
|
|
}
|
|
}
|
|
return $lines;
|
|
}
|
|
|
|
/**
|
|
* Validate a provided input range
|
|
* @param $start
|
|
* @param $end
|
|
* @return bool
|
|
*/
|
|
protected static function validHighlightRange( $start, $end ) {
|
|
// Since we're taking this tiny range and producing a an
|
|
// array of every integer between them, it would be trivial
|
|
// to DoS the system by asking for a huge range.
|
|
// Impose an arbitrary limit on the number of lines in a
|
|
// given range to reduce the impact.
|
|
$arbitrarilyLargeConstant = 10000;
|
|
return
|
|
ctype_digit($start) &&
|
|
ctype_digit($end) &&
|
|
$start > 0 &&
|
|
$start < $end &&
|
|
$end - $start < $arbitrarilyLargeConstant;
|
|
}
|
|
|
|
/**
|
|
* @param $args array
|
|
* @return int
|
|
*/
|
|
static function getEncloseType( $args ) {
|
|
// "Enclose" parameter
|
|
$enclose = GESHI_HEADER_PRE_VALID;
|
|
if ( isset( $args['enclose'] ) ) {
|
|
if ( $args['enclose'] === 'div' ) {
|
|
$enclose = GESHI_HEADER_DIV;
|
|
} elseif ( $args['enclose'] === 'none' ) {
|
|
$enclose = GESHI_HEADER_NONE;
|
|
}
|
|
}
|
|
|
|
return $enclose;
|
|
}
|
|
|
|
/**
|
|
* Hook into Content::getParserOutput to provide syntax highlighting for
|
|
* script content.
|
|
*
|
|
* @return bool
|
|
* @since MW 1.21
|
|
*/
|
|
public static function renderHook( Content $content, Title $title,
|
|
$revId, ParserOptions $options, $generateHtml, ParserOutput &$output
|
|
) {
|
|
|
|
global $wgSyntaxHighlightModels, $wgUseSiteCss,
|
|
$wgParser, $wgTextModelsToParse;
|
|
|
|
$highlightModels = ExtensionRegistry::getInstance()->getAttribute( 'SyntaxHighlightModels' );
|
|
|
|
// Determine the language
|
|
$model = $content->getModel();
|
|
if ( !isset( $highlightModels[$model] ) && !isset( $wgSyntaxHighlightModels[$model] ) ) {
|
|
// We don't care about this model, carry on.
|
|
return true;
|
|
}
|
|
|
|
if ( !$generateHtml ) {
|
|
// Nothing special for us to do, let MediaWiki handle this.
|
|
return true;
|
|
}
|
|
|
|
// Hope that $wgSyntaxHighlightModels does not contain silly types.
|
|
$text = ContentHandler::getContentText( $content );
|
|
|
|
if ( $text === null || $text === false ) {
|
|
// Oops! Non-text content? Let MediaWiki handle this.
|
|
return true;
|
|
}
|
|
|
|
// Parse using the standard parser to get links etc. into the database, HTML is replaced below.
|
|
// We could do this using $content->fillParserOutput(), but alas it is 'protected'.
|
|
if ( $content instanceof TextContent && in_array( $model, $wgTextModelsToParse ) ) {
|
|
$output = $wgParser->parse( $text, $title, $options, true, true, $revId );
|
|
}
|
|
|
|
if ( isset( $highlightModels[$model] ) ) {
|
|
$lang = $highlightModels[$model];
|
|
} else {
|
|
// TODO: Add deprecation warning after a while?
|
|
$lang = $wgSyntaxHighlightModels[$model];
|
|
}
|
|
|
|
|
|
// Attempt to format
|
|
$geshi = self::prepare( $text, $lang );
|
|
if ( $geshi instanceof GeSHi ) {
|
|
|
|
$out = $geshi->parse_code();
|
|
if ( !$geshi->error() ) {
|
|
// Done
|
|
$output->addModuleStyles( "ext.geshi.language.$lang" );
|
|
$output->setText( "<div dir=\"ltr\">{$out}</div>" );
|
|
|
|
if ( $wgUseSiteCss ) {
|
|
$output->addModuleStyles( 'ext.geshi.local' );
|
|
}
|
|
|
|
// Inform MediaWiki that we have parsed this page and it shouldn't mess with it.
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Bottle out
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Hook to provide syntax highlighting for API pretty-printed output
|
|
*
|
|
* @param IContextSource $context
|
|
* @param string $text
|
|
* @param string $mime
|
|
* @param string $format
|
|
* @since MW 1.24
|
|
*/
|
|
public static function apiFormatHighlight( IContextSource $context, $text, $mime, $format ) {
|
|
switch ( $mime ) {
|
|
case 'text/javascript':
|
|
case 'application/json':
|
|
$lang = 'javascript';
|
|
break;
|
|
|
|
case 'text/xml':
|
|
$lang = 'xml';
|
|
break;
|
|
|
|
default:
|
|
// Don't know how to handle this
|
|
return true;
|
|
}
|
|
|
|
$geshi = self::prepare( $text, $lang );
|
|
if ( $geshi instanceof GeSHi ) {
|
|
$out = $geshi->parse_code();
|
|
if ( !$geshi->error() ) {
|
|
if ( preg_match( '/^<pre([^>]*)>/i', $out, $m ) ) {
|
|
$attrs = Sanitizer::decodeTagAttributes( $m[1] );
|
|
$attrs['class'] .= ' api-pretty-content';
|
|
$out = '<pre' . Sanitizer::safeEncodeTagAttributes( $attrs ) . '>' .
|
|
substr( $out, strlen( $m[0] ) );
|
|
}
|
|
$output = $context->getOutput();
|
|
$output->addModuleStyles( array( "ext.geshi.language.$lang", 'ext.geshi.local' ) );
|
|
$output->addHTML( "<div dir=\"ltr\">{$out}</div>" );
|
|
|
|
// Inform MediaWiki that we have parsed this page and it shouldn't mess with it.
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Bottle out
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Initialise a GeSHi object to format some code, performing
|
|
* common setup for all our uses of it
|
|
*
|
|
* @param string $text
|
|
* @param string $lang
|
|
* @return GeSHi
|
|
*/
|
|
public static function prepare( $text, $lang ) {
|
|
|
|
global $wgSyntaxHighlightKeywordLinks;
|
|
|
|
self::initialise();
|
|
$geshi = new GeSHi( $text, $lang );
|
|
if ( $geshi->error() == GESHI_ERROR_NO_SUCH_LANG ) {
|
|
return null;
|
|
}
|
|
$geshi->set_encoding( 'UTF-8' );
|
|
$geshi->enable_classes();
|
|
$geshi->set_overall_class( "source-$lang" );
|
|
$geshi->enable_keyword_links( $wgSyntaxHighlightKeywordLinks );
|
|
|
|
// If the source code is over 100 kB, disable higlighting of symbols.
|
|
// If over 200 kB, disable highlighting of strings too.
|
|
$bytes = strlen( $text );
|
|
if ( $bytes > 102400 ) {
|
|
$geshi->set_symbols_highlighting( false );
|
|
if ( $bytes > 204800 ) {
|
|
$geshi->set_strings_highlighting( false );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* GeSHi comes by default with a font-family set to monospace, which
|
|
* causes the font-size to be smaller than one would expect.
|
|
* We append a CSS hack to the default GeSHi styles: specifying 'monospace'
|
|
* twice "resets" the browser font-size specified for monospace.
|
|
*
|
|
* The hack is documented in MediaWiki core under
|
|
* docs/uidesign/monospace.html and in bug 33496.
|
|
*/
|
|
// Preserve default since we don't want to override the other style
|
|
// properties set by geshi (padding, font-size, vertical-align etc.)
|
|
$geshi->set_code_style(
|
|
'font-family: monospace, monospace;',
|
|
/* preserve defaults = */ true
|
|
);
|
|
|
|
// No need to preserve default (which is just "font-family: monospace;")
|
|
// outputting both is unnecessary
|
|
$geshi->set_overall_style(
|
|
'font-family: monospace, monospace;',
|
|
/* preserve defaults = */ false
|
|
);
|
|
|
|
return $geshi;
|
|
}
|
|
|
|
/**
|
|
* Prepare a CSS snippet suitable for use as a ParserOutput/OutputPage
|
|
* head item.
|
|
*
|
|
* Not used anymore, kept for backwards-compatibility with other extensions.
|
|
*
|
|
* @deprecated
|
|
* @param GeSHi $geshi
|
|
* @return string
|
|
*/
|
|
public static function buildHeadItem( $geshi ) {
|
|
wfDeprecated( __METHOD__ );
|
|
$css = array();
|
|
$css[] = '<style type="text/css">/*<![CDATA[*/';
|
|
$css[] = self::getCSS( $geshi );
|
|
$css[] = '/*]]>*/';
|
|
$css[] = '</style>';
|
|
return implode( "\n", $css );
|
|
}
|
|
|
|
/**
|
|
* Get the complete CSS code necessary to display styles for given GeSHi instance.
|
|
*
|
|
* @param GeSHi $geshi
|
|
* @return string
|
|
*/
|
|
public static function getCSS( $geshi ) {
|
|
$lang = $geshi->language;
|
|
$css = array();
|
|
$css[] = ".source-$lang {line-height: normal;}";
|
|
$css[] = ".source-$lang li, .source-$lang pre {";
|
|
$css[] = "\tline-height: normal; border: 0px none white;";
|
|
$css[] = "}";
|
|
$css[] = $geshi->get_stylesheet( /*$economy_mode*/ false );
|
|
return implode( "\n", $css );
|
|
}
|
|
|
|
/**
|
|
* Format an 'unknown language' error message and append formatted
|
|
* plain text to it.
|
|
*
|
|
* @param string $text
|
|
* @return string HTML fragment
|
|
*/
|
|
private static function formatLanguageError( $text ) {
|
|
$msg = wfMessage( 'syntaxhighlight-err-language' )->inContentLanguage()->escaped();
|
|
$error = self::formatError( $msg, $text );
|
|
return $error . '<pre>' . htmlspecialchars( $text ) . '</pre>';
|
|
}
|
|
|
|
/**
|
|
* Format an error message
|
|
*
|
|
* @param string $error
|
|
* @return string
|
|
*/
|
|
private static function formatError( $error = '' ) {
|
|
$html = '';
|
|
if ( $error ) {
|
|
$html .= "<p>{$error}</p>";
|
|
}
|
|
$html .= '<p>' . wfMessage( 'syntaxhighlight-specify')->inContentLanguage()->escaped()
|
|
. ' <samp><source lang="html4strict">...</source></samp></p>'
|
|
. '<p>' . wfMessage( 'syntaxhighlight-supported' )->inContentLanguage()->escaped()
|
|
. '</p>' . self::formatLanguages();
|
|
return "<div style=\"border: solid red 1px; padding: .5em;\">{$html}</div>";
|
|
}
|
|
|
|
/**
|
|
* Format the list of supported languages
|
|
*
|
|
* @return string
|
|
*/
|
|
private static function formatLanguages() {
|
|
$langs = self::getSupportedLanguages();
|
|
$list = array();
|
|
if ( count( $langs ) > 0 ) {
|
|
foreach ( $langs as $lang ) {
|
|
$list[] = '<samp>' . htmlspecialchars( $lang ) . '</samp>';
|
|
}
|
|
return '<p class="mw-collapsible mw-collapsed" style="padding: 0em 1em;">' . implode( ', ', $list ) . '</p><br style="clear: all"/>';
|
|
} else {
|
|
return '<p>' . wfMessage( 'syntaxhighlight-err-loading' )->inContentLanguage()->escaped() . '</p>';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the list of supported languages
|
|
*
|
|
* @return array
|
|
*/
|
|
private static function getSupportedLanguages() {
|
|
global $wgGeSHiSupportedLanguages;
|
|
self::initialise();
|
|
return $wgGeSHiSupportedLanguages;
|
|
}
|
|
|
|
/**
|
|
* Initialise messages and ensure the GeSHi class is loaded
|
|
* @return bool
|
|
*/
|
|
private static function initialise() {
|
|
if ( !self::$initialised ) {
|
|
if ( !class_exists( 'GeSHi' ) ) {
|
|
require ( dirname( __FILE__ ) . '/geshi/geshi.php' );
|
|
}
|
|
self::$initialised = true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Register a ResourceLoader module providing styles for each supported language.
|
|
*
|
|
* @param ResourceLoader $resourceLoader
|
|
* @return bool true
|
|
*/
|
|
public static function resourceLoaderRegisterModules( &$resourceLoader ) {
|
|
$modules = array();
|
|
|
|
foreach ( self::getSupportedLanguages() as $lang ) {
|
|
$modules["ext.geshi.language.$lang" ] = array(
|
|
'position' => 'top',
|
|
'class' => 'ResourceLoaderGeSHiModule',
|
|
'lang' => $lang,
|
|
);
|
|
}
|
|
|
|
$resourceLoader->register( $modules );
|
|
|
|
return true;
|
|
}
|
|
}
|