ExtensionProcessor.php

Go to the documentation of this file.

<?php
 
class ExtensionProcessor implements Processor {
 
    protected static $globalSettings = [
        'ActionFilteredLogs',
        'Actions',
        'AddGroups',
        'APIFormatModules',
        'APIListModules',
        'APIMetaModules',
        'APIModules',
        'APIPropModules',
        'AuthManagerAutoConfig',
        'AvailableRights',
        'CentralIdLookupProviders',
        'ChangeCredentialsBlacklist',
        'ConfigRegistry',
        'ContentHandlers',
        'DefaultUserOptions',
        'ExtensionEntryPointListFiles',
        'ExtensionFunctions',
        'FeedClasses',
        'FileExtensions',
        'FilterLogTypes',
        'GrantPermissionGroups',
        'GrantPermissions',
        'GroupPermissions',
        'GroupsAddToSelf',
        'GroupsRemoveFromSelf',
        'HiddenPrefs',
        'ImplicitGroups',
        'JobClasses',
        'LogActions',
        'LogActionsHandlers',
        'LogHeaders',
        'LogNames',
        'LogRestrictions',
        'LogTypes',
        'MediaHandlers',
        'PasswordPolicy',
        'RateLimits',
        'RawHtmlMessages',
        'ReauthenticateTime',
        'RecentChangesFlags',
        'RemoveCredentialsBlacklist',
        'RemoveGroups',
        'ResourceLoaderSources',
        'RevokePermissions',
        'SessionProviders',
        'SpecialPages',
        'ValidSkinNames',
    ];
 
    protected const CORE_ATTRIBS = [
        'ParsoidModules',
        'RestRoutes',
        'SkinOOUIThemes',
        'SearchMappings',
        'TrackingCategories',
    ];
 
    protected const MERGE_STRATEGIES = [
        'wgAuthManagerAutoConfig' => 'array_plus_2d',
        'wgCapitalLinkOverrides' => 'array_plus',
        'wgExtraGenderNamespaces' => 'array_plus',
        'wgGrantPermissions' => 'array_plus_2d',
        'wgGroupPermissions' => 'array_plus_2d',
        'wgHooks' => 'array_merge_recursive',
        'wgNamespaceContentModels' => 'array_plus',
        'wgNamespaceProtection' => 'array_plus',
        'wgNamespacesWithSubpages' => 'array_plus',
        'wgPasswordPolicy' => 'array_merge_recursive',
        'wgRateLimits' => 'array_plus_2d',
        'wgRevokePermissions' => 'array_plus_2d',
    ];
 
    protected const CREDIT_ATTRIBS = [
        'type',
        'author',
        'description',
        'descriptionmsg',
        'license-name',
        'name',
        'namemsg',
        'url',
        'version',
    ];
 
    protected const NOT_ATTRIBS = [
        'callback',
        'config',
        'config_prefix',
        'load_composer_autoloader',
        'manifest_version',
        'namespaces',
        'requires',
        'AutoloadClasses',
        'ExtensionMessagesFiles',
        'Hooks',
        'MessagePosterModule',
        'MessagesDirs',
        'OOUIThemePaths',
        'ParserTestFiles',
        'QUnitTestModule',
        'ResourceFileModulePaths',
        'ResourceModuleSkinStyles',
        'ResourceModules',
        'ServiceWiringFiles',
    ];
 
    protected $globals = [
        'wgExtensionMessagesFiles' => [],
        'wgMessagesDirs' => [],
    ];
 
    protected $defines = [];
 
    protected $callbacks = [];
 
    protected $credits = [];
 
    protected $config = [];
 
    protected $attributes = [];
 
    protected $extAttributes = [];
 
