Hooks.php

Go to the documentation of this file.

<?php
use MediaWiki\MediaWikiServices;
use UtfNormal\Validator;
use Wikimedia\PSquare;
 
class ScribuntoHooks {
 
    public static function onRegistration() {
        define( 'CONTENT_MODEL_SCRIBUNTO', 'Scribunto' );
    }
 
    public static function getSoftwareInfo( array &$software ) {
        $engine = Scribunto::newDefaultEngine();
        $engine->setTitle( Title::makeTitle( NS_SPECIAL, 'Version' ) );
        $engine->getSoftwareInfo( $software );
        return true;
    }
 
    public static function setupParserHook( Parser &$parser ) {
        $parser->setFunctionHook( 'invoke', 'ScribuntoHooks::invokeHook', Parser::SFH_OBJECT_ARGS );
        return true;
    }
 
    public static function clearState( Parser &$parser ) {
        Scribunto::resetParserEngine( $parser );
        return true;
    }
 
    public static function parserCloned( Parser $parser ) {
        $parser->scribunto_engine = null;
        return true;
    }
 
    public static function invokeHook( Parser &$parser, PPFrame $frame, array $args ) {
        global $wgScribuntoGatherFunctionStats;
 
        try {
            if ( count( $args ) < 2 ) {
                throw new ScribuntoException( 'scribunto-common-nofunction' );
            }
            $moduleName = trim( $frame->expand( $args[0] ) );
            $engine = Scribunto::getParserEngine( $parser );
 
            $title = Title::makeTitleSafe( NS_MODULE, $moduleName );
            if ( !$title || !$title->hasContentModel( CONTENT_MODEL_SCRIBUNTO ) ) {
                throw new ScribuntoException( 'scribunto-common-nosuchmodule',
                    [ 'args' => [ $moduleName ] ] );
            }
            $module = $engine->fetchModuleFromParser( $title );
            if ( !$module ) {
                throw new ScribuntoException( 'scribunto-common-nosuchmodule',
                    [ 'args' => [ $moduleName ] ] );
            }
            $functionName = trim( $frame->expand( $args[1] ) );
 
            $bits = $args[1]->splitArg();
            unset( $args[0] );
            unset( $args[1] );
 
            // If $bits['index'] is empty, then the function name was parsed as a
            // key=value pair (because of an equals sign in it), and since it didn't
            // have an index, we don't need the index offset.
            $childFrame = $frame->newChild( $args, $title, $bits['index'] === '' ? 0 : 1 );
 
            if ( $wgScribuntoGatherFunctionStats ) {
                $u0 = $engine->getResourceUsage( $engine::CPU_SECONDS );
                $result = $module->invoke( $functionName, $childFrame );
                $u1 = $engine->getResourceUsage( $engine::CPU_SECONDS );
 
                if ( $u1 > $u0 ) {
                    $timingMs = (int)( 1000 * ( $u1 - $u0 ) );
                    // Since the overhead of stats is worst when when #invoke
                    // calls are very short, don't process measurements <= 20ms.
                    if ( $timingMs > 20 ) {
                        self::reportTiming( $moduleName, $functionName, $timingMs );
                    }
                }
            } else {
                $result = $module->invoke( $functionName, $childFrame );
            }
 
            return Validator::cleanUp( strval( $result ) );
        } catch ( ScribuntoException $e ) {
            $trace = $e->getScriptTraceHtml( [ 'msgOptions' => [ 'content' ] ] );
            $html = Html::element( 'p', [], $e->getMessage() );
            if ( $trace !== false ) {
                $html .= Html::element( 'p',
                    [],
                    wfMessage( 'scribunto-common-backtrace' )->inContentLanguage()->text()
                ) . $trace;
            } else {
                $html .= Html::element( 'p',
                    [],
                    wfMessage( 'scribunto-common-no-details' )->inContentLanguage()->text()
                );
            }
            $out = $parser->getOutput();
            $errors = $out->getExtensionData( 'ScribuntoErrors' );
            if ( $errors === null ) {
                // On first hook use, set up error array and output
                $errors = [];
                $parser->addTrackingCategory( 'scribunto-common-error-category' );
                $out->addModules( 'ext.scribunto.errors' );
            }
            $errors[] = $html;
            $out->setExtensionData( 'ScribuntoErrors', $errors );
            $out->addJsConfigVars( 'ScribuntoErrors', $errors );
            $id = 'mw-scribunto-error-' . ( count( $errors ) - 1 );
            $parserError = htmlspecialchars( $e->getMessage() );
 
            // #iferror-compatible error element
            return "<strong class=\"error\"><span class=\"scribunto-error\" id=\"$id\">" .
                $parserError . "</span></strong>";
        }
    }
 
