Allow all components to be loaded from file instead of calculated

A new phpcs config setting: moodleComponentsListPath

Enables the possibility of loading the list of components from
a file, instead of calculating them from codebase.

This is interesting when the complete codebase is not available,
like happens for example with CiBoT, that only keeps the files
modified in place, to reduce the stuff being checked.

The format of the components file is the same than the
moodle-local_ci/list_valid_components one:

[plugin|subsystem],component_name,component_full_path

Covered with unit tests, will be used in the remote branch checker
(a.k.a. CiBoT).

If the setting is not configured then the standard load of
components from codebase (core_component execution) is performed.

Author: stronk7

moodle/Util/MoodleUtil.php

@@ -93,6 +93,47 @@ protected static function calculateAllComponents(string $moodleRoot): ?array {
 
         // We haven't the components yet, let's calculate all them.
 
+        // First, try to get it from configuration/runtime option.
+        // This accepts the full path to a file like the one generated
+        // by moodle-local_ci/list_valid_components, which format is:
+        // [plugin|subsystem],component_name,component_full_path.
+        // Useful to load them when not all the code base is available
+        // like it happens with CiBoT runs, for example.
+        if ($componentsFile = Config::getConfigData('moodleComponentsListPath')) {
+            if (!is_readable($componentsFile)) {
+                throw new DeepExitException(
+                    "ERROR: Incorrect 'moodleComponentsListPath' config/runtime option. File not found: '$componentsFile'", 3);
+            }
+            // Go processing the file.
+            $handle = fopen($componentsFile, "r");
+            if ($handle) {
+                while (($line = fgets($handle)) !== false) {
+                    $aline = explode(',', trim($line));
+                    // Exclude any line not starting by plugin|sybsystem.
+                    if ($aline[0] !== 'plugin' && $aline[0] !== 'subsystem') {
+                        continue;
+                    }
+                    // Exclude any component not being valid one.
+                    if (!preg_match('/^[a-z][a-z0-9]*(_[a-z][a-z0-9_]*)?[a-z0-9]+$/', $aline[1])) {
+                        continue;
+                    }
+                    // Exclude any path not being under Mooddle dirroot.
+                    if (strpos($aline[2], $moodleRoot) !== 0) {
+                        continue;
+                    }
+                    // Arrived here, it's a valid line, annotate the component.
+                    self::$moodleComponents[$aline[1]] = $aline[2];
+                }
+                fclose($handle);
+            }
+            // Let's sort the array in ascending order, so more specific matches first.
+            arsort(self::$moodleComponents);
+
+            return self::$moodleComponents;
+        }
+
+        // Let's try to get the components from core.
+
         // Verify that core_component class is already available.
         // Make an exception for PHPUnit runs, to be able to test everything
         // because within tests it's always available and never invoked.

moodle/tests/moodleutil_test.php

@@ -17,6 +17,7 @@
 namespace local_codechecker;
 
 use MoodleCodeSniffer\moodle\Util\MoodleUtil;
+use org\bovigo\vfs\vfsStream;
 use PHP_CodeSniffer\Config;
 use PHP_CodeSniffer\Exceptions\DeepExitException;
 use PHP_CodeSniffer\Files\File;
@@ -41,6 +42,52 @@
  */
 class moodleutil_test extends local_codechecker_testcase {
 
+    /**
+     * Unit test for calculateAllComponents.
+     *
+     * Not 100% orthodox because {@see calculateAllComponents()} is protected,
+     * and it's already indirectly tested by {@see test_getMoodleComponent()}
+     * but it has some feature that we need to test individually here.
+     */
+    public function test_calculateAllComponents() {
+        // Let's calculate moodleRoot.
+        $moodleRoot = MoodleUtil::getMoodleRoot();
+
+        // Let's prepare a components file, with some correct and incorrect entries.
+        $components =
+            "nonono,mod_forum,{$moodleRoot}/mod_forum\n" .                // Wrong type.
+            "plugin,mod__nono,{$moodleRoot}/mod_forum\n" .                // Wrong component.
+            "plugin,mod_forum,/no/no/no/no//mod_forum\n" .                // Wrong path.
+            "plugin,local_codechecker,{$moodleRoot}/local/codechecker\n" .// All ok.
+            "plugin,mod_forum,{$moodleRoot}/mod/forum\n";                 // All ok.
+
+        // Let's use virtual filesystem instead of real one.
+        $vfs = vfsStream::setup('root', null, ['components.txt' => $components]);
+
+        // Set codechecker config to point to it.
+        Config::setConfigData('moodleComponentsListPath', $vfs->url() . '/components.txt', true);
+
+        // Let's run calculateAllComponents() and evaluate results.
+        $method = new \ReflectionMethod(MoodleUtil::class, 'calculateAllComponents');
+        $method->setAccessible(true);
+        $method->invokeArgs(null, [$moodleRoot]);
+
+        // Let's inspect which components have been loaded.
+        $property = new \ReflectionProperty(MoodleUtil::class, 'moodleComponents');
+        $property->setAccessible(true);
+        $loadedComponents = $property->getValue();
+
+        $this->assertCount(2, $loadedComponents);
+        $this->assertSame(['mod_forum', 'local_codechecker'],
+            array_keys($loadedComponents)); // Verify they are ordered in ascending order.
+        $this->assertSame(["{$moodleRoot}/mod/forum", "{$moodleRoot}/local/codechecker"],
+            array_values($loadedComponents)); // Verify component paths are also the expected ones.
+
+        // Ensure cached information doesn't affect other tests.
+        $this->cleanMoodleUtilCaches();
+        Config::setConfigData('moodleComponentsListPath', null, true);
+    }
+
     /**
      * Provider for test_getMoodleComponent.
      */