CodeExplorer

findFile example

            }

            $offsets[$getSymbols] = $i;
        }

        return true;
    }

    public function findFile(string $class): ?string
    {
        return $this->isFinder ? ($this->classLoader[0]->findFile($class) ?: null) : null;
    }

    /** * Loads the given class or interface. * * @throws \RuntimeException */
    public function loadClass(string $class): void
    {
        $e = error_reporting(error_reporting() | \E_PARSE | \E_ERROR | \E_CORE_ERROR | \E_COMPILE_ERROR);

class MockFileFinderTest extends TestCase {

  /** * @covers ::create * @covers ::findFile */
  public function testFindFile() {
    $tmp = MockFileFinder::create('testfilename.txt');
    $this->assertEquals('testfilename.txt', $tmp->findFile('n/a'));
    $this->assertEquals('testfilename.txt', $tmp->findFile('SomeClass'));
  }

}

  private static function alterAssert(ClassLoader $autoloader): void {
    // If the class exists already there is nothing we can do. Hopefully this     // is happening because this has been called already. The call from     // \Drupal\Core\Test\TestDiscovery::registerTestNamespaces() necessitates     // this protection.     if (class_exists('PHPUnit\Framework\Assert', FALSE)) {
      return;
    }
    // Mutate Assert code to make it forward compatible with different PhpUnit     // versions, by adding Symfony's PHPUnit-bridge PolyfillAssertTrait.     $alteredFile = $autoloader->findFile('PHPUnit\Framework\Assert');
    $phpunit_dir = dirname($alteredFile, 3);
    $alteredCode = file_get_contents($alteredFile);
    $alteredCode = preg_replace('/abstract class Assert[^\{]+\{/', '$0 ' . \PHP_EOL . " use \Symfony\Bridge\PhpUnit\Legacy\PolyfillAssertTrait;" . \PHP_EOL, $alteredCode, 1);
    include static::flushAlteredCodeToFile('Assert.php', $alteredCode);
  }

  /** * Alters the TestCase class. * * @param \Composer\Autoload\ClassLoader $autoloader * The autoloader. * * @throws \ReflectionException */

