Proyectos de Subversion Moodle

namespace core;

use core\exception\coding_exception;

use core\output\theme_config;

use stdClass;

use ArrayIterator;

use DirectoryIterator;

use Exception;

use RegexIterator;

    /** @var array deprecated plugins  */

    protected static $deprecatedplugins = null;

    /** @var array deleted plugins */

    protected static $deletedplugins = null;

    /** @var array deprecated plugin types */

    protected static $deprecatedplugintypes = null;

    /** @var array deleted plugin types */

    protected static $deletedplugintypes = null;

    /** @var array deprecated sub plugins */

    protected static $deprecatedsubplugins = null;

    /** @var array deleted sub plugins */

    protected static $deletedsubplugins = null;

        \CFPropertyList::class => 'lib/plist/src/CFPropertyList',

        \Complex::class => 'lib/phpspreadsheet/markbaker/complex/classes/src',

        \Composer\Pcre::class => 'lib/composer/pcre/src',

        \DI::class => 'lib/php-di/php-di/src',

        \FastRoute::class => 'lib/nikic/fast-route/src',

        \GuzzleHttp::class => 'lib/guzzlehttp/guzzle/src',

        \GuzzleHttp\Promise::class => 'lib/guzzlehttp/promises/src',

        \GuzzleHttp\Psr7::class => 'lib/guzzlehttp/psr7/src',

        \IMSGlobal\LTI::class => 'lib/ltiprovider/src',

        \Invoker::class => 'lib/php-di/invoker/src',

        \Kevinrob\GuzzleCache::class => 'lib/guzzlehttp/kevinrob/guzzlecache/src',

        \Laravel\SerializableClosure::class => 'lib/laravel/serializable-closure/src',

        \libphonenumber::class => 'lib/giggsey/libphonenumber-for-php-lite/src',

        \Matrix::class => 'lib/phpspreadsheet/markbaker/matrix/classes/src',

        \MaxMind\Db::class => 'lib/maxmind/MaxMind/src/MaxMind/Db',

        \MoodleHQ::class => [

            'lib/rtlcss/src/MoodleHQ',

        ],

            'lib/psr/http-message/src',

        ],

        \Psr\Http\Server::class => [

            "lib/psr/http-server-handler/src",

            "lib/psr/http-server-middleware/src",

        \Psr\Log::class => "lib/psr/log/src",

    ];

    /**

     *  An array containing files which are normally in a package's composer/autoload.files section.

     *

     * PHP does not provide a mechanism for automatically including the files that methods are in.

     *

     * The Composer autoloader includes all files in this section of the composer.json file during the instantiation of the loader.

     *

     * @var array<string>

     */

    protected static $composerautoloadfiles = [

        'lib/aws-sdk/src/functions.php',

        'lib/guzzlehttp/guzzle/src/functions_include.php',

        'lib/ralouphie/getallheaders/src/getallheaders.php',

    /**

     * Register the Moodle class autoloader.

     */

    public static function register_autoloader(): void {

        if (defined('COMPONENT_CLASSLOADER')) {

            spl_autoload_register(COMPONENT_CLASSLOADER);

        } else {

            spl_autoload_register([self::class, 'classloader']);

        }

        // Load any composer-driven autoload files.

        // This is intended to mimic the behaviour of the standard Composer Autoloader.

        foreach (static::$composerautoloadfiles as $file) {

            $path = dirname(__DIR__, 2) . '/' . $file;

            if (file_exists($path)) {

                require_once($path);

            }

        }

    }

                self::$deprecatedplugintypes    = $cache['deprecatedplugintypes'];

                self::$deletedplugintypes       = $cache['deletedplugintypes'];

                self::$deprecatedplugins        = $cache['deprecatedplugins'];

                self::$deletedplugins           = $cache['deletedplugins'];

                self::$deprecatedsubplugins     = $cache['deprecatedsubplugins'];

                self::$deletedsubplugins        = $cache['deletedsubplugins'];

                    self::$deprecatedplugintypes    = $cache['deprecatedplugintypes'];

                    self::$deletedplugintypes       = $cache['deletedplugintypes'];

                    self::$deprecatedplugins        = $cache['deprecatedplugins'];

                    self::$deletedplugins           = $cache['deletedplugins'];

                    self::$deprecatedsubplugins     = $cache['deprecatedsubplugins'];

                    self::$deletedsubplugins        = $cache['deletedsubplugins'];

        bool $fullreset = false,

    ): void {

        // Reset all caches to ensure they are reloaded.

        self::$plugins = null;

        self::$subsystems = null;

        self::$parents = null;

        self::$subplugins = null;

        self::$deprecatedplugins = null;

        self::$deletedplugins = null;

        self::$deprecatedplugintypes = null;

        self::$deletedplugintypes = null;

        self::$deprecatedsubplugins = null;

        self::$deletedsubplugins = null;

        self::$apis = null;

        self::$classmap = null;

        self::$classmaprenames = null;

        self::$filemap = null;

        if ($fullreset) {

            self::$componentsource = null;

            self::$version = null;

            self::$supportsubplugins = ['mod', 'editor', 'tool', 'local'];

        }

    }

    /**

     * Check whether the cache content in the supplied cache is valid.

     *

     * @param array $cache The content being loaded

     * @return bool Whether it is valid

     */

    protected static function is_cache_valid(array $cache): bool {

        global $CFG;

        if (!isset($cache['version'])) {

            // Something is very wrong.

            return false;

        }

        if ((float) $cache['version'] !== (float) self::fetch_core_version()) {

            // Outdated cache. We trigger an error log to track an eventual repetitive failure of float comparison.

            error_log('Resetting core_component cache after core upgrade to version ' . self::fetch_core_version());

            return false;

        }

        if ($cache['plugintypes']['mod'] !== "$CFG->dirroot/mod") {

            // phpcs:ignore moodle.Commenting.InlineComment.NotCapital

            // $CFG->dirroot was changed.

            return false;

        }

        // Check for key classes which block access to the upgrade in some way.

        // Note: This list should be kept _extremely_ minimal and generally

        // when adding a newly discovered classes older ones should be removed.

        // Always keep moodle_exception in place.

        $keyclasses = [

            \core\exception\moodle_exception::class,

            \core\output\bootstrap_renderer::class,

            \core_cache\cache::class,

        ];

        foreach ($keyclasses as $classname) {

            if (!array_key_exists($classname, $cache['classmap'])) {

                // The cache is missing some key classes. This is likely before the upgrade has run.

                error_log(

                    "The '{$classname}' class was not found in the component class cache. Resetting the classmap.",

                );

                return false;

            }

        }

        return true;

            'plugintypes'           => self::$plugintypes,

            'deprecatedplugintypes' => self::$deprecatedplugintypes,

            'plugins'               => self::$plugins,

            'subplugins'            => self::$subplugins,

            'deprecatedsubplugins'  => self::$deprecatedsubplugins,

            'deletedsubplugins'     => self::$deletedsubplugins,

        [

            'plugintypes' => self::$plugintypes,

            'parents' => self::$parents,

            'subplugins' => self::$subplugins,

            'deletedplugintypes' => self::$deletedplugintypes,

            'deprecatedsubplugins' => self::$deprecatedsubplugins,

            'deletedsubplugin' => self::$deletedsubplugins

            self::$plugins[$type] = self::fetch_plugins($type, $fulldir);

        }

        self::$deprecatedplugins = [];

        foreach (self::$deprecatedplugintypes as $type => $fulldir) {

            self::$deprecatedplugins[$type] = self::fetch_plugins($type, $fulldir);

        }

        self::$deletedplugins = [];

        foreach (self::$deletedplugintypes as $type => $fulldir) {

        // Top level plugin types.

        $plugintypesmap = [

            'plugintypes' => [],

            'deprecatedplugintypes' => [],

            'deletedplugintypes' => [],

        ];

        $subplugintypesmap = [

            'plugintypes' => [],

            'deprecatedplugintypes' => [],

            'deletedplugintypes' => [],

        ];

        $parents = [];

        foreach ($plugintypesmap as $sourcekey => $typesarr) {

                    $path = $CFG->admin . substr($path, 5);

                }

        }

        // Prevent deprecation of plugin types supporting subplugins (those in self::$supportsubplugins).

        foreach (['deprecatedplugintypes', 'deletedplugintypes'] as $key) {

            $illegaltypes = array_intersect(self::$supportsubplugins, array_keys($plugintypesmap[$key]));

            if (!empty($illegaltypes)) {

                debugging("Deprecation of a plugin type which supports subplugins is not supported. These plugin types will ".

                    "continue to be treated as active.", DEBUG_DEVELOPER);

                foreach ($illegaltypes as $plugintype) {

                }

            if ($type === 'local') {

            $plugins = self::fetch_plugins($type, $plugintypesmap['plugintypes'][$type]);

            foreach ($plugins as $plugin => $fulldir) {

                $allsubtypes = self::fetch_subtypes($fulldir);

                $subplugintypesdata = [

                    'plugintypes' => $allsubtypes['plugintypes'] ?? [],

                    'deprecatedplugintypes' => $allsubtypes['deprecatedplugintypes'] ?? [],

                    'deletedplugintypes' => $allsubtypes['deletedplugintypes'] ?? [],

                        && !$subplugintypesdata['deletedplugintypes']) {

                    continue;

                }

                $subplugintypesmap['plugintypes'][$type . '_' . $plugin] = [];

                foreach ($subplugintypesdata as $key => $subplugintypes) {

                                || isset($plugintypesmap['deprecatedplugintypes'][$subtype])

                                || isset($plugintypesmap['deletedplugintypes'][$subtype])) {

                            error_log("Invalid subtype '$subtype', duplicate detected.");

                            continue;

                        }

                        $plugintypesmap[$key][$subtype] = $subdir;

            $type = 'local';

            $plugins = self::fetch_plugins($type, $plugintypesmap['plugintypes'][$type]);

            foreach ($plugins as $plugin => $fulldir) {

                $allsubtypes = self::fetch_subtypes($fulldir);

                $subplugintypesdata = [

                    'plugintypes' => $allsubtypes['plugintypes'] ?? [],

                if (!$subplugintypesdata['plugintypes'] && !$subplugintypesdata['deprecatedplugintypes']

                        && !$subplugintypesdata['deletedplugintypes']) {

                    continue;

                }

                $subplugintypesmap['deletedplugintypes'][$type . '_' . $plugin] = [];

                        if (isset($plugintypesmap['plugintypes'][$subtype])

                                || isset($plugintypesmap['deprecatedplugintypes'][$subtype])

                                || isset($plugintypesmap['deletedplugintypes'][$subtype])) {

                            error_log("Invalid subtype '$subtype', duplicate detected.");

                            continue;

                        }

                        );

                }

            }

        }

        return [

            'plugintypes' => $plugintypesmap['plugintypes'],

            'parents' => $parents,

        $subplugins = [];

        if (str_contains($ownerdir, $CFG->dirroot)) {

            $plugindir = substr($ownerdir, strlen($CFG->dirroot) + 1);

        } else {

            $realownerdir = realpath($ownerdir);

            $realroot = realpath(dirname(__DIR__, 2));

            $plugindir = substr($realownerdir, strlen($realroot) + 1);

        }

        $subtypesregister = [

            'plugintypes' => [],

            'deprecatedplugintypes' => [],

            'deletedplugintypes' => [],

            if (json_last_error() === JSON_ERROR_NONE) {

                if (!empty($subpluginsjson->subplugintypes)) {

                    // If the newer subplugintypes is defined, use it.

                    // The value here is relative to the plugin's owner directory.

                    $subplugins = array_map($subpluginpathformatter, (array) $subpluginsjson->subplugintypes);

                } else if (!empty($subpluginsjson->plugintypes)) {

                    error_log(

                        "No subplugintypes defined in $ownerdir/db/subplugins.json. " .

                        "Falling back to deprecated plugintypes value. " .

                        "See MDL-83705 for further information.",

                }

                $subtypesregister['plugintypes'] = $subplugins;

                // The deprecated and deleted subplugintypes are optional and are always relative to the plugin's root directory.

                $subtypesregister['deprecatedplugintypes'] = array_map(

                    $subpluginpathformatter,

                    (array) ($subpluginsjson->deprecatedsubplugintypes ?? []),

                );

                $subtypesregister['deletedplugintypes'] = array_map(

                    $subpluginpathformatter,

                    (array) ($subpluginsjson->deletedsubplugintypes ?? []),

            }

            if (function_exists('debugging') && debugging()) {

                if (property_exists($subpluginsjson, 'subplugintypes') && property_exists($subpluginsjson, 'plugintypes')) {

                    $subplugintypes = (array) $subpluginsjson->subplugintypes;

                    $plugintypes = (array) $subpluginsjson->plugintypes;

                    if (count($subplugintypes) !== count(($plugintypes))) {

                        error_log("Subplugintypes and plugintypes are not in sync in $ownerdir/db/subplugins.json");

                    }

                    foreach ($subplugintypes as $type => $path) {

                        if (!isset($plugintypes[$type])) {

                            error_log("Subplugintypes and plugintypes are not in sync for '$type' in $ownerdir/db/subplugins.json");

                            continue;

                        }

                        if ($plugintypes[$type] !== $subplugins[$type]) {

                            error_log("Subplugintypes and plugintypes are not in sync for '$type' in $ownerdir/db/subplugins.json");

                        }

                    }

                }

        } else if (file_exists("$ownerdir/db/subplugins.php")) {

        }

                    error_log("Invalid subtype directory '$dir' detected in '$ownerdir'.");

                    continue;

                self::load_classes($plugintype . '_' . $pluginname, "$fulldir/classes");

        }

        // Include deprecated plugins in the classmap, to facilitate migration code which uses existing plugin classes.

        foreach (self::$deprecatedplugins as $plugintype => $plugins) {

            foreach ($plugins as $pluginname => $fulldir) {

                self::load_classes($plugintype . '_' . $pluginname, "$fulldir/classes");

            }

        }

    /**

     * Get a list of deprecated plugin types and their locations.

     *

     * @return array as (string)plugintype => (string)fulldir

     */

    public static function get_deprecated_plugin_types(): array {

        self::init();

        return self::$deprecatedplugintypes;

    }

    /**

     * Get a list of all deleted plugin types and their locations.

     *

     * @return array as (string)plugintype => (string)fulldir

     */

    public static function get_deleted_plugin_types(): array {

        self::init();

        return self::$deletedplugintypes;

    }

    /**

     * Gets list of all plugin types, comprising available plugin types as well as any plugin types currently in deprecation.

     *

     * @return array as (string)plugintype => (string)fulldir

     */

    public static function get_all_plugin_types(): array {

        self::init();

        return array_merge(self::$plugintypes, self::$deprecatedplugintypes, self::$deletedplugintypes);

    }

    /**

     * Is the plugintype deprecated.

     *

     * @param string $plugintype

     * @return bool true if deprecated, false otherwise.

     */

    public static function is_deprecated_plugin_type(string $plugintype): bool {

        self::init();

        return array_key_exists($plugintype, self::$deprecatedplugintypes);

    }

    /**

     * Is the plugintype deleted.

     *

     * @param string $plugintype

     * @return bool true if deleted, false otherwise.

     */

    public static function is_deleted_plugin_type(string $plugintype): bool {

        self::init();

        return array_key_exists($plugintype, self::$deletedplugintypes);

    }

    /**

     * Is the plugintype in deprecation.

     *

     * @param string $plugintype

     * @return bool true if in either phase 1 (deprecated) or phase 2 (deleted) or deprecation.

     */

    public static function is_plugintype_in_deprecation(string $plugintype): bool {

        self::init();

        return array_key_exists($plugintype, array_merge(self::$deprecatedplugintypes, self::$deletedplugintypes));

    }

    /**

     * Get list of deprecated plugins of a given type.

     *

     * @param string $plugintype

     * @return array as (string)pluginname => (string)fulldir

     */

    public static function get_deprecated_plugin_list($plugintype): array {

        self::init();

        return self::$deprecatedplugins[$plugintype] ?? [];

    }

    /**

     * Get list of deleted plugins of a given type.

     *

     * @param string $plugintype

     * @return array as (string)pluginname => (string)fulldir

     */

    public static function get_deleted_plugin_list($plugintype): array {

        self::init();

        return self::$deletedplugins[$plugintype] ?? [];

    }

    /**

     * Get list of all plugins of a given type, comprising all available plugins as well as any plugins in deprecation.

     *

     * @param string $plugintype

     * @return array as (string)pluginname => (string)fulldir

     */

    public static function get_all_plugins_list(string $plugintype): array {

        self::init();

        return array_merge(

            self::$plugins[$plugintype] ?? [],

            self::$deprecatedplugins[$plugintype] ?? [],

            self::$deletedplugins[$plugintype] ?? []

        );

    }

     *

     * No filtering is done on deprecated/deleted subtypes. Calling code should check this if needed.

    /**

     * Return all subplugins for the component, comprising all available subplugins plus any in deprecation.

     *

     * @param string $component

     * @return array|null $subtype=>array($component, ..), null if no subtypes defined

     */

    public static function get_all_subplugins($component): ?array {

        self::init();

        $subplugins = array_merge(

            self::$subplugins[$component] ?? [],

            self::$deprecatedsubplugins[$component] ?? [],

            self::$deletedsubplugins[$component] ?? [],

        );

        return $subplugins ?: null;

    }

    /**

     * Load legacy classes based upon the db/legacyclasses.php file.

     *

     * The legacyclasses.php should contain a key => value array ($legacyclasses) where the key is the class name,

     * and the value is the path to the class file within the relative ../classes/ directory.

     *

     * @param string|null $fulldir The directory to the legacy classes.

     * @param bool $allowsubsystems Whether to allow the specification of alternative subsystems for this path.

     */

    protected static function load_legacy_classes(

        ?string $fulldir,

        bool $allowsubsystems = false,

    ): void {

        if (is_null($fulldir)) {

            return;

        }

        $file = $fulldir . '/db/legacyclasses.php';

        if (is_readable($file)) {

            $legacyclasses = null;

            require($file);

            if (is_array($legacyclasses)) {

                foreach ($legacyclasses as $classname => $path) {

                    if (is_array($path)) {

                        if (!$allowsubsystems) {

                            throw new Exception(

                                "Invalid legacy classes path entry for {$classname}. " .

                                    "Only files within the component can be specified.",

                            );

                        }

                        if (count($path) !== 2) {

                            throw new Exception(

                                "Invalid legacy classes path entry for {$classname}. " .

                                    "Entries must be in the format [subsystem, path].",

                            );

                        }

                        [$subsystem, $path] = $path;

                        $subsystem = substr($subsystem, 5);

                        if (!array_key_exists($subsystem, self::$subsystems)) {