class DebugClassLoader in Zircon Profile 8

Autoloader checking if the class is really defined in the file found.

The ClassLoader will wrap all registered autoloaders and will throw an exception if a file is found but does not declare the class.

@author Fabien Potencier <[e-mail]> @author Christophe Coevoet <[e-mail]> @author Nicolas Grekas <[e-mail]>

Hierarchy

• class \Symfony\Component\Debug\DebugClassLoader

3 files declare their use of DebugClassLoader

ClassNotFoundFatalErrorHandler.php in vendor/symfony/debug/FatalErrorHandler/ClassNotFoundFatalErrorHandler.php

ClassNotFoundFatalErrorHandlerTest.php in vendor/symfony/debug/Tests/FatalErrorHandler/ClassNotFoundFatalErrorHandlerTest.php

DebugClassLoaderTest.php in vendor/symfony/debug/Tests/DebugClassLoaderTest.php

File

vendor/symfony/debug/DebugClassLoader.php, line 25

Namespace

Symfony\Component\Debug

class DebugClassLoader {
  private $classLoader;
  private $isFinder;
  private $wasFinder;
  private static $caseCheck;
  private static $deprecated = array();
  private static $php7Reserved = array(
    'int',
    'float',
    'bool',
    'string',
    'true',
    'false',
    'null',
  );
  private static $darwinCache = array(
    '/' => array(
      '/',
      array(),
    ),
  );

  /**
   * Constructor.
   *
   * @param callable|object $classLoader Passing an object is @deprecated since version 2.5 and support for it will be removed in 3.0
   */
  public function __construct($classLoader) {
    $this->wasFinder = is_object($classLoader) && method_exists($classLoader, 'findFile');
    if ($this->wasFinder) {
      @trigger_error('The ' . __METHOD__ . ' method will no longer support receiving an object into its $classLoader argument in 3.0.', E_USER_DEPRECATED);
      $this->classLoader = array(
        $classLoader,
        'loadClass',
      );
      $this->isFinder = true;
    }
    else {
      $this->classLoader = $classLoader;
      $this->isFinder = is_array($classLoader) && method_exists($classLoader[0], 'findFile');
    }
    if (!isset(self::$caseCheck)) {
      self::$caseCheck = false !== stripos(PHP_OS, 'win') ? false !== stripos(PHP_OS, 'darwin') ? 2 : 1 : 0;
    }
  }

  /**
   * Gets the wrapped class loader.
   *
   * @return callable|object A class loader. Since version 2.5, returning an object is @deprecated and support for it will be removed in 3.0
   */
  public function getClassLoader() {
    return $this->wasFinder ? $this->classLoader[0] : $this->classLoader;
  }

  /**
   * Wraps all autoloaders.
   */
  public static function enable() {

    // Ensures we don't hit https://bugs.php.net/42098
    class_exists('Symfony\\Component\\Debug\\ErrorHandler');
    class_exists('Psr\\Log\\LogLevel');
    if (!is_array($functions = spl_autoload_functions())) {
      return;
    }
    foreach ($functions as $function) {
      spl_autoload_unregister($function);
    }
    foreach ($functions as $function) {
      if (!is_array($function) || !$function[0] instanceof self) {
        $function = array(
          new static($function),
          'loadClass',
        );
      }
      spl_autoload_register($function);
    }
  }

  /**
   * Disables the wrapping.
   */
  public static function disable() {
    if (!is_array($functions = spl_autoload_functions())) {
      return;
    }
    foreach ($functions as $function) {
      spl_autoload_unregister($function);
    }
    foreach ($functions as $function) {
      if (is_array($function) && $function[0] instanceof self) {
        $function = $function[0]
          ->getClassLoader();
      }
      spl_autoload_register($function);
    }
  }

  /**
   * Finds a file by class name.
   *
   * @param string $class A class name to resolve to file
   *
   * @return string|null
   *
   * @deprecated since version 2.5, to be removed in 3.0.
   */
  public function findFile($class) {
    @trigger_error('The ' . __METHOD__ . ' method is deprecated since version 2.5 and will be removed in 3.0.', E_USER_DEPRECATED);
    if ($this->wasFinder) {
      return $this->classLoader[0]
        ->findFile($class);
    }
  }