    public function extractInfo( $path, array $info, $version ) {
        $dir = dirname( $path );
        $this->extractHooks( $info, $path );
        $this->extractExtensionMessagesFiles( $dir, $info );
        $this->extractMessagesDirs( $dir, $info );
        $this->extractNamespaces( $info );
        $this->extractResourceLoaderModules( $dir, $info );
        if ( isset( $info['ServiceWiringFiles'] ) ) {
            $this->extractPathBasedGlobal(
                'wgServiceWiringFiles',
                $dir,
                $info['ServiceWiringFiles']
            );
        }
        if ( isset( $info['ParserTestFiles'] ) ) {
            $this->extractPathBasedGlobal(
                'wgParserTestFiles',
                $dir,
                $info['ParserTestFiles']
            );
        }
        $name = $this->extractCredits( $path, $info );
        if ( isset( $info['callback'] ) ) {
            $this->callbacks[$name] = $info['callback'];
        }
 
        // config should be after all core globals are extracted,
        // so duplicate setting detection will work fully
        if ( $version === 2 ) {
            $this->extractConfig2( $info, $dir );
        } else {
            // $version === 1
            $this->extractConfig1( $info );
        }
 
        // Record the extension name in the ParsoidModules property
        if ( isset( $info['ParsoidModules'] ) ) {
            foreach ( $info['ParsoidModules'] as &$module ) {
                if ( is_string( $module ) ) {
                    $className = $module;
                    $module = [
                        'class' => $className,
                    ];
                }
                $module['name'] = $name;
            }
        }
 
        if ( $version === 2 ) {
            $this->extractAttributes( $path, $info );
        }
 
        foreach ( $info as $key => $val ) {
            // If it's a global setting,
            if ( in_array( $key, self::$globalSettings ) ) {
                $this->storeToArrayRecursive( $path, "wg$key", $val, $this->globals );
                continue;
            }
            // Ignore anything that starts with a @
            if ( $key[0] === '@' ) {
                continue;
            }
 
            if ( $version === 2 ) {
                // Only whitelisted attributes are set
                if ( in_array( $key, self::CORE_ATTRIBS ) ) {
                    $this->storeToArray( $path, $key, $val, $this->attributes );
                }
            } else {
                // version === 1
                if ( !in_array( $key, self::NOT_ATTRIBS )
                    && !in_array( $key, self::CREDIT_ATTRIBS )
                ) {
                    // If it's not blacklisted, it's an attribute
                    $this->storeToArrayRecursive( $path, $key, $val, $this->attributes );
                }
            }
        }
    }
 
    protected function extractAttributes( $path, array $info ) {
        if ( isset( $info['attributes'] ) ) {
            foreach ( $info['attributes'] as $extName => $value ) {
                $this->storeToArrayRecursive( $path, $extName, $value, $this->extAttributes );
            }
        }
    }
 
    public function getExtractedInfo() {
        // Make sure the merge strategies are set
        foreach ( $this->globals as $key => $val ) {
            if ( isset( self::MERGE_STRATEGIES[$key] ) ) {
                $this->globals[$key][ExtensionRegistry::MERGE_STRATEGY] = self::MERGE_STRATEGIES[$key];
            }
        }
 
        // Merge $this->extAttributes into $this->attributes depending on what is loaded
        foreach ( $this->extAttributes as $extName => $value ) {
            // Only set the attribute if $extName is loaded (and hence present in credits)
            if ( isset( $this->credits[$extName] ) ) {
                foreach ( $value as $attrName => $attrValue ) {
                    $this->storeToArrayRecursive(
                        '', // Don't provide a path since it's impossible to generate an error here
                        $extName . $attrName,
                        $attrValue,
                        $this->attributes
                    );
                }
                unset( $this->extAttributes[$extName] );
            }
        }
 
        return [
            'globals' => $this->globals,
            'config' => $this->config,
            'defines' => $this->defines,
            'callbacks' => $this->callbacks,
            'credits' => $this->credits,
            'attributes' => $this->attributes,
        ];
    }
 
