vendor/symfony/http-foundation/File/MimeType/MimeTypeGuesser.php line 18

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\HttpFoundation\File\MimeType;
  14. use Symfony\Component\HttpFoundation\File\Exception\AccessDeniedException;
  15. use Symfony\Component\HttpFoundation\File\Exception\FileNotFoundException;
  16. use Symfony\Component\Mime\MimeTypes;
  18. @trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.3, use "%s" instead.', MimeTypeGuesser::class, MimeTypes::class), \E_USER_DEPRECATED);
  20. /**
  21.  * A singleton mime type guesser.
  22.  *
  23.  * By default, all mime type guessers provided by the framework are installed
  24.  * (if available on the current OS/PHP setup).
  25.  *
  26.  * You can register custom guessers by calling the register() method on the
  27.  * singleton instance. Custom guessers are always called before any default ones.
  28.  *
  29.  *     $guesser = MimeTypeGuesser::getInstance();
  30.  *     $guesser->register(new MyCustomMimeTypeGuesser());
  31.  *
  32.  * If you want to change the order of the default guessers, just re-register your
  33.  * preferred one as a custom one. The last registered guesser is preferred over
  34.  * previously registered ones.
  35.  *
  36.  * Re-registering a built-in guesser also allows you to configure it:
  37.  *
  38.  *     $guesser = MimeTypeGuesser::getInstance();
  39.  *     $guesser->register(new FileinfoMimeTypeGuesser('/path/to/magic/file'));
  40.  *
  41.  * @author Bernhard Schussek <bschussek@gmail.com>
  42.  */
  43. class MimeTypeGuesser implements MimeTypeGuesserInterface
  44. {
  45.     /**
  46.      * The singleton instance.
  47.      *
  48.      * @var MimeTypeGuesser
  49.      */
  50.     private static $instance = null;
  52.     /**
  53.      * All registered MimeTypeGuesserInterface instances.
  54.      *
  55.      * @var array
  56.      */
  57.     protected $guessers = [];
  59.     /**
  60.      * Returns the singleton instance.
  61.      *
  62.      * @return self
  63.      */
  64.     public static function getInstance()
  65.     {
  66.         if (null === self::$instance) {
  67.             self::$instance = new self();
  68.         }
  70.         return self::$instance;
  71.     }
  73.     /**
  74.      * Resets the singleton instance.
  75.      */
  76.     public static function reset()
  77.     {
  78.         self::$instance = null;
  79.     }
  81.     /**
  82.      * Registers all natively provided mime type guessers.
  83.      */
  84.     private function __construct()
  85.     {
  86.         $this->register(new FileBinaryMimeTypeGuesser());
  87.         $this->register(new FileinfoMimeTypeGuesser());
  88.     }
  90.     /**
  91.      * Registers a new mime type guesser.
  92.      *
  93.      * When guessing, this guesser is preferred over previously registered ones.
  94.      */
  95.     public function register(MimeTypeGuesserInterface $guesser)
  96.     {
  97.         array_unshift($this->guessers, $guesser);
  98.     }
  100.     /**
  101.      * Tries to guess the mime type of the given file.
  102.      *
  103.      * The file is passed to each registered mime type guesser in reverse order
  104.      * of their registration (last registered is queried first). Once a guesser
  105.      * returns a value that is not NULL, this method terminates and returns the
  106.      * value.
  107.      *
  108.      * @param string $path The path to the file
  109.      *
  110.      * @return string The mime type or NULL, if none could be guessed
  111.      *
  112.      * @throws \LogicException
  113.      * @throws FileNotFoundException
  114.      * @throws AccessDeniedException
  115.      */
  116.     public function guess($path)
  117.     {
  118.         if (!is_file($path)) {
  119.             throw new FileNotFoundException($path);
  120.         }
  122.         if (!is_readable($path)) {
  123.             throw new AccessDeniedException($path);
  124.         }
  126.         foreach ($this->guessers as $guesser) {
  127.             if (null !== $mimeType = $guesser->guess($path)) {
  128.                 return $mimeType;
  129.             }
  130.         }
  132.         if (2 === \count($this->guessers) && !FileBinaryMimeTypeGuesser::isSupported() && !FileinfoMimeTypeGuesser::isSupported()) {
  133.             throw new \LogicException('Unable to guess the mime type as no guessers are available (Did you enable the php_fileinfo extension?).');
  134.         }
  136.         return null;
  137.     }
  138. }