    public static function reportTiming( $moduleName, $functionName, $timing ) {
        global $wgScribuntoGatherFunctionStats, $wgScribuntoSlowFunctionThreshold;
 
        if ( !$wgScribuntoGatherFunctionStats ) {
            return;
        }
 
        $threshold = $wgScribuntoSlowFunctionThreshold;
        if ( !( is_float( $threshold ) && $threshold > 0 && $threshold < 1 ) ) {
            return;
        }
 
        static $cache;
 
        if ( !$cache ) {
            $cache = ObjectCache::getLocalServerInstance( CACHE_NONE );
 
        }
 
        // To control the sampling rate, we keep a compact histogram of
        // observations in APC, and extract the Nth percentile (specified
        // via $wgScribuntoSlowFunctionThreshold; defaults to 0.90).
        // We need APC and \Wikimedia\PSquare to do that.
        if ( !class_exists( PSquare::class ) || $cache instanceof EmptyBagOStuff ) {
            return;
        }
 
        $cacheVersion = '1';
        $key = $cache->makeGlobalKey( __METHOD__, $cacheVersion, $threshold );
 
        // This is a classic "read-update-write" critical section with no
        // mutual exclusion, but the only consequence is that some samples
        // will be dropped. We only need enough samples to estimate the
        // the shape of the data, so that's fine.
        $ps = $cache->get( $key ) ?: new PSquare( $threshold );
        $ps->addObservation( $timing );
        $cache->set( $key, $ps, 60 );
 
        if ( $ps->getCount() < 1000 || $timing < $ps->getValue() ) {
            return;
        }
 
        static $stats;
 
        if ( !$stats ) {
            $stats = MediaWikiServices::getInstance()->getStatsdDataFactory();
        }
 
        $metricKey = sprintf( 'scribunto.traces.%s__%s__%s', wfWikiId(), $moduleName, $functionName );
        $stats->timing( $metricKey, $timing );
    }
 
    public static function getCodeLanguage( Title $title, &$languageCode ) {
        global $wgScribuntoUseCodeEditor;
        if ( $wgScribuntoUseCodeEditor && $title->hasContentModel( CONTENT_MODEL_SCRIBUNTO )
        ) {
            $engine = Scribunto::newDefaultEngine();
            if ( $engine->getCodeEditorLanguage() ) {
                $languageCode = $engine->getCodeEditorLanguage();
                return false;
            }
        }
 
        return true;
    }
 
    public static function contentHandlerDefaultModelFor( Title $title, &$model ) {
        if ( $model === 'sanitized-css' ) {
            // Let TemplateStyles override Scribunto
            return true;
        }
        if ( $title->getNamespace() == NS_MODULE && !Scribunto::isDocPage( $title ) ) {
            $model = CONTENT_MODEL_SCRIBUNTO;
            return true;
        }
        return true;
    }
 
    public static function reportLimitData( Parser $parser, ParserOutput $output ) {
        if ( Scribunto::isParserEnginePresent( $parser ) ) {
            $engine = Scribunto::getParserEngine( $parser );
            $engine->reportLimitData( $output );
        }
        return true;
    }
 
    public static function formatLimitData( $key, &$value, &$report, $isHTML, $localize ) {
        $engine = Scribunto::newDefaultEngine();
        return $engine->formatLimitData( $key, $value, $report, $isHTML, $localize );
    }
 
    public static function showStandardInputsOptions( EditPage $editor, OutputPage $output, &$tab ) {
        if ( $editor->getTitle()->hasContentModel( CONTENT_MODEL_SCRIBUNTO ) ) {
            $output->addModules( 'ext.scribunto.edit' );
            $editor->editFormTextAfterTools .= '<div id="mw-scribunto-console"></div>';
        }
        return true;
    }
 
    public static function showReadOnlyFormInitial( EditPage $editor, OutputPage $output ) {
        if ( $editor->getTitle()->hasContentModel( CONTENT_MODEL_SCRIBUNTO ) ) {
            $output->addModules( 'ext.scribunto.edit' );
            $editor->editFormTextAfterContent .= '<div id="mw-scribunto-console"></div>';
        }
        return true;
    }
 
    public static function beforeEditButtons( EditPage &$editor, array &$buttons, &$tabindex ) {
        if ( $editor->getTitle()->hasContentModel( CONTENT_MODEL_SCRIBUNTO ) ) {
            unset( $buttons['preview'] );
        }
        return true;
    }
 
    public static function validateScript( IContextSource $context, Content $content,
        Status $status
    ) {
        $title = $context->getTitle();
 
        if ( !$content instanceof ScribuntoContent ) {
            return true;
        }
 
        $validateStatus = $content->validate( $title );
        if ( $validateStatus->isOK() ) {
            return true;
        }
 
        $status->merge( $validateStatus );
 
        if ( isset( $validateStatus->scribunto_error->params['module'] ) ) {
            $module = $validateStatus->scribunto_error->params['module'];
            $line = $validateStatus->scribunto_error->params['line'];
            if ( $module === $title->getPrefixedDBkey() && preg_match( '/^\d+$/', $line ) ) {
                $out = $context->getOutput();
                $out->addInlineScript( 'window.location.hash = ' . Xml::encodeJsVar( "#mw-ce-l$line" ) );
            }
        }
 
        return true;
    }
 
    public static function showDocPageHeader( Article &$article, &$outputDone, &$pcache ) {
        $title = $article->getTitle();
        if ( Scribunto::isDocPage( $title, $forModule ) ) {
            $article->getContext()->getOutput()->addHTML(
                wfMessage( 'scribunto-doc-page-header', $forModule->getPrefixedText() )->parseAsBlock()
            );
        }
        return true;
    }
}