    public function getRequirements( array $info, $includeDev ) {
        // Quick shortcuts
        if ( !$includeDev || !isset( $info['dev-requires'] ) ) {
            return $info['requires'] ?? [];
        }
 
        if ( !isset( $info['requires'] ) ) {
            return $info['dev-requires'] ?? [];
        }
 
        // OK, we actually have to merge everything
        $merged = [];
 
        // Helper that combines version requirements by
        // picking the non-null if one is, or combines
        // the two. Note that it is not possible for
        // both inputs to be null.
        $pick = function ( $a, $b ) {
            if ( $a === null ) {
                return $b;
            } elseif ( $b === null ) {
                return $a;
            } else {
                return "$a $b";
            }
        };
 
        $req = $info['requires'];
        $dev = $info['dev-requires'];
        if ( isset( $req['MediaWiki'] ) || isset( $dev['MediaWiki'] ) ) {
            $merged['MediaWiki'] = $pick(
                $req['MediaWiki'] ?? null,
                $dev['MediaWiki'] ?? null
            );
        }
 
        $platform = array_merge(
            array_keys( $req['platform'] ?? [] ),
            array_keys( $dev['platform'] ?? [] )
        );
        if ( $platform ) {
            foreach ( $platform as $pkey ) {
                if ( $pkey === 'php' ) {
                    $value = $pick(
                        $req['platform']['php'] ?? null,
                        $dev['platform']['php'] ?? null
                    );
                } else {
                    // Prefer dev value, but these should be constant
                    // anyways (ext-* and ability-*)
                    $value = $dev['platform'][$pkey] ?? $req['platform'][$pkey];
                }
                $merged['platform'][$pkey] = $value;
            }
        }
 
        foreach ( [ 'extensions', 'skins' ] as $thing ) {
            $things = array_merge(
                array_keys( $req[$thing] ?? [] ),
                array_keys( $dev[$thing] ?? [] )
            );
            foreach ( $things as $name ) {
                $merged[$thing][$name] = $pick(
                    $req[$thing][$name] ?? null,
                    $dev[$thing][$name] ?? null
                );
            }
        }
        return $merged;
    }
 
    private function setArrayHookHandler(
        array $callback,
        array $hookHandlersAttr,
        string $name,
        string $path
    ) {
        if ( isset( $callback['handler'] ) ) {
            $handlerName = $callback['handler'];
            $handlerDefinition = $hookHandlersAttr[$handlerName] ?? false;
            if ( !$handlerDefinition ) {
                throw new UnexpectedValueException(
                    "Missing handler definition for $name in HookHandlers attribute in $path"
                );
            }
            $callback['handler'] = $handlerDefinition;
            $callback['extensionPath'] = $path;
            $this->attributes['Hooks'][$name][] = $callback;
        } else {
            foreach ( $callback as $callable ) {
                if ( is_array( $callable ) ) {
                    if ( isset( $callable['handler'] ) ) { // Non-legacy style handler
                        $this->setArrayHookHandler( $callable, $hookHandlersAttr, $name, $path );
                    } else { // Legacy style handler array
                        $this->globals['wgHooks'][$name][] = $callable;
                    }
                } elseif ( is_string( $callable ) ) {
                    $this->setStringHookHandler( $callable, $hookHandlersAttr, $name, $path );
                }
            }
        }
    }
 
    private function setStringHookHandler(
        string $callback,
        array $hookHandlersAttr,
        string $name,
        string $path
    ) {
        if ( isset( $hookHandlersAttr[$callback] ) ) {
            $handler = [
                'handler' => $hookHandlersAttr[$callback],
                'extensionPath' => $path
            ];
            $this->attributes['Hooks'][$name][] = $handler;
        } else { // legacy style handler
            $this->globals['wgHooks'][$name][] = $callback;
        }
    }
 
    protected function extractHooks( array $info, string $path ) {
        $extName = $info['name'];
        if ( isset( $info['Hooks'] ) ) {
            $hookHandlersAttr = [];
            foreach ( $info['HookHandlers'] ?? [] as $name => $def ) {
                $hookHandlersAttr[$name] = [ 'name' => "$extName-$name" ] + $def;
            }
            foreach ( $info['Hooks'] as $name => $callback ) {
                if ( is_string( $callback ) ) {
                    $this->setStringHookHandler( $callback, $hookHandlersAttr, $name, $path );
                } elseif ( is_array( $callback ) ) {
                    $this->setArrayHookHandler( $callback, $hookHandlersAttr, $name, $path );
                }
            }
        }
        if ( isset( $info['DeprecatedHooks'] ) ) {
            $deprecatedHooks = [];
            foreach ( $info['DeprecatedHooks'] as $name => $deprecatedHookInfo ) {
                $deprecatedHookInfo += [ 'component' => $extName ];
                $deprecatedHooks[$name] = $deprecatedHookInfo;
            }
            if ( isset( $this->attributes['DeprecatedHooks'] ) ) {
                $this->attributes['DeprecatedHooks'] += $deprecatedHooks;
            } else {
                $this->attributes['DeprecatedHooks'] = $deprecatedHooks;
            }
        }
    }
 