$file = null;

        foreach (spl_autoload_functions() as $autoloader) {
            if (!\is_array($autoloader)) {
                continue;
            }

            if ($autoloader[0] instanceof DebugClassLoader) {
                $autoloader = $autoloader[0]->getClassLoader();
            }

            if (!\is_array($autoloader) || !$autoloader[0] instanceof ClassLoader || !$autoloader[0]->findFile(__CLASS__)) {
                continue;
            }

            foreach (get_declared_classes() as $class) {
                if (str_starts_with($class, 'ComposerAutoloaderInit') && $class::getLoader() === $autoloader[0]) {
                    $file = \dirname((new \ReflectionClass($class))->getFileName(), 2).'/autoload.php';

                    if (null !== $this->targetDirRegex && preg_match($this->targetDirRegex.'A', $file)) {
                        return $file;
                    }
                }
            }

return $pluginRootPath;
    }

    /** * @throws KernelPluginLoaderException */
    private function instantiatePlugins(string $projectDir): void
    {
        foreach ($this->pluginInfos as $pluginData) {
            $className = $pluginData['baseClass'];

            $pluginClassFilePath = $this->classLoader->findFile($className);
            if (!class_exists($className) || !$pluginClassFilePath || !file_exists($pluginClassFilePath)) {
                continue;
            }

            /** @var Plugin $plugin */
            $plugin = new $className((bool) $pluginData['active'], $pluginData['path'], $projectDir);

            if (!$plugin instanceof Plugin) {
                $reason = sprintf('Plugin class "%s" must extend "%s"', $plugin::class, Plugin::class);

                throw new KernelPluginLoaderException($pluginData['name'], $reason);
            }

        return [
            'App\\Services\\' => [__DIR__.'/../../fake_app/'],
            'acme\\lib\\' => [__DIR__.'/../acme/lib/'],
            'bar\\lib\\' => [__DIR__.'/../bar/lib/'],
            'fcy\\lib\\' => [__DIR__.'/../fcy/lib/'],
        ];
    }

    public function loadClass($className)
    {
        if ($file = $this->findFile($className)) {
            require $file;
        }
    }

    public function findFile($class)
    {
        foreach ($this->getPrefixesPsr4() as $prefix => $baseDirs) {
            if (0 !== strpos($class, $prefix)) {
                continue;
            }

class ClassFinderTest extends TestCase {

  /** * @covers ::findFile */
  public function testFindFile() {
    $finder = new ClassFinder();

    // The full path is returned therefore only tests with     // assertStringEndsWith() so the test is portable.     $expected_path = str_replace('/', DIRECTORY_SEPARATOR, 'core/tests/Drupal/Tests/Component/ClassFinder/ClassFinderTest.php');
    $this->assertStringEndsWith($expected_path, $finder->findFile(ClassFinderTest::class));
    $class = 'Not\\A\\Class';
    $this->assertNull($finder->findFile($class));

    // Register an autoloader that can find this class.     $loader = new ClassLoader();
    $loader->addClassMap([$class => __FILE__]);
    $loader->register();
    $this->assertEquals(__FILE__, $finder->findFile($class));
    // This shouldn't prevent us from finding the original file.     $this->assertStringEndsWith($expected_path, $finder->findFile(ClassFinderTest::class));

$this->fileRepository->update(
            [['id' => $fileId, 'accessToken' => $token]],
            $context
        );

        return $token;
    }

    public function createFileResponse(Context $context, string $fileId, string $accessToken): Response
    {
        $entity = $this->findFile($context, $fileId);

        $fileAccessToken = (string) $entity->getAccessToken();

        if ($fileAccessToken === '' || $entity->getAccessToken() !== $accessToken || !$this->isModifiedRecently($entity)) {
            throw ImportExportException::invalidFileAccessToken();
        }

        $this->fileRepository->update(
            [['id' => $fileId, 'accessToken' => null]],
            $context
        );

$file = null;

        foreach (spl_autoload_functions() as $autoloader) {
            if (!\is_array($autoloader)) {
                continue;
            }

            if ($autoloader[0] instanceof DebugClassLoader || $autoloader[0] instanceof LegacyDebugClassLoader) {
                $autoloader = $autoloader[0]->getClassLoader();
            }

            if (!\is_array($autoloader) || !$autoloader[0] instanceof ClassLoader || !$autoloader[0]->findFile(__CLASS__)) {
                continue;
            }

            foreach (get_declared_classes() as $class) {
                if (str_starts_with($class, 'ComposerAutoloaderInit') && $class::getLoader() === $autoloader[0]) {
                    $file = \dirname((new \ReflectionClass($class))->getFileName(), 2).'/autoload.php';

                    if (null !== $this->targetDirRegex && preg_match($this->targetDirRegex.'A', $file)) {
                        return $file;
                    }
                }
            }

        $this->finder                  = $finder;
        $this->classAnnotationOptimize = $classAnnotationOptimize;
    }

    /** * @return void */
    protected function parse()
    {
        $fileName = $this->finder->findFile($this->className);

        if ($this->parsed || ! $fileName) {
            return;
        }
        $this->parsed = true;
        $contents     = file_get_contents($fileName);
        if ($this->classAnnotationOptimize) {
            $regex = sprintf('/\A.*^\s*((abstract|final)\s+)?class\s+%s\s+/sm', $this->shortClassName);

            if (preg_match($regex, $contents, $matches)) {
                $contents = $matches[0];
            }

    }

    /** * Loads the given class or interface. * * @param string $class The name of the class * @return true|null True if loaded, null otherwise */
    public function loadClass($class)
    {
        if ($file = $this->findFile($class)) {
            includeFile($file);

            return true;
        }

        return null;
    }

    /** * Finds the path to the file where the class is defined. * * @param string $class The name of the class * * @return string|false The path if found, false otherwise */

Attention: date(Defaults::(STORAGE_DATE_TIME_FORMAT|STORAGE_DATE_FORMAT)) has been used in "%s". Please be aware that date doesn't support microseconds and is therefore incompatible with our default datetime format. Please use (new \DateTime())->format(STORAGE_DATE_TIME_FORMAT) instead. EOF;

        $classLoader = KernelLifecycleManager::getClassLoader();

        $migrationLoader = $this->getContainer()->get(MigrationCollectionLoader::class);
        foreach ($migrationLoader->collectAll() as $collection) {
            foreach (array_keys($collection->getMigrationSteps()) as $className) {
                /** @var string $file */
                $file = $classLoader->findFile($className);

                $result = preg_match_all(
                    '/date$Defaults::(STORAGE_DATE_TIME_FORMAT|STORAGE_DATE_FORMAT).*$;/',
                    (string) file_get_contents($file),
                    $matches
                );

                static::assertSame(0, $result, sprintf($errorTemplate, basename($file)));
            }
        }
    }
}

use Shopware\Core\Migration\V6_3\Migration1536233560BasicData;

/** * @internal * * @coversNothing */
class BasicDataUntouchedTest extends TestCase
{
    public function testBasicDataUntouched(): void
    {
        $file = KernelLifecycleManager::getClassLoader()->findFile(Migration1536233560BasicData::class);
        static::assertIsString($file);

        static::assertSame(
            '803f6b644dc0c3d59b523fa3c02fdbaa28acbbff',
            sha1_file($file),
            'BasicData migration has changed. This is not allowed.'
        );
    }
}

if (!$error instanceof NoDeprecationFoundException) {
                    $invalidFiles[$filePath] = $error->getMessage();
                }
            }
        }

        static::assertEmpty($invalidFiles, print_r($invalidFiles, true));
    }

    private function getPathForClass(string $className): string
    {
        $path = realpath(\dirname((string) KernelLifecycleManager::getClassLoader()->findFile($className)) . '/../');

        if ($path === false) {
            throw new \LogicException("could not locate filepath for class {$className}");
        }

        return $path;
    }

    private function getDeprecationTagTester(): AnnotationTagTester
    {
        if ($this->deprecationTagTester === null) {