Handle file classmaps and normalized wiki targets

Author: coisa

src/Console/Command/WikiCommand.php

@@ -133,7 +133,7 @@ protected function execute(InputInterface $input, OutputInterface $output): int
         $jsonOutput = $this->isJsonOutput($input);
         $processOutput = $jsonOutput ? new BufferedOutput() : $output;
         $target = (string) $input->getOption('target');
-        $isDefaultWikiTarget = ProjectCapabilitiesResolverInterface::DEFAULT_WIKI_TARGET === $target;
+        $isDefaultWikiTarget = $this->isDefaultWikiTarget($target);
         $cacheEnabled = $this->isCacheEnabled($input);
 
         if ($input->getOption('init')) {
@@ -213,6 +213,38 @@ protected function execute(InputInterface $input, OutputInterface $output): int
         );
     }
 
+    /**
+     * Detects whether a target option still points at the default wiki target path.
+     *
+     * @param string $target the wiki target option received from the CLI
+     *
+     * @return bool true when the provided path is equivalent to the default wiki target
+     */
+    private function isDefaultWikiTarget(string $target): bool
+    {
+        return $this->normalizeProjectRelativePath($target) === $this->normalizeProjectRelativePath(
+            ProjectCapabilitiesResolverInterface::DEFAULT_WIKI_TARGET
+        );
+    }
+
+    /**
+     * Normalizes a project-relative path for resilient default-option comparisons.
+     *
+     * @param string $path the project-relative path to normalize
+     *
+     * @return string the normalized project-relative path
+     */
+    private function normalizeProjectRelativePath(string $path): string
+    {
+        $normalizedPath = str_replace('\\', '/', $path);
+
+        while (str_starts_with($normalizedPath, './')) {
+            $normalizedPath = substr($normalizedPath, 2);
+        }
+
+        return rtrim($normalizedPath, '/');
+    }
+
     /**
      * Adds the repository wiki as a Git submodule when the target path is missing.
      *

src/Project/ProjectCapabilitiesResolver.php

@@ -25,7 +25,10 @@
 use function array_key_first;
 use function array_values;
 use function is_dir;
+use function is_file;
 use function rtrim;
+use function str_ends_with;
+use function strtolower;
 
 /**
  * Resolves which repository surfaces are available to documentation, testing, and wiki tooling.
@@ -69,7 +72,7 @@ public function resolve(
             $this->filesystem->exists($guideDirectory),
             $this->filesystem->exists($testsPath),
             $this->filesystem->exists($wikiTarget),
-            [] !== $apiDirectories,
+            $this->resolveHasPhpSourceFiles($apiDirectories),
         );
     }
 
@@ -133,6 +136,34 @@ private function resolveRelativeApiDirectory(string $path): ?string
         return $this->filesystem->makePathRelative($absolutePath);
     }
 
+    /**
+     * Resolves whether Composer autoload metadata exposes testable PHP source for the repository.
+     *
+     * @param list<string> $apiDirectories the resolved API directories exposed by Composer autoload metadata
+     */
+    private function resolveHasPhpSourceFiles(array $apiDirectories): bool
+    {
+        if ([] !== $apiDirectories) {
+            return true;
+        }
+
+        foreach (self::API_AUTOLOAD_TYPES as $autoloadType) {
+            foreach ($this->normalizeAutoloadPaths($this->composer->getAutoload($autoloadType)) as $path) {
+                $absolutePath = $this->filesystem->getAbsolutePath($path);
+
+                if (! \is_string($absolutePath)) {
+                    continue;
+                }
+
+                if (is_file($absolutePath) && str_ends_with(strtolower($absolutePath), '.php')) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
     /**
      * Flattens Composer autoload path definitions into a normalized list of non-empty paths.
      *

tests/Console/Command/WikiCommandTest.php

@@ -33,6 +33,7 @@
 use FastForward\DevTools\Path\WorkingProjectPathResolver;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\Attributes\TestWith;
 use PHPUnit\Framework\Attributes\UsesClass;
 use PHPUnit\Framework\Attributes\UsesTrait;
 use PHPUnit\Framework\TestCase;
@@ -226,6 +227,33 @@ public function executeWillSkipWhenWikiTargetDoesNotExist(): void
         self::assertSame(WikiCommand::SUCCESS, $this->executeCommand());
     }
 
+    /**
+     * @return void
+     */
+    #[Test]
+    #[TestWith(['./.github/wiki'])]
+    #[TestWith(['.github/wiki/'])]
+    public function executeWillTreatEquivalentDefaultWikiTargetsAsDefault(string $target): void
+    {
+        $this->input->getOption('target')
+            ->willReturn($target);
+        $this->projectCapabilitiesResolver->resolve(Argument::any(), Argument::any(), Argument::any())
+            ->willReturn(new ProjectCapabilities([], null, false, false, false, false));
+        $this->processQueue->add(Argument::cetera())
+            ->shouldNotBeCalled();
+        $this->logger->info('Generating wiki documentation...', Argument::that(
+            static fn(array $context): bool => $context['input'] instanceof InputInterface
+        ))->shouldBeCalled();
+        $this->logger->log(
+            'warning',
+            'Skipping wiki documentation generation because the wiki target does not exist at {target}.',
+            Argument::that(static fn(array $context): bool => $target === $context['target']
+                && $context['input'] instanceof InputInterface),
+        )->shouldBeCalled();
+
+        self::assertSame(WikiCommand::SUCCESS, $this->executeCommand());
+    }
+
     /**
      * @return void
      */

tests/Project/ProjectCapabilitiesResolverTest.php

@@ -133,6 +133,29 @@ public function resolveWillIgnoreToolingPhpFilesWhenDetectingTestablePhpSource()
         self::assertTrue($capabilities->canGenerateMetrics());
     }
 
+    /**
+     * @return void
+     */
+    #[Test]
+    public function resolveWillDetectPhpSourceFromFileBasedClassmapEntries(): void
+    {
+        mkdir($this->workspace . '/legacy', recursive: true);
+        file_put_contents($this->workspace . '/legacy/LegacyClass.php', "<?php\n\nfinal class LegacyClass {}\n");
+
+        $this->composer->getAutoload('psr-4')
+            ->willReturn([]);
+        $this->composer->getAutoload('psr-0')
+            ->willReturn([]);
+        $this->composer->getAutoload('classmap')
+            ->willReturn(['legacy/LegacyClass.php']);
+
+        $capabilities = $this->resolver->resolve();
+
+        self::assertTrue($capabilities->hasPhpSourceFiles());
+        self::assertTrue($capabilities->canRunTests());
+        self::assertFalse($capabilities->canGenerateApiDocumentation());
+    }
+
     /**
      * @return void
      */