    protected function extractNamespaces( array $info ) {
        if ( isset( $info['namespaces'] ) ) {
            foreach ( $info['namespaces'] as $ns ) {
                if ( defined( $ns['constant'] ) ) {
                    // If the namespace constant is already defined, use it.
                    // This allows namespace IDs to be overwritten locally.
                    $id = constant( $ns['constant'] );
                } else {
                    $id = $ns['id'];
                }
                $this->defines[ $ns['constant'] ] = $id;
 
                if ( !( isset( $ns['conditional'] ) && $ns['conditional'] ) ) {
                    // If it is not conditional, register it
                    $this->attributes['ExtensionNamespaces'][$id] = $ns['name'];
                }
                if ( isset( $ns['movable'] ) && !$ns['movable'] ) {
                    $this->attributes['ImmovableNamespaces'][] = $id;
                }
                if ( isset( $ns['gender'] ) ) {
                    $this->globals['wgExtraGenderNamespaces'][$id] = $ns['gender'];
                }
                if ( isset( $ns['subpages'] ) && $ns['subpages'] ) {
                    $this->globals['wgNamespacesWithSubpages'][$id] = true;
                }
                if ( isset( $ns['content'] ) && $ns['content'] ) {
                    $this->globals['wgContentNamespaces'][] = $id;
                }
                if ( isset( $ns['defaultcontentmodel'] ) ) {
                    $this->globals['wgNamespaceContentModels'][$id] = $ns['defaultcontentmodel'];
                }
                if ( isset( $ns['protection'] ) ) {
                    $this->globals['wgNamespaceProtection'][$id] = $ns['protection'];
                }
                if ( isset( $ns['capitallinkoverride'] ) ) {
                    $this->globals['wgCapitalLinkOverrides'][$id] = $ns['capitallinkoverride'];
                }
 
            }
        }
    }
 
    protected function extractResourceLoaderModules( $dir, array $info ) {
        $defaultPaths = $info['ResourceFileModulePaths'] ?? false;
        if ( isset( $defaultPaths['localBasePath'] ) ) {
            if ( $defaultPaths['localBasePath'] === '' ) {
                // Avoid double slashes (e.g. /extensions/Example//path)
                $defaultPaths['localBasePath'] = $dir;
            } else {
                $defaultPaths['localBasePath'] = "$dir/{$defaultPaths['localBasePath']}";
            }
        }
 
        foreach ( [ 'ResourceModules', 'ResourceModuleSkinStyles', 'OOUIThemePaths' ] as $setting ) {
            if ( isset( $info[$setting] ) ) {
                foreach ( $info[$setting] as $name => $data ) {
                    if ( isset( $data['localBasePath'] ) ) {
                        if ( $data['localBasePath'] === '' ) {
                            // Avoid double slashes (e.g. /extensions/Example//path)
                            $data['localBasePath'] = $dir;
                        } else {
                            $data['localBasePath'] = "$dir/{$data['localBasePath']}";
                        }
                    }
                    if ( $defaultPaths ) {
                        $data += $defaultPaths;
                    }
                    $this->attributes[$setting][$name] = $data;
                }
            }
        }
 
        if ( isset( $info['QUnitTestModule'] ) ) {
            $data = $info['QUnitTestModule'];
            if ( isset( $data['localBasePath'] ) ) {
                if ( $data['localBasePath'] === '' ) {
                    // Avoid double slashes (e.g. /extensions/Example//path)
                    $data['localBasePath'] = $dir;
                } else {
                    $data['localBasePath'] = "$dir/{$data['localBasePath']}";
                }
            }
            $this->attributes['QUnitTestModules']["test.{$info['name']}"] = $data;
        }
 
        if ( isset( $info['MessagePosterModule'] ) ) {
            $data = $info['MessagePosterModule'];
            $basePath = $data['localBasePath'] ?? '';
            $baseDir = $basePath === '' ? $dir : "$dir/$basePath";
            foreach ( $data['scripts'] ?? [] as $scripts ) {
                $this->attributes['MessagePosterModule']['scripts'][] =
                    new ResourceLoaderFilePath( $scripts, $baseDir );
            }
            foreach ( $data['dependencies'] ?? [] as $dependency ) {
                $this->attributes['MessagePosterModule']['dependencies'][] = $dependency;
            }
        }
    }
 
    protected function extractExtensionMessagesFiles( $dir, array $info ) {
        if ( isset( $info['ExtensionMessagesFiles'] ) ) {
            foreach ( $info['ExtensionMessagesFiles'] as &$file ) {
                $file = "$dir/$file";
            }
            $this->globals["wgExtensionMessagesFiles"] += $info['ExtensionMessagesFiles'];
        }
    }
 