  /**
   * Loads the given class or interface.
   *
   * @param string $class The name of the class
   *
   * @return bool|null True, if loaded
   *
   * @throws \RuntimeException
   */
  public function loadClass($class) {
    ErrorHandler::stackErrors();
    try {
      if ($this->isFinder) {
        if ($file = $this->classLoader[0]
          ->findFile($class)) {
          require $file;
        }
      }
      else {
        call_user_func($this->classLoader, $class);
        $file = false;
      }
    } catch (\Exception $e) {
      ErrorHandler::unstackErrors();
      throw $e;
    }
    ErrorHandler::unstackErrors();
    $exists = class_exists($class, false) || interface_exists($class, false) || function_exists('trait_exists') && trait_exists($class, false);
    if ('\\' === $class[0]) {
      $class = substr($class, 1);
    }
    if ($exists) {
      $refl = new \ReflectionClass($class);
      $name = $refl
        ->getName();
      if ($name !== $class && 0 === strcasecmp($name, $class)) {
        throw new \RuntimeException(sprintf('Case mismatch between loaded and declared class names: %s vs %s', $class, $name));
      }
      if (in_array(strtolower($refl
        ->getShortName()), self::$php7Reserved)) {
        @trigger_error(sprintf('%s uses a reserved class name (%s) that will break on PHP 7 and higher', $name, $refl
          ->getShortName()), E_USER_DEPRECATED);
      }
      elseif (preg_match('#\\n \\* @deprecated (.*?)\\r?\\n \\*(?: @|/$)#s', $refl
        ->getDocComment(), $notice)) {
        self::$deprecated[$name] = preg_replace('#\\s*\\r?\\n \\* +#', ' ', $notice[1]);
      }
      else {
        if (2 > ($len = 1 + (strpos($name, '\\', 1 + strpos($name, '\\')) ?: strpos($name, '_')))) {
          $len = 0;
          $ns = '';
        }
        else {
          switch ($ns = substr($name, 0, $len)) {
            case 'Symfony\\Bridge\\':
            case 'Symfony\\Bundle\\':
            case 'Symfony\\Component\\':
              $ns = 'Symfony\\';
              $len = strlen($ns);
              break;
          }
        }
        $parent = $refl
          ->getParentClass();
        if (!$parent || strncmp($ns, $parent->name, $len)) {
          if ($parent && isset(self::$deprecated[$parent->name]) && strncmp($ns, $parent->name, $len)) {
            @trigger_error(sprintf('The %s class extends %s that is deprecated %s', $name, $parent->name, self::$deprecated[$parent->name]), E_USER_DEPRECATED);
          }
          foreach ($refl
            ->getInterfaceNames() as $interface) {
            if (isset(self::$deprecated[$interface]) && strncmp($ns, $interface, $len) && !($parent && $parent
              ->implementsInterface($interface))) {
              @trigger_error(sprintf('The %s %s %s that is deprecated %s', $name, $refl
                ->isInterface() ? 'interface extends' : 'class implements', $interface, self::$deprecated[$interface]), E_USER_DEPRECATED);
            }
          }
        }
      }
    }
    if ($file) {
      if (!$exists) {
        if (false !== strpos($class, '/')) {
          throw new \RuntimeException(sprintf('Trying to autoload a class with an invalid name "%s". Be careful that the namespace separator is "\\" in PHP, not "/".', $class));
        }
        throw new \RuntimeException(sprintf('The autoloader expected class "%s" to be defined in file "%s". The file was found but the class was not in it, the class name or namespace probably has a typo.', $class, $file));
      }
      if (self::$caseCheck) {
        $real = explode('\\', $class . strrchr($file, '.'));
        $tail = explode(DIRECTORY_SEPARATOR, str_replace('/', DIRECTORY_SEPARATOR, $file));
        $i = count($tail) - 1;
        $j = count($real) - 1;
        while (isset($tail[$i], $real[$j]) && $tail[$i] === $real[$j]) {
          --$i;
          --$j;
        }
        array_splice($tail, 0, $i + 1);
      }
      if (self::$caseCheck && $tail) {
        $tail = DIRECTORY_SEPARATOR . implode(DIRECTORY_SEPARATOR, $tail);
        $tailLen = strlen($tail);
        $real = $refl
          ->getFileName();
        if (2 === self::$caseCheck) {

          // realpath() on MacOSX doesn't normalize the case of characters
          $i = 1 + strrpos($real, '/');
          $file = substr($real, $i);
          $real = substr($real, 0, $i);
          if (isset(self::$darwinCache[$real])) {
            $kDir = $real;
          }
          else {
            $kDir = strtolower($real);
            if (isset(self::$darwinCache[$kDir])) {
              $real = self::$darwinCache[$kDir][0];
            }
            else {
              $dir = getcwd();
              chdir($real);
              $real = getcwd() . '/';
              chdir($dir);
              $dir = $real;
              $k = $kDir;
              $i = strlen($dir) - 1;
              while (!isset(self::$darwinCache[$k])) {
                self::$darwinCache[$k] = array(
                  $dir,
                  array(),
                );
                self::$darwinCache[$dir] =& self::$darwinCache[$k];
                while ('/' !== $dir[--$i]) {
                }
                $k = substr($k, 0, ++$i);
                $dir = substr($dir, 0, $i--);
              }
            }
          }
          $dirFiles = self::$darwinCache[$kDir][1];
          if (isset($dirFiles[$file])) {
            $kFile = $file;
          }
          else {
            $kFile = strtolower($file);
            if (!isset($dirFiles[$kFile])) {
              foreach (scandir($real, 2) as $f) {
                if ('.' !== $f[0]) {
                  $dirFiles[$f] = $f;
                  if ($f === $file) {
                    $kFile = $k = $file;
                  }
                  elseif ($f !== ($k = strtolower($f))) {
                    $dirFiles[$k] = $f;
                  }
                }
              }
              self::$darwinCache[$kDir][1] = $dirFiles;
            }
          }
          $real .= $dirFiles[$kFile];
        }
        if (0 === substr_compare($real, $tail, -$tailLen, $tailLen, true) && 0 !== substr_compare($real, $tail, -$tailLen, $tailLen, false)) {
          throw new \RuntimeException(sprintf('Case mismatch between class and real file names: %s vs %s in %s', substr($tail, -$tailLen + 1), substr($real, -$tailLen + 1), substr($real, 0, -$tailLen + 1)));
        }
      }
      return true;
    }
  }

}

Members

Name	Modifiers	Type	Description	Overrides
DebugClassLoader::$caseCheck	private static	property
DebugClassLoader::$classLoader	private	property
DebugClassLoader::$darwinCache	private static	property
DebugClassLoader::$deprecated	private static	property
DebugClassLoader::$isFinder	private	property
DebugClassLoader::$php7Reserved	private static	property
DebugClassLoader::$wasFinder	private	property
DebugClassLoader::disable	public static	function	Disables the wrapping.
DebugClassLoader::enable	public static	function	Wraps all autoloaders.
DebugClassLoader::findFile Deprecated	public	function	Finds a file by class name.
DebugClassLoader::getClassLoader	public	function	Gets the wrapped class loader.
DebugClassLoader::loadClass	public	function	Loads the given class or interface.
DebugClassLoader::__construct	public	function	Constructor.