    protected function extractMessagesDirs( $dir, array $info ) {
        if ( isset( $info['MessagesDirs'] ) ) {
            foreach ( $info['MessagesDirs'] as $name => $files ) {
                foreach ( (array)$files as $file ) {
                    $this->globals["wgMessagesDirs"][$name][] = "$dir/$file";
                }
            }
        }
    }
 
    protected function extractCredits( $path, array $info ) {
        $credits = [
            'path' => $path,
            'type' => 'other',
        ];
        foreach ( self::CREDIT_ATTRIBS as $attr ) {
            if ( isset( $info[$attr] ) ) {
                $credits[$attr] = $info[$attr];
            }
        }
 
        $name = $credits['name'];
 
        // If someone is loading the same thing twice, throw
        // a nice error (T121493)
        if ( isset( $this->credits[$name] ) ) {
            $firstPath = $this->credits[$name]['path'];
            $secondPath = $credits['path'];
            throw new Exception( "It was attempted to load $name twice, from $firstPath and $secondPath." );
        }
 
        $this->credits[$name] = $credits;
 
        return $name;
    }
 
    protected function extractConfig1( array $info ) {
        if ( isset( $info['config'] ) ) {
            if ( isset( $info['config']['_prefix'] ) ) {
                $prefix = $info['config']['_prefix'];
                unset( $info['config']['_prefix'] );
            } else {
                $prefix = 'wg';
            }
            foreach ( $info['config'] as $key => $val ) {
                if ( $key[0] !== '@' ) {
                    $this->addConfigGlobal( "$prefix$key", $val, $info['name'] );
                }
            }
        }
    }
 
    protected function extractConfig2( array $info, $dir ) {
        $prefix = $info['config_prefix'] ?? 'wg';
        if ( isset( $info['config'] ) ) {
            foreach ( $info['config'] as $key => $data ) {
                $value = $data['value'];
                if ( isset( $data['path'] ) && $data['path'] ) {
                    $callback = function ( $value ) use ( $dir ) {
                        return "$dir/$value";
                    };
                    if ( is_array( $value ) ) {
                        $value = array_map( $callback, $value );
                    } else {
                        $value = $callback( $value );
                    }
                }
                if ( isset( $data['merge_strategy'] ) ) {
                    $value[ExtensionRegistry::MERGE_STRATEGY] = $data['merge_strategy'];
                }
                $this->addConfigGlobal( "$prefix$key", $value, $info['name'] );
                $data['providedby'] = $info['name'];
                if ( isset( $info['ConfigRegistry'][0] ) ) {
                    $data['configregistry'] = array_keys( $info['ConfigRegistry'] )[0];
                }
                $this->config[$key] = $data;
            }
        }
    }
 
    private function addConfigGlobal( $key, $value, $extName ) {
        if ( array_key_exists( $key, $this->globals ) ) {
            throw new RuntimeException(
                "The configuration setting '$key' was already set by MediaWiki core or"
                . " another extension, and cannot be set again by $extName." );
        }
        $this->globals[$key] = $value;
    }
 
    protected function extractPathBasedGlobal( $global, $dir, $paths ) {
        foreach ( $paths as $path ) {
            $this->globals[$global][] = "$dir/$path";
        }
    }
 
    protected function storeToArrayRecursive( $path, $name, $value, &$array ) {
        if ( !is_array( $value ) ) {
            throw new InvalidArgumentException( "The value for '$name' should be an array (from $path)" );
        }
        if ( isset( $array[$name] ) ) {
            $array[$name] = array_merge_recursive( $array[$name], $value );
        } else {
            $array[$name] = $value;
        }
    }
 
    protected function storeToArray( $path, $name, $value, &$array ) {
        if ( !is_array( $value ) ) {
            throw new InvalidArgumentException( "The value for '$name' should be an array (from $path)" );
        }
        if ( isset( $array[$name] ) ) {
            $array[$name] = array_merge( $array[$name], $value );
        } else {
            $array[$name] = $value;
        }
    }
 
    public function getExtraAutoloaderPaths( $dir, array $info ) {
        $paths = [];
        if ( isset( $info['load_composer_autoloader'] ) && $info['load_composer_autoloader'] === true ) {
            $paths[] = "$dir/vendor/autoload.php";
        }
        return $paths;
    }
}