nextcloud / server

lib/private/Files/Type/Detection.php

Indentation +351 added lines, -351 removed lines

@@ -22,355 +22,355 @@
  * @package OC\Files\Type
  */
 class Detection implements IMimeTypeDetector {
-	private const CUSTOM_MIMETYPEMAPPING = 'mimetypemapping.json';
-	private const CUSTOM_MIMETYPEALIASES = 'mimetypealiases.json';
-	private const CUSTOM_MIMETYPENAMES = 'mimetypenames.json';
-
-	/** @var array<list{string, string|null}> */
-	protected array $mimeTypes = [];
-	protected array $secureMimeTypes = [];
-
-	protected array $mimeTypeIcons = [];
-	/** @var array<string,string> */
-	protected array $mimeTypeAlias = [];
-	/** @var array<string,string> */
-	protected array $mimeTypesNames = [];
-
-	public function __construct(
-		private IURLGenerator $urlGenerator,
-		private LoggerInterface $logger,
-		private string $customConfigDir,
-		private string $defaultConfigDir,
-	) {
-	}
-
-	/**
-	 * Add an extension -> MIME type mapping
-	 *
-	 * $mimeType is the assumed correct mime type
-	 * The optional $secureMimeType is an alternative to send to send
-	 * to avoid potential XSS.
-	 *
-	 * @param string $extension
-	 * @param string $mimeType
-	 * @param string|null $secureMimeType
-	 */
-	public function registerType(
-		string $extension,
-		string $mimeType,
-		?string $secureMimeType = null): void {
-		// Make sure the extension is a string
-		// https://github.com/nextcloud/server/issues/42902
-		$this->mimeTypes[$extension] = [$mimeType, $secureMimeType];
-		$this->secureMimeTypes[$mimeType] = $secureMimeType ?? $mimeType;
-	}
-
-	/**
-	 * Add an array of extension -> MIME type mappings
-	 *
-	 * The mimeType value is in itself an array where the first index is
-	 * the assumed correct mimeType and the second is either a secure alternative
-	 * or null if the correct is considered secure.
-	 *
-	 * @param array $types
-	 */
-	public function registerTypeArray(array $types): void {
-		// Register the types,
-		foreach ($types as $extension => $mimeType) {
-			$this->registerType((string)$extension, $mimeType[0], $mimeType[1] ?? null);
-		}
-
-		// Update the alternative mimeTypes to avoid having to look them up each time.
-		foreach ($this->mimeTypes as $extension => $mimeType) {
-			if (str_starts_with((string)$extension, '_comment')) {
-				continue;
-			}
-
-			$this->secureMimeTypes[$mimeType[0]] = $mimeType[1] ?? $mimeType[0];
-			if (isset($mimeType[1])) {
-				$this->secureMimeTypes[$mimeType[1]] = $mimeType[1];
-			}
-		}
-	}
-
-	private function loadCustomDefinitions(string $fileName, array $definitions): array {
-		if (file_exists($this->customConfigDir . '/' . $fileName)) {
-			$custom = json_decode(file_get_contents($this->customConfigDir . '/' . $fileName), true);
-			if (json_last_error() === JSON_ERROR_NONE) {
-				$definitions = array_replace($definitions, $custom);
-			} else {
-				$this->logger->warning('Failed to parse ' . $fileName . ': ' . json_last_error_msg());
-			}
-		}
-		return $definitions;
-	}
-
-	/**
-	 * Add the MIME type aliases if they are not yet present
-	 */
-	private function loadAliases(): void {
-		if (!empty($this->mimeTypeAlias)) {
-			return;
-		}
-
-		$this->mimeTypeAlias = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypealiases.dist.json'), true);
-		$this->mimeTypeAlias = $this->loadCustomDefinitions(self::CUSTOM_MIMETYPEALIASES, $this->mimeTypeAlias);
-	}
-
-	/**
-	 * @return array<string,string>
-	 */
-	public function getAllAliases(): array {
-		$this->loadAliases();
-		return $this->mimeTypeAlias;
-	}
-
-	public function getOnlyDefaultAliases(): array {
-		$this->loadMappings();
-		$this->mimeTypeAlias = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypealiases.dist.json'), true);
-		return $this->mimeTypeAlias;
-	}
-
-	/**
-	 * Add MIME type mappings if they are not yet present
-	 */
-	private function loadMappings(): void {
-		if (!empty($this->mimeTypes)) {
-			return;
-		}
-
-		$mimeTypeMapping = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypemapping.dist.json'), true);
-		$mimeTypeMapping = $this->loadCustomDefinitions(self::CUSTOM_MIMETYPEMAPPING, $mimeTypeMapping);
-
-		$this->registerTypeArray($mimeTypeMapping);
-	}
-
-	/**
-	 * @return array<list{string, string|null}>
-	 */
-	public function getAllMappings(): array {
-		$this->loadMappings();
-		return $this->mimeTypes;
-	}
-
-	private function loadNamings(): void {
-		if (!empty($this->mimeTypesNames)) {
-			return;
-		}
-
-		$mimeTypeMapping = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypenames.dist.json'), true);
-		$mimeTypeMapping = $this->loadCustomDefinitions(self::CUSTOM_MIMETYPENAMES, $mimeTypeMapping);
-
-		$this->mimeTypesNames = $mimeTypeMapping;
-	}
-
-	/**
-	 * @return array<string,string>
-	 */
-	public function getAllNamings(): array {
-		$this->loadNamings();
-		return $this->mimeTypesNames;
-	}
-
-	/**
-	 * detect MIME type only based on filename, content of file is not used
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public function detectPath($path): string {
-		$this->loadMappings();
-
-		$fileName = basename($path);
-
-		// remove leading dot on hidden files with a file extension
-		$fileName = ltrim($fileName, '.');
-
-		// note: leading dot doesn't qualify as extension
-		if (strpos($fileName, '.') > 0) {
-			// remove versioning extension: name.v1508946057 and transfer extension: name.ocTransferId2057600214.part
-			$fileName = preg_replace('!((\.v\d+)|((\.ocTransferId\d+)?\.part))$!', '', $fileName);
-
-			//try to guess the type by the file extension
-			$extension = strrchr($fileName, '.');
-			if ($extension !== false) {
-				$extension = strtolower($extension);
-				$extension = substr($extension, 1); // remove leading .
-				return $this->mimeTypes[$extension][0] ?? 'application/octet-stream';
-			}
-		}
-
-		return 'application/octet-stream';
-	}
-
-	/**
-	 * Detect MIME type only based on the content of file.
-	 *
-	 * @param string $path
-	 * @return string
-	 * @since 18.0.0
-	 */
-	public function detectContent(string $path): string {
-		$this->loadMappings();
-
-		if (@is_dir($path)) {
-			// directories are easy
-			return 'httpd/unix-directory';
-		}
-
-		if (class_exists(finfo::class)) {
-			$finfo = new finfo(FILEINFO_MIME_TYPE);
-			$mimeType = @$finfo->file($path);
-			if ($mimeType) {
-				$mimeType = $this->getSecureMimeType($mimeType);
-				if ($mimeType !== 'application/octet-stream') {
-					return $mimeType;
-				}
-			}
-		}
-
-		if (str_starts_with($path, 'file://')) {
-			// Is the file wrapped in a stream?
-			return 'application/octet-stream';
-		}
-
-		if (function_exists('mime_content_type')) {
-			// use mime magic extension if available
-			$mimeType = mime_content_type($path);
-			if ($mimeType) {
-				$mimeType = $this->getSecureMimeType($mimeType);
-				if ($mimeType !== 'application/octet-stream') {
-					return $mimeType;
-				}
-			}
-		}
-
-		$binaryFinder = \OCP\Server::get(IBinaryFinder::class);
-		$program = $binaryFinder->findBinaryPath('file');
-		if ($program !== false) {
-			// it looks like we have a 'file' command,
-			// lets see if it does have mime support
-			$path = escapeshellarg($path);
-			$fp = popen("test -f $path && $program -b --mime-type $path", 'r');
-			if ($fp !== false) {
-				$mimeType = fgets($fp);
-				pclose($fp);
-				if ($mimeType) {
-					//trim the newline
-					$mimeType = trim($mimeType);
-					$mimeType = $this->getSecureMimeType($mimeType);
-					return $mimeType;
-				}
-			}
-		}
-
-		return 'application/octet-stream';
-	}
-
-	/**
-	 * Detect MIME type based on both filename and content
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public function detect($path): string {
-		$mimeType = $this->detectPath($path);
-
-		if ($mimeType !== 'application/octet-stream') {
-			return $mimeType;
-		}
-
-		return $this->detectContent($path);
-	}
-
-	/**
-	 * Detect MIME type based on the content of a string
-	 *
-	 * @param string $data
-	 * @return string
-	 */
-	public function detectString($data): string {
-		if (class_exists(finfo::class)) {
-			$finfo = new finfo(FILEINFO_MIME_TYPE);
-			$mimeType = $finfo->buffer($data);
-			if ($mimeType) {
-				return $mimeType;
-			}
-		}
-
-		$tmpFile = \OCP\Server::get(ITempManager::class)->getTemporaryFile();
-		$fh = fopen($tmpFile, 'wb');
-		fwrite($fh, $data, 8024);
-		fclose($fh);
-		$mimeType = $this->detect($tmpFile);
-		unset($tmpFile);
-		return $mimeType;
-	}
-
-	/**
-	 * Get a secure MIME type that won't expose potential XSS.
-	 *
-	 * @param string $mimeType
-	 * @return string
-	 */
-	public function getSecureMimeType($mimeType): string {
-		$this->loadMappings();
-
-		return $this->secureMimeTypes[$mimeType] ?? 'application/octet-stream';
-	}
-
-	/**
-	 * Get path to the icon of a file type
-	 * @param string $mimeType the MIME type
-	 * @return string the url
-	 */
-	public function mimeTypeIcon($mimeType): string {
-		$this->loadAliases();
-
-		while (isset($this->mimeTypeAlias[$mimeType])) {
-			$mimeType = $this->mimeTypeAlias[$mimeType];
-		}
-		if (isset($this->mimeTypeIcons[$mimeType])) {
-			return $this->mimeTypeIcons[$mimeType];
-		}
-
-		// Replace slash and backslash with a minus
-		$icon = str_replace(['/', '\\'], '-', $mimeType);
-
-		// Is it a dir?
-		if ($mimeType === 'dir') {
-			$this->mimeTypeIcons[$mimeType] = $this->urlGenerator->imagePath('core', 'filetypes/folder.svg');
-			return $this->mimeTypeIcons[$mimeType];
-		}
-		if ($mimeType === 'dir-shared') {
-			$this->mimeTypeIcons[$mimeType] = $this->urlGenerator->imagePath('core', 'filetypes/folder-shared.svg');
-			return $this->mimeTypeIcons[$mimeType];
-		}
-		if ($mimeType === 'dir-external') {
-			$this->mimeTypeIcons[$mimeType] = $this->urlGenerator->imagePath('core', 'filetypes/folder-external.svg');
-			return $this->mimeTypeIcons[$mimeType];
-		}
-
-		// Icon exists?
-		try {
-			$this->mimeTypeIcons[$mimeType] = $this->urlGenerator->imagePath('core', 'filetypes/' . $icon . '.svg');
-			return $this->mimeTypeIcons[$mimeType];
-		} catch (\RuntimeException $e) {
-			// Specified image not found
-		}
-
-		// Try only the first part of the filetype
-		if (strpos($icon, '-')) {
-			$mimePart = substr($icon, 0, strpos($icon, '-'));
-			try {
-				$this->mimeTypeIcons[$mimeType] = $this->urlGenerator->imagePath('core', 'filetypes/' . $mimePart . '.svg');
-				return $this->mimeTypeIcons[$mimeType];
-			} catch (\RuntimeException $e) {
-				// Image for the first part of the MIME type not found
-			}
-		}
-
-		$this->mimeTypeIcons[$mimeType] = $this->urlGenerator->imagePath('core', 'filetypes/file.svg');
-		return $this->mimeTypeIcons[$mimeType];
-	}
+    private const CUSTOM_MIMETYPEMAPPING = 'mimetypemapping.json';
+    private const CUSTOM_MIMETYPEALIASES = 'mimetypealiases.json';
+    private const CUSTOM_MIMETYPENAMES = 'mimetypenames.json';
+
+    /** @var array<list{string, string|null}> */
+    protected array $mimeTypes = [];
+    protected array $secureMimeTypes = [];
+
+    protected array $mimeTypeIcons = [];
+    /** @var array<string,string> */
+    protected array $mimeTypeAlias = [];
+    /** @var array<string,string> */
+    protected array $mimeTypesNames = [];
+
+    public function __construct(
+        private IURLGenerator $urlGenerator,
+        private LoggerInterface $logger,
+        private string $customConfigDir,
+        private string $defaultConfigDir,
+    ) {
+    }
+
+    /**
+     * Add an extension -> MIME type mapping
+     *
+     * $mimeType is the assumed correct mime type
+     * The optional $secureMimeType is an alternative to send to send
+     * to avoid potential XSS.
+     *
+     * @param string $extension
+     * @param string $mimeType
+     * @param string|null $secureMimeType
+     */
+    public function registerType(
+        string $extension,
+        string $mimeType,
+        ?string $secureMimeType = null): void {
+        // Make sure the extension is a string
+        // https://github.com/nextcloud/server/issues/42902
+        $this->mimeTypes[$extension] = [$mimeType, $secureMimeType];
+        $this->secureMimeTypes[$mimeType] = $secureMimeType ?? $mimeType;
+    }
+
+    /**
+     * Add an array of extension -> MIME type mappings
+     *
+     * The mimeType value is in itself an array where the first index is
+     * the assumed correct mimeType and the second is either a secure alternative
+     * or null if the correct is considered secure.
+     *
+     * @param array $types
+     */
+    public function registerTypeArray(array $types): void {
+        // Register the types,
+        foreach ($types as $extension => $mimeType) {
+            $this->registerType((string)$extension, $mimeType[0], $mimeType[1] ?? null);
+        }
+
+        // Update the alternative mimeTypes to avoid having to look them up each time.
+        foreach ($this->mimeTypes as $extension => $mimeType) {
+            if (str_starts_with((string)$extension, '_comment')) {
+                continue;
+            }
+
+            $this->secureMimeTypes[$mimeType[0]] = $mimeType[1] ?? $mimeType[0];
+            if (isset($mimeType[1])) {
+                $this->secureMimeTypes[$mimeType[1]] = $mimeType[1];
+            }
+        }
+    }
+
+    private function loadCustomDefinitions(string $fileName, array $definitions): array {
+        if (file_exists($this->customConfigDir . '/' . $fileName)) {
+            $custom = json_decode(file_get_contents($this->customConfigDir . '/' . $fileName), true);
+            if (json_last_error() === JSON_ERROR_NONE) {
+                $definitions = array_replace($definitions, $custom);
+            } else {
+                $this->logger->warning('Failed to parse ' . $fileName . ': ' . json_last_error_msg());
+            }
+        }
+        return $definitions;
+    }
+
+    /**
+     * Add the MIME type aliases if they are not yet present
+     */
+    private function loadAliases(): void {
+        if (!empty($this->mimeTypeAlias)) {
+            return;
+        }
+
+        $this->mimeTypeAlias = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypealiases.dist.json'), true);
+        $this->mimeTypeAlias = $this->loadCustomDefinitions(self::CUSTOM_MIMETYPEALIASES, $this->mimeTypeAlias);
+    }
+
+    /**
+     * @return array<string,string>
+     */
+    public function getAllAliases(): array {
+        $this->loadAliases();
+        return $this->mimeTypeAlias;
+    }
+
+    public function getOnlyDefaultAliases(): array {
+        $this->loadMappings();
+        $this->mimeTypeAlias = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypealiases.dist.json'), true);
+        return $this->mimeTypeAlias;
+    }
+
+    /**
+     * Add MIME type mappings if they are not yet present
+     */
+    private function loadMappings(): void {
+        if (!empty($this->mimeTypes)) {
+            return;
+        }
+
+        $mimeTypeMapping = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypemapping.dist.json'), true);
+        $mimeTypeMapping = $this->loadCustomDefinitions(self::CUSTOM_MIMETYPEMAPPING, $mimeTypeMapping);
+
+        $this->registerTypeArray($mimeTypeMapping);
+    }
+
+    /**
+     * @return array<list{string, string|null}>
+     */
+    public function getAllMappings(): array {
+        $this->loadMappings();
+        return $this->mimeTypes;
+    }
+
+    private function loadNamings(): void {
+        if (!empty($this->mimeTypesNames)) {
+            return;
+        }
+
+        $mimeTypeMapping = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypenames.dist.json'), true);
+        $mimeTypeMapping = $this->loadCustomDefinitions(self::CUSTOM_MIMETYPENAMES, $mimeTypeMapping);
+
+        $this->mimeTypesNames = $mimeTypeMapping;
+    }
+
+    /**
+     * @return array<string,string>
+     */
+    public function getAllNamings(): array {
+        $this->loadNamings();
+        return $this->mimeTypesNames;
+    }
+
+    /**
+     * detect MIME type only based on filename, content of file is not used
+     *
+     * @param string $path
+     * @return string
+     */
+    public function detectPath($path): string {
+        $this->loadMappings();
+
+        $fileName = basename($path);
+
+        // remove leading dot on hidden files with a file extension
+        $fileName = ltrim($fileName, '.');
+
+        // note: leading dot doesn't qualify as extension
+        if (strpos($fileName, '.') > 0) {
+            // remove versioning extension: name.v1508946057 and transfer extension: name.ocTransferId2057600214.part
+            $fileName = preg_replace('!((\.v\d+)|((\.ocTransferId\d+)?\.part))$!', '', $fileName);
+
+            //try to guess the type by the file extension
+            $extension = strrchr($fileName, '.');
+            if ($extension !== false) {
+                $extension = strtolower($extension);
+                $extension = substr($extension, 1); // remove leading .
+                return $this->mimeTypes[$extension][0] ?? 'application/octet-stream';
+            }
+        }
+
+        return 'application/octet-stream';
+    }
+
+    /**
+     * Detect MIME type only based on the content of file.
+     *
+     * @param string $path
+     * @return string
+     * @since 18.0.0
+     */
+    public function detectContent(string $path): string {
+        $this->loadMappings();
+
+        if (@is_dir($path)) {
+            // directories are easy
+            return 'httpd/unix-directory';
+        }
+
+        if (class_exists(finfo::class)) {
+            $finfo = new finfo(FILEINFO_MIME_TYPE);
+            $mimeType = @$finfo->file($path);
+            if ($mimeType) {
+                $mimeType = $this->getSecureMimeType($mimeType);
+                if ($mimeType !== 'application/octet-stream') {
+                    return $mimeType;
+                }
+            }
+        }
+
+        if (str_starts_with($path, 'file://')) {
+            // Is the file wrapped in a stream?
+            return 'application/octet-stream';
+        }
+
+        if (function_exists('mime_content_type')) {
+            // use mime magic extension if available
+            $mimeType = mime_content_type($path);
+            if ($mimeType) {
+                $mimeType = $this->getSecureMimeType($mimeType);
+                if ($mimeType !== 'application/octet-stream') {
+                    return $mimeType;
+                }
+            }
+        }
+
+        $binaryFinder = \OCP\Server::get(IBinaryFinder::class);
+        $program = $binaryFinder->findBinaryPath('file');
+        if ($program !== false) {
+            // it looks like we have a 'file' command,
+            // lets see if it does have mime support
+            $path = escapeshellarg($path);
+            $fp = popen("test -f $path && $program -b --mime-type $path", 'r');
+            if ($fp !== false) {
+                $mimeType = fgets($fp);
+                pclose($fp);
+                if ($mimeType) {
+                    //trim the newline
+                    $mimeType = trim($mimeType);
+                    $mimeType = $this->getSecureMimeType($mimeType);
+                    return $mimeType;
+                }
+            }
+        }
+
+        return 'application/octet-stream';
+    }
+
+    /**
+     * Detect MIME type based on both filename and content
+     *
+     * @param string $path
+     * @return string
+     */
+    public function detect($path): string {
+        $mimeType = $this->detectPath($path);
+
+        if ($mimeType !== 'application/octet-stream') {
+            return $mimeType;
+        }
+
+        return $this->detectContent($path);
+    }
+
+    /**
+     * Detect MIME type based on the content of a string
+     *
+     * @param string $data
+     * @return string
+     */
+    public function detectString($data): string {
+        if (class_exists(finfo::class)) {
+            $finfo = new finfo(FILEINFO_MIME_TYPE);
+            $mimeType = $finfo->buffer($data);
+            if ($mimeType) {
+                return $mimeType;
+            }
+        }
+
+        $tmpFile = \OCP\Server::get(ITempManager::class)->getTemporaryFile();
+        $fh = fopen($tmpFile, 'wb');
+        fwrite($fh, $data, 8024);
+        fclose($fh);
+        $mimeType = $this->detect($tmpFile);
+        unset($tmpFile);
+        return $mimeType;
+    }
+
+    /**
+     * Get a secure MIME type that won't expose potential XSS.
+     *
+     * @param string $mimeType
+     * @return string
+     */
+    public function getSecureMimeType($mimeType): string {
+        $this->loadMappings();
+
+        return $this->secureMimeTypes[$mimeType] ?? 'application/octet-stream';
+    }
+
+    /**
+     * Get path to the icon of a file type
+     * @param string $mimeType the MIME type
+     * @return string the url
+     */
+    public function mimeTypeIcon($mimeType): string {
+        $this->loadAliases();
+
+        while (isset($this->mimeTypeAlias[$mimeType])) {
+            $mimeType = $this->mimeTypeAlias[$mimeType];
+        }
+        if (isset($this->mimeTypeIcons[$mimeType])) {
+            return $this->mimeTypeIcons[$mimeType];
+        }
+
+        // Replace slash and backslash with a minus
+        $icon = str_replace(['/', '\\'], '-', $mimeType);
+
+        // Is it a dir?
+        if ($mimeType === 'dir') {
+            $this->mimeTypeIcons[$mimeType] = $this->urlGenerator->imagePath('core', 'filetypes/folder.svg');
+            return $this->mimeTypeIcons[$mimeType];
+        }
+        if ($mimeType === 'dir-shared') {
+            $this->mimeTypeIcons[$mimeType] = $this->urlGenerator->imagePath('core', 'filetypes/folder-shared.svg');
+            return $this->mimeTypeIcons[$mimeType];
+        }
+        if ($mimeType === 'dir-external') {
+            $this->mimeTypeIcons[$mimeType] = $this->urlGenerator->imagePath('core', 'filetypes/folder-external.svg');
+            return $this->mimeTypeIcons[$mimeType];
+        }
+
+        // Icon exists?
+        try {
+            $this->mimeTypeIcons[$mimeType] = $this->urlGenerator->imagePath('core', 'filetypes/' . $icon . '.svg');
+            return $this->mimeTypeIcons[$mimeType];
+        } catch (\RuntimeException $e) {
+            // Specified image not found
+        }
+
+        // Try only the first part of the filetype
+        if (strpos($icon, '-')) {
+            $mimePart = substr($icon, 0, strpos($icon, '-'));
+            try {
+                $this->mimeTypeIcons[$mimeType] = $this->urlGenerator->imagePath('core', 'filetypes/' . $mimePart . '.svg');
+                return $this->mimeTypeIcons[$mimeType];
+            } catch (\RuntimeException $e) {
+                // Image for the first part of the MIME type not found
+            }
+        }
+
+        $this->mimeTypeIcons[$mimeType] = $this->urlGenerator->imagePath('core', 'filetypes/file.svg');
+        return $this->mimeTypeIcons[$mimeType];
+    }
 }

Spacing +11 added lines, -11 removed lines

@@ -77,12 +77,12 @@ 
 	public function registerTypeArray(array $types): void {
 		// Register the types,
 		foreach ($types as $extension => $mimeType) {
-			$this->registerType((string)$extension, $mimeType[0], $mimeType[1] ?? null);
+			$this->registerType((string) $extension, $mimeType[0], $mimeType[1] ?? null);
 		}
 
 		// Update the alternative mimeTypes to avoid having to look them up each time.
 		foreach ($this->mimeTypes as $extension => $mimeType) {
-			if (str_starts_with((string)$extension, '_comment')) {
+			if (str_starts_with((string) $extension, '_comment')) {
 				continue;
 			}
 
@@ -94,12 +94,12 @@ 
 	}
 
 	private function loadCustomDefinitions(string $fileName, array $definitions): array {
-		if (file_exists($this->customConfigDir . '/' . $fileName)) {
-			$custom = json_decode(file_get_contents($this->customConfigDir . '/' . $fileName), true);
+		if (file_exists($this->customConfigDir.'/'.$fileName)) {
+			$custom = json_decode(file_get_contents($this->customConfigDir.'/'.$fileName), true);
 			if (json_last_error() === JSON_ERROR_NONE) {
 				$definitions = array_replace($definitions, $custom);
 			} else {
-				$this->logger->warning('Failed to parse ' . $fileName . ': ' . json_last_error_msg());
+				$this->logger->warning('Failed to parse '.$fileName.': '.json_last_error_msg());
 			}
 		}
 		return $definitions;
@@ -113,7 +113,7 @@ 
 			return;
 		}
 
-		$this->mimeTypeAlias = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypealiases.dist.json'), true);
+		$this->mimeTypeAlias = json_decode(file_get_contents($this->defaultConfigDir.'/mimetypealiases.dist.json'), true);
 		$this->mimeTypeAlias = $this->loadCustomDefinitions(self::CUSTOM_MIMETYPEALIASES, $this->mimeTypeAlias);
 	}
 
@@ -127,7 +127,7 @@ 
 
 	public function getOnlyDefaultAliases(): array {
 		$this->loadMappings();
-		$this->mimeTypeAlias = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypealiases.dist.json'), true);
+		$this->mimeTypeAlias = json_decode(file_get_contents($this->defaultConfigDir.'/mimetypealiases.dist.json'), true);
 		return $this->mimeTypeAlias;
 	}
 
@@ -139,7 +139,7 @@ 
 			return;
 		}
 
-		$mimeTypeMapping = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypemapping.dist.json'), true);
+		$mimeTypeMapping = json_decode(file_get_contents($this->defaultConfigDir.'/mimetypemapping.dist.json'), true);
 		$mimeTypeMapping = $this->loadCustomDefinitions(self::CUSTOM_MIMETYPEMAPPING, $mimeTypeMapping);
 
 		$this->registerTypeArray($mimeTypeMapping);
@@ -158,7 +158,7 @@ 
 			return;
 		}
 
-		$mimeTypeMapping = json_decode(file_get_contents($this->defaultConfigDir . '/mimetypenames.dist.json'), true);
+		$mimeTypeMapping = json_decode(file_get_contents($this->defaultConfigDir.'/mimetypenames.dist.json'), true);
 		$mimeTypeMapping = $this->loadCustomDefinitions(self::CUSTOM_MIMETYPENAMES, $mimeTypeMapping);
 
 		$this->mimeTypesNames = $mimeTypeMapping;
@@ -353,7 +353,7 @@ 
 
 		// Icon exists?
 		try {
-			$this->mimeTypeIcons[$mimeType] = $this->urlGenerator->imagePath('core', 'filetypes/' . $icon . '.svg');
+			$this->mimeTypeIcons[$mimeType] = $this->urlGenerator->imagePath('core', 'filetypes/'.$icon.'.svg');
 			return $this->mimeTypeIcons[$mimeType];
 		} catch (\RuntimeException $e) {
 			// Specified image not found
@@ -363,7 +363,7 @@ 
 		if (strpos($icon, '-')) {
 			$mimePart = substr($icon, 0, strpos($icon, '-'));
 			try {
-				$this->mimeTypeIcons[$mimeType] = $this->urlGenerator->imagePath('core', 'filetypes/' . $mimePart . '.svg');
+				$this->mimeTypeIcons[$mimeType] = $this->urlGenerator->imagePath('core', 'filetypes/'.$mimePart.'.svg');
 				return $this->mimeTypeIcons[$mimeType];
 			} catch (\RuntimeException $e) {
 				// Image for the first part of the MIME type not found

tests/lib/Files/Type/DetectionTest.php

Indentation +342 added lines, -342 removed lines

@@ -14,394 +14,394 @@
 use Psr\Log\LoggerInterface;
 
 class DetectionTest extends \Test\TestCase {
-	/** @var Detection */
-	private $detection;
-
-	protected function setUp(): void {
-		parent::setUp();
-		$this->detection = new Detection(
-			Server::get(IURLGenerator::class),
-			Server::get(LoggerInterface::class),
-			\OC::$SERVERROOT . '/config/',
-			\OC::$SERVERROOT . '/resources/config/'
-		);
-	}
-
-	public static function dataDetectPath(): array {
-		return [
-			['foo.txt', 'text/plain'],
-			['foo.png', 'image/png'],
-			['foo.bar.png', 'image/png'],
-			['.hidden.png', 'image/png'],
-			['.hidden.foo.png', 'image/png'],
-			['.hidden/foo.png', 'image/png'],
-			['.hidden/.hidden.png', 'image/png'],
-			['test.jpg/foo.png', 'image/png'],
-			['.png', 'application/octet-stream'],
-			['..hidden', 'application/octet-stream'],
-			['foo', 'application/octet-stream'],
-			['', 'application/octet-stream'],
-			['foo.png.ocTransferId123456789.part', 'image/png'],
-			['foo.png.v1234567890', 'image/png'],
-		];
-	}
-
-	/**
-	 *
-	 * @param string $path
-	 * @param string $expected
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataDetectPath')]
-	public function testDetectPath(string $path, string $expected): void {
-		$this->assertEquals($expected, $this->detection->detectPath($path));
-	}
-
-	public static function dataDetectContent(): array {
-		return [
-			['/', 'httpd/unix-directory'],
-			['/data.tar.gz', 'application/gzip'],
-			['/data.zip', 'application/zip'],
-			['/testimage.mp3', 'audio/mpeg'],
-			['/testimage.png', 'image/png'],
-		];
-	}
-
-	/**
-	 *
-	 * @param string $path
-	 * @param string $expected
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataDetectContent')]
-	public function testDetectContent(string $path, string $expected): void {
-		$this->assertEquals($expected, $this->detection->detectContent(\OC::$SERVERROOT . '/tests/data' . $path));
-	}
-
-	public static function dataDetect(): array {
-		return [
-			['/', 'httpd/unix-directory'],
-			['/data.tar.gz', 'application/gzip'],
-			['/data.zip', 'application/zip'],
-			['/testimagelarge.svg', 'image/svg+xml'],
-			['/testimage.png', 'image/png'],
-		];
-	}
-
-	/**
-	 *
-	 * @param string $path
-	 * @param string $expected
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataDetect')]
-	public function testDetect(string $path, string $expected): void {
-		$this->assertEquals($expected, $this->detection->detect(\OC::$SERVERROOT . '/tests/data' . $path));
-	}
-
-	public function testDetectString(): void {
-		$result = $this->detection->detectString('/data/data.tar.gz');
-		$expected = 'text/plain';
-		$this->assertEquals($expected, $result);
-	}
-
-	public static function dataMimeTypeCustom(): array {
-		return [
-			['123', 'foobar/123'],
-			['a123', 'foobar/123'],
-			['bar', 'foobar/bar'],
-		];
-	}
-
-	/**
-	 *
-	 * @param string $ext
-	 * @param string $mime
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataMimeTypeCustom')]
-	public function testDetectMimeTypeCustom(string $ext, string $mime): void {
-		$tmpDir = sys_get_temp_dir() . '/nc-detect-' . uniqid('', true);
-		mkdir($tmpDir, 0700);
-
-		try {
-			// Create a default / shipped mapping file (dist)
-			file_put_contents($tmpDir . '/mimetypemapping.dist.json', json_encode([]));
-
-			// Create new custom mapping file that should be picked up by Detection
-			file_put_contents($tmpDir . '/mimetypemapping.json', json_encode([$ext => [$mime]]));
-
-			/** @var IURLGenerator $urlGenerator */
-			$urlGenerator = $this->getMockBuilder(IURLGenerator::class)
-				->disableOriginalConstructor()
-				->getMock();
-
-			/** @var LoggerInterface $logger */
-			$logger = $this->createMock(LoggerInterface::class);
-
-			$detection = new Detection($urlGenerator, $logger, $tmpDir, $tmpDir);
-			$mappings = $detection->getAllMappings();
-
-			$this->assertArrayHasKey($ext, $mappings);
-			$this->assertEquals($mime, $detection->detectPath('foo.' . $ext));
-		} finally {
-			// cleanup
-			@unlink($tmpDir . '/mimetypemapping.json');
-			@unlink($tmpDir . '/mimetypemapping.dist.json');
-			@rmdir($tmpDir);
-		}
-	}
-
-	public function testDetectMimeTypePreservesLeadingZeroKeys(): void {
-		$tmpDir = sys_get_temp_dir() . '/nc-detect-' . uniqid();
-		mkdir($tmpDir, 0700);
-		try {
-			// Create a default / shipped mapping file (dist)
-			file_put_contents($tmpDir . '/mimetypemapping.dist.json', json_encode([]));
-
-			// Create new custom mapping file with potentially problematic keys
-			$mappings = [
-				'001' => ['application/x-zeroone', null],
-				'1' => ['application/x-one', null],
-			];
-			file_put_contents($tmpDir . '/mimetypemapping.json', json_encode($mappings));
-
-			/** @var IURLGenerator $urlGenerator */
-			$urlGenerator = $this->getMockBuilder(IURLGenerator::class)
-				->disableOriginalConstructor()
-				->getMock();
-
-			/** @var LoggerInterface $logger */
-			$logger = $this->createMock(LoggerInterface::class);
-
-			$detection = new Detection($urlGenerator, $logger, $tmpDir, $tmpDir);
-			$mappings = $detection->getAllMappings();
-
-			$this->assertArrayHasKey('001', $mappings, 'Expected mapping to contain key "001"');
-			$this->assertArrayHasKey('1', $mappings, 'Expected mapping to contain key "1"');
-
-			$this->assertEquals('application/x-zeroone', $detection->detectPath('foo.001'));
-			$this->assertEquals('application/x-one', $detection->detectPath('foo.1'));
-		} finally {
-			@unlink($tmpDir . '/mimetypemapping.json');
-			@unlink($tmpDir . '/mimetypemapping.dist.json');
-			@rmdir($tmpDir);
-		}
-	}
-
-	public static function dataGetSecureMimeType(): array {
-		return [
-			['image/svg+xml', 'text/plain'],
-			['image/png', 'image/png'],
-		];
-	}
-
-	/**
-	 *
-	 * @param string $mimeType
-	 * @param string $expected
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataGetSecureMimeType')]
-	public function testGetSecureMimeType(string $mimeType, string $expected): void {
-		$this->assertEquals($expected, $this->detection->getSecureMimeType($mimeType));
-	}
-
-	public function testMimeTypeIcon(): void {
-		if (!class_exists('org\\bovigo\\vfs\\vfsStream')) {
-			$this->markTestSkipped('Package vfsStream not installed');
-		}
-		$confDir = \org\bovigo\vfs\vfsStream::setup();
-		$mimetypealiases_dist = \org\bovigo\vfs\vfsStream::newFile('mimetypealiases.dist.json')->at($confDir);
-
-		//Empty alias file
-		$mimetypealiases_dist->setContent(json_encode([], JSON_FORCE_OBJECT));
-
-
-		/*
+    /** @var Detection */
+    private $detection;
+
+    protected function setUp(): void {
+        parent::setUp();
+        $this->detection = new Detection(
+            Server::get(IURLGenerator::class),
+            Server::get(LoggerInterface::class),
+            \OC::$SERVERROOT . '/config/',
+            \OC::$SERVERROOT . '/resources/config/'
+        );
+    }
+
+    public static function dataDetectPath(): array {
+        return [
+            ['foo.txt', 'text/plain'],
+            ['foo.png', 'image/png'],
+            ['foo.bar.png', 'image/png'],
+            ['.hidden.png', 'image/png'],
+            ['.hidden.foo.png', 'image/png'],
+            ['.hidden/foo.png', 'image/png'],
+            ['.hidden/.hidden.png', 'image/png'],
+            ['test.jpg/foo.png', 'image/png'],
+            ['.png', 'application/octet-stream'],
+            ['..hidden', 'application/octet-stream'],
+            ['foo', 'application/octet-stream'],
+            ['', 'application/octet-stream'],
+            ['foo.png.ocTransferId123456789.part', 'image/png'],
+            ['foo.png.v1234567890', 'image/png'],
+        ];
+    }
+
+    /**
+     *
+     * @param string $path
+     * @param string $expected
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataDetectPath')]
+    public function testDetectPath(string $path, string $expected): void {
+        $this->assertEquals($expected, $this->detection->detectPath($path));
+    }
+
+    public static function dataDetectContent(): array {
+        return [
+            ['/', 'httpd/unix-directory'],
+            ['/data.tar.gz', 'application/gzip'],
+            ['/data.zip', 'application/zip'],
+            ['/testimage.mp3', 'audio/mpeg'],
+            ['/testimage.png', 'image/png'],
+        ];
+    }
+
+    /**
+     *
+     * @param string $path
+     * @param string $expected
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataDetectContent')]
+    public function testDetectContent(string $path, string $expected): void {
+        $this->assertEquals($expected, $this->detection->detectContent(\OC::$SERVERROOT . '/tests/data' . $path));
+    }
+
+    public static function dataDetect(): array {
+        return [
+            ['/', 'httpd/unix-directory'],
+            ['/data.tar.gz', 'application/gzip'],
+            ['/data.zip', 'application/zip'],
+            ['/testimagelarge.svg', 'image/svg+xml'],
+            ['/testimage.png', 'image/png'],
+        ];
+    }
+
+    /**
+     *
+     * @param string $path
+     * @param string $expected
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataDetect')]
+    public function testDetect(string $path, string $expected): void {
+        $this->assertEquals($expected, $this->detection->detect(\OC::$SERVERROOT . '/tests/data' . $path));
+    }
+
+    public function testDetectString(): void {
+        $result = $this->detection->detectString('/data/data.tar.gz');
+        $expected = 'text/plain';
+        $this->assertEquals($expected, $result);
+    }
+
+    public static function dataMimeTypeCustom(): array {
+        return [
+            ['123', 'foobar/123'],
+            ['a123', 'foobar/123'],
+            ['bar', 'foobar/bar'],
+        ];
+    }
+
+    /**
+     *
+     * @param string $ext
+     * @param string $mime
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataMimeTypeCustom')]
+    public function testDetectMimeTypeCustom(string $ext, string $mime): void {
+        $tmpDir = sys_get_temp_dir() . '/nc-detect-' . uniqid('', true);
+        mkdir($tmpDir, 0700);
+
+        try {
+            // Create a default / shipped mapping file (dist)
+            file_put_contents($tmpDir . '/mimetypemapping.dist.json', json_encode([]));
+
+            // Create new custom mapping file that should be picked up by Detection
+            file_put_contents($tmpDir . '/mimetypemapping.json', json_encode([$ext => [$mime]]));
+
+            /** @var IURLGenerator $urlGenerator */
+            $urlGenerator = $this->getMockBuilder(IURLGenerator::class)
+                ->disableOriginalConstructor()
+                ->getMock();
+
+            /** @var LoggerInterface $logger */
+            $logger = $this->createMock(LoggerInterface::class);
+
+            $detection = new Detection($urlGenerator, $logger, $tmpDir, $tmpDir);
+            $mappings = $detection->getAllMappings();
+
+            $this->assertArrayHasKey($ext, $mappings);
+            $this->assertEquals($mime, $detection->detectPath('foo.' . $ext));
+        } finally {
+            // cleanup
+            @unlink($tmpDir . '/mimetypemapping.json');
+            @unlink($tmpDir . '/mimetypemapping.dist.json');
+            @rmdir($tmpDir);
+        }
+    }
+
+    public function testDetectMimeTypePreservesLeadingZeroKeys(): void {
+        $tmpDir = sys_get_temp_dir() . '/nc-detect-' . uniqid();
+        mkdir($tmpDir, 0700);
+        try {
+            // Create a default / shipped mapping file (dist)
+            file_put_contents($tmpDir . '/mimetypemapping.dist.json', json_encode([]));
+
+            // Create new custom mapping file with potentially problematic keys
+            $mappings = [
+                '001' => ['application/x-zeroone', null],
+                '1' => ['application/x-one', null],
+            ];
+            file_put_contents($tmpDir . '/mimetypemapping.json', json_encode($mappings));
+
+            /** @var IURLGenerator $urlGenerator */
+            $urlGenerator = $this->getMockBuilder(IURLGenerator::class)
+                ->disableOriginalConstructor()
+                ->getMock();
+
+            /** @var LoggerInterface $logger */
+            $logger = $this->createMock(LoggerInterface::class);
+
+            $detection = new Detection($urlGenerator, $logger, $tmpDir, $tmpDir);
+            $mappings = $detection->getAllMappings();
+
+            $this->assertArrayHasKey('001', $mappings, 'Expected mapping to contain key "001"');
+            $this->assertArrayHasKey('1', $mappings, 'Expected mapping to contain key "1"');
+
+            $this->assertEquals('application/x-zeroone', $detection->detectPath('foo.001'));
+            $this->assertEquals('application/x-one', $detection->detectPath('foo.1'));
+        } finally {
+            @unlink($tmpDir . '/mimetypemapping.json');
+            @unlink($tmpDir . '/mimetypemapping.dist.json');
+            @rmdir($tmpDir);
+        }
+    }
+
+    public static function dataGetSecureMimeType(): array {
+        return [
+            ['image/svg+xml', 'text/plain'],
+            ['image/png', 'image/png'],
+        ];
+    }
+
+    /**
+     *
+     * @param string $mimeType
+     * @param string $expected
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataGetSecureMimeType')]
+    public function testGetSecureMimeType(string $mimeType, string $expected): void {
+        $this->assertEquals($expected, $this->detection->getSecureMimeType($mimeType));
+    }
+
+    public function testMimeTypeIcon(): void {
+        if (!class_exists('org\\bovigo\\vfs\\vfsStream')) {
+            $this->markTestSkipped('Package vfsStream not installed');
+        }
+        $confDir = \org\bovigo\vfs\vfsStream::setup();
+        $mimetypealiases_dist = \org\bovigo\vfs\vfsStream::newFile('mimetypealiases.dist.json')->at($confDir);
+
+        //Empty alias file
+        $mimetypealiases_dist->setContent(json_encode([], JSON_FORCE_OBJECT));
+
+
+        /*
 		 * Test dir mimetype
 		 */
 
-		//Mock UrlGenerator
-		$urlGenerator = $this->getMockBuilder(IURLGenerator::class)
-			->disableOriginalConstructor()
-			->getMock();
+        //Mock UrlGenerator
+        $urlGenerator = $this->getMockBuilder(IURLGenerator::class)
+            ->disableOriginalConstructor()
+            ->getMock();
 
-		/** @var LoggerInterface $logger */
-		$logger = $this->createMock(LoggerInterface::class);
+        /** @var LoggerInterface $logger */
+        $logger = $this->createMock(LoggerInterface::class);
 
-		//Only call the url generator once
-		$urlGenerator->expects($this->once())
-			->method('imagePath')
-			->with($this->equalTo('core'), $this->equalTo('filetypes/folder.png'))
-			->willReturn('folder.svg');
+        //Only call the url generator once
+        $urlGenerator->expects($this->once())
+            ->method('imagePath')
+            ->with($this->equalTo('core'), $this->equalTo('filetypes/folder.png'))
+            ->willReturn('folder.svg');
 
-		$detection = new Detection($urlGenerator, $logger, $confDir->url(), $confDir->url());
-		$mimeType = $detection->mimeTypeIcon('dir');
-		$this->assertEquals('folder.svg', $mimeType);
+        $detection = new Detection($urlGenerator, $logger, $confDir->url(), $confDir->url());
+        $mimeType = $detection->mimeTypeIcon('dir');
+        $this->assertEquals('folder.svg', $mimeType);
 
 
-		/*
+        /*
 		 * Test dir-shareed mimetype
 		 */
-		//Mock UrlGenerator
-		$urlGenerator = $this->getMockBuilder(IURLGenerator::class)
-			->disableOriginalConstructor()
-			->getMock();
+        //Mock UrlGenerator
+        $urlGenerator = $this->getMockBuilder(IURLGenerator::class)
+            ->disableOriginalConstructor()
+            ->getMock();
 
-		//Only call the url generator once
-		$urlGenerator->expects($this->once())
-			->method('imagePath')
-			->with($this->equalTo('core'), $this->equalTo('filetypes/folder-shared.png'))
-			->willReturn('folder-shared.svg');
+        //Only call the url generator once
+        $urlGenerator->expects($this->once())
+            ->method('imagePath')
+            ->with($this->equalTo('core'), $this->equalTo('filetypes/folder-shared.png'))
+            ->willReturn('folder-shared.svg');
 
-		$detection = new Detection($urlGenerator, $logger, $confDir->url(), $confDir->url());
-		$mimeType = $detection->mimeTypeIcon('dir-shared');
-		$this->assertEquals('folder-shared.svg', $mimeType);
+        $detection = new Detection($urlGenerator, $logger, $confDir->url(), $confDir->url());
+        $mimeType = $detection->mimeTypeIcon('dir-shared');
+        $this->assertEquals('folder-shared.svg', $mimeType);
 
 
-		/*
+        /*
 		 * Test dir external
 		 */
 
-		//Mock UrlGenerator
-		$urlGenerator = $this->getMockBuilder(IURLGenerator::class)
-			->disableOriginalConstructor()
-			->getMock();
+        //Mock UrlGenerator
+        $urlGenerator = $this->getMockBuilder(IURLGenerator::class)
+            ->disableOriginalConstructor()
+            ->getMock();
 
-		//Only call the url generator once
-		$urlGenerator->expects($this->once())
-			->method('imagePath')
-			->with($this->equalTo('core'), $this->equalTo('filetypes/folder-external.png'))
-			->willReturn('folder-external.svg');
+        //Only call the url generator once
+        $urlGenerator->expects($this->once())
+            ->method('imagePath')
+            ->with($this->equalTo('core'), $this->equalTo('filetypes/folder-external.png'))
+            ->willReturn('folder-external.svg');
 
-		$detection = new Detection($urlGenerator, $logger, $confDir->url(), $confDir->url());
-		$mimeType = $detection->mimeTypeIcon('dir-external');
-		$this->assertEquals('folder-external.svg', $mimeType);
+        $detection = new Detection($urlGenerator, $logger, $confDir->url(), $confDir->url());
+        $mimeType = $detection->mimeTypeIcon('dir-external');
+        $this->assertEquals('folder-external.svg', $mimeType);
 
 
-		/*
+        /*
 		 * Test complete mimetype
 		 */
 
-		//Mock UrlGenerator
-		$urlGenerator = $this->getMockBuilder(IURLGenerator::class)
-			->disableOriginalConstructor()
-			->getMock();
+        //Mock UrlGenerator
+        $urlGenerator = $this->getMockBuilder(IURLGenerator::class)
+            ->disableOriginalConstructor()
+            ->getMock();
 
-		//Only call the url generator once
-		$urlGenerator->expects($this->once())
-			->method('imagePath')
-			->with($this->equalTo('core'), $this->equalTo('filetypes/my-type.png'))
-			->willReturn('my-type.svg');
+        //Only call the url generator once
+        $urlGenerator->expects($this->once())
+            ->method('imagePath')
+            ->with($this->equalTo('core'), $this->equalTo('filetypes/my-type.png'))
+            ->willReturn('my-type.svg');
 
-		$detection = new Detection($urlGenerator, $logger, $confDir->url(), $confDir->url());
-		$mimeType = $detection->mimeTypeIcon('my-type');
-		$this->assertEquals('my-type.svg', $mimeType);
+        $detection = new Detection($urlGenerator, $logger, $confDir->url(), $confDir->url());
+        $mimeType = $detection->mimeTypeIcon('my-type');
+        $this->assertEquals('my-type.svg', $mimeType);
 
 
-		/*
+        /*
 		 * Test subtype
 		 */
 
-		//Mock UrlGenerator
-		$urlGenerator = $this->getMockBuilder(IURLGenerator::class)
-			->disableOriginalConstructor()
-			->getMock();
-
-		//Only call the url generator once
-		$calls = [
-			['core', 'filetypes/my-type.png'],
-			['core', 'filetypes/my.png'],
-		];
-		$urlGenerator->expects($this->exactly(2))
-			->method('imagePath')
-			->willReturnCallback(
-				function ($appName, $file) use (&$calls) {
-					$expected = array_shift($calls);
-					$this->assertEquals($expected, [$appName, $file]);
-					if ($file === 'filetypes/my.png') {
-						return 'my.svg';
-					}
-					throw new \RuntimeException();
-				}
-			);
-
-		$detection = new Detection($urlGenerator, $logger, $confDir->url(), $confDir->url());
-		$mimeType = $detection->mimeTypeIcon('my-type');
-		$this->assertEquals('my.svg', $mimeType);
-
-
-		/*
+        //Mock UrlGenerator
+        $urlGenerator = $this->getMockBuilder(IURLGenerator::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        //Only call the url generator once
+        $calls = [
+            ['core', 'filetypes/my-type.png'],
+            ['core', 'filetypes/my.png'],
+        ];
+        $urlGenerator->expects($this->exactly(2))
+            ->method('imagePath')
+            ->willReturnCallback(
+                function ($appName, $file) use (&$calls) {
+                    $expected = array_shift($calls);
+                    $this->assertEquals($expected, [$appName, $file]);
+                    if ($file === 'filetypes/my.png') {
+                        return 'my.svg';
+                    }
+                    throw new \RuntimeException();
+                }
+            );
+
+        $detection = new Detection($urlGenerator, $logger, $confDir->url(), $confDir->url());
+        $mimeType = $detection->mimeTypeIcon('my-type');
+        $this->assertEquals('my.svg', $mimeType);
+
+
+        /*
 		 * Test default mimetype
 		 */
 
-		//Mock UrlGenerator
-		$urlGenerator = $this->getMockBuilder(IURLGenerator::class)
-			->disableOriginalConstructor()
-			->getMock();
-
-		//Only call the url generator once
-		$calls = [
-			['core', 'filetypes/foo-bar.png'],
-			['core', 'filetypes/foo.png'],
-			['core', 'filetypes/file.png'],
-		];
-		$urlGenerator->expects($this->exactly(3))
-			->method('imagePath')
-			->willReturnCallback(
-				function ($appName, $file) use (&$calls) {
-					$expected = array_shift($calls);
-					$this->assertEquals($expected, [$appName, $file]);
-					if ($file === 'filetypes/file.png') {
-						return 'file.svg';
-					}
-					throw new \RuntimeException();
-				}
-			);
-
-		$detection = new Detection($urlGenerator, $logger, $confDir->url(), $confDir->url());
-		$mimeType = $detection->mimeTypeIcon('foo-bar');
-		$this->assertEquals('file.svg', $mimeType);
-
-		/*
+        //Mock UrlGenerator
+        $urlGenerator = $this->getMockBuilder(IURLGenerator::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        //Only call the url generator once
+        $calls = [
+            ['core', 'filetypes/foo-bar.png'],
+            ['core', 'filetypes/foo.png'],
+            ['core', 'filetypes/file.png'],
+        ];
+        $urlGenerator->expects($this->exactly(3))
+            ->method('imagePath')
+            ->willReturnCallback(
+                function ($appName, $file) use (&$calls) {
+                    $expected = array_shift($calls);
+                    $this->assertEquals($expected, [$appName, $file]);
+                    if ($file === 'filetypes/file.png') {
+                        return 'file.svg';
+                    }
+                    throw new \RuntimeException();
+                }
+            );
+
+        $detection = new Detection($urlGenerator, $logger, $confDir->url(), $confDir->url());
+        $mimeType = $detection->mimeTypeIcon('foo-bar');
+        $this->assertEquals('file.svg', $mimeType);
+
+        /*
 		 * Test chaching
 		 */
 
-		//Mock UrlGenerator
-		$urlGenerator = $this->getMockBuilder(IURLGenerator::class)
-			->disableOriginalConstructor()
-			->getMock();
+        //Mock UrlGenerator
+        $urlGenerator = $this->getMockBuilder(IURLGenerator::class)
+            ->disableOriginalConstructor()
+            ->getMock();
 
-		//Only call the url generator once
-		$urlGenerator->expects($this->once())
-			->method('imagePath')
-			->with($this->equalTo('core'), $this->equalTo('filetypes/foo-bar.png'))
-			->willReturn('foo-bar.svg');
+        //Only call the url generator once
+        $urlGenerator->expects($this->once())
+            ->method('imagePath')
+            ->with($this->equalTo('core'), $this->equalTo('filetypes/foo-bar.png'))
+            ->willReturn('foo-bar.svg');
 
-		$detection = new Detection($urlGenerator, $logger, $confDir->url(), $confDir->url());
-		$mimeType = $detection->mimeTypeIcon('foo-bar');
-		$this->assertEquals('foo-bar.svg', $mimeType);
-		$mimeType = $detection->mimeTypeIcon('foo-bar');
-		$this->assertEquals('foo-bar.svg', $mimeType);
+        $detection = new Detection($urlGenerator, $logger, $confDir->url(), $confDir->url());
+        $mimeType = $detection->mimeTypeIcon('foo-bar');
+        $this->assertEquals('foo-bar.svg', $mimeType);
+        $mimeType = $detection->mimeTypeIcon('foo-bar');
+        $this->assertEquals('foo-bar.svg', $mimeType);
 
 
 
-		/*
+        /*
 		 * Test aliases
 		 */
 
-		//Put alias
-		$mimetypealiases_dist->setContent(json_encode(['foo' => 'foobar/baz'], JSON_FORCE_OBJECT));
+        //Put alias
+        $mimetypealiases_dist->setContent(json_encode(['foo' => 'foobar/baz'], JSON_FORCE_OBJECT));
 
-		//Mock UrlGenerator
-		$urlGenerator = $this->getMockBuilder(IURLGenerator::class)
-			->disableOriginalConstructor()
-			->getMock();
+        //Mock UrlGenerator
+        $urlGenerator = $this->getMockBuilder(IURLGenerator::class)
+            ->disableOriginalConstructor()
+            ->getMock();
 
-		//Only call the url generator once
-		$urlGenerator->expects($this->once())
-			->method('imagePath')
-			->with($this->equalTo('core'), $this->equalTo('filetypes/foobar-baz.png'))
-			->willReturn('foobar-baz.svg');
+        //Only call the url generator once
+        $urlGenerator->expects($this->once())
+            ->method('imagePath')
+            ->with($this->equalTo('core'), $this->equalTo('filetypes/foobar-baz.png'))
+            ->willReturn('foobar-baz.svg');
 
-		$detection = new Detection($urlGenerator, $logger, $confDir->url(), $confDir->url());
-		$mimeType = $detection->mimeTypeIcon('foo');
-		$this->assertEquals('foobar-baz.svg', $mimeType);
-	}
+        $detection = new Detection($urlGenerator, $logger, $confDir->url(), $confDir->url());
+        $mimeType = $detection->mimeTypeIcon('foo');
+        $this->assertEquals('foobar-baz.svg', $mimeType);
+    }
 }

Spacing +17 added lines, -17 removed lines

@@ -22,8 +22,8 @@ 
 		$this->detection = new Detection(
 			Server::get(IURLGenerator::class),
 			Server::get(LoggerInterface::class),
-			\OC::$SERVERROOT . '/config/',
-			\OC::$SERVERROOT . '/resources/config/'
+			\OC::$SERVERROOT.'/config/',
+			\OC::$SERVERROOT.'/resources/config/'
 		);
 	}
 
@@ -73,7 +73,7 @@ 
 	 */
 	#[\PHPUnit\Framework\Attributes\DataProvider('dataDetectContent')]
 	public function testDetectContent(string $path, string $expected): void {
-		$this->assertEquals($expected, $this->detection->detectContent(\OC::$SERVERROOT . '/tests/data' . $path));
+		$this->assertEquals($expected, $this->detection->detectContent(\OC::$SERVERROOT.'/tests/data'.$path));
 	}
 
 	public static function dataDetect(): array {
@@ -93,7 +93,7 @@ 
 	 */
 	#[\PHPUnit\Framework\Attributes\DataProvider('dataDetect')]
 	public function testDetect(string $path, string $expected): void {
-		$this->assertEquals($expected, $this->detection->detect(\OC::$SERVERROOT . '/tests/data' . $path));
+		$this->assertEquals($expected, $this->detection->detect(\OC::$SERVERROOT.'/tests/data'.$path));
 	}
 
 	public function testDetectString(): void {
@@ -117,15 +117,15 @@ 
 	 */
 	#[\PHPUnit\Framework\Attributes\DataProvider('dataMimeTypeCustom')]
 	public function testDetectMimeTypeCustom(string $ext, string $mime): void {
-		$tmpDir = sys_get_temp_dir() . '/nc-detect-' . uniqid('', true);
+		$tmpDir = sys_get_temp_dir().'/nc-detect-'.uniqid('', true);
 		mkdir($tmpDir, 0700);
 
 		try {
 			// Create a default / shipped mapping file (dist)
-			file_put_contents($tmpDir . '/mimetypemapping.dist.json', json_encode([]));
+			file_put_contents($tmpDir.'/mimetypemapping.dist.json', json_encode([]));
 
 			// Create new custom mapping file that should be picked up by Detection
-			file_put_contents($tmpDir . '/mimetypemapping.json', json_encode([$ext => [$mime]]));
+			file_put_contents($tmpDir.'/mimetypemapping.json', json_encode([$ext => [$mime]]));
 
 			/** @var IURLGenerator $urlGenerator */
 			$urlGenerator = $this->getMockBuilder(IURLGenerator::class)
@@ -139,28 +139,28 @@ 
 			$mappings = $detection->getAllMappings();
 
 			$this->assertArrayHasKey($ext, $mappings);
-			$this->assertEquals($mime, $detection->detectPath('foo.' . $ext));
+			$this->assertEquals($mime, $detection->detectPath('foo.'.$ext));
 		} finally {
 			// cleanup
-			@unlink($tmpDir . '/mimetypemapping.json');
-			@unlink($tmpDir . '/mimetypemapping.dist.json');
+			@unlink($tmpDir.'/mimetypemapping.json');
+			@unlink($tmpDir.'/mimetypemapping.dist.json');
 			@rmdir($tmpDir);
 		}
 	}
 
 	public function testDetectMimeTypePreservesLeadingZeroKeys(): void {
-		$tmpDir = sys_get_temp_dir() . '/nc-detect-' . uniqid();
+		$tmpDir = sys_get_temp_dir().'/nc-detect-'.uniqid();
 		mkdir($tmpDir, 0700);
 		try {
 			// Create a default / shipped mapping file (dist)
-			file_put_contents($tmpDir . '/mimetypemapping.dist.json', json_encode([]));
+			file_put_contents($tmpDir.'/mimetypemapping.dist.json', json_encode([]));
 
 			// Create new custom mapping file with potentially problematic keys
 			$mappings = [
 				'001' => ['application/x-zeroone', null],
 				'1' => ['application/x-one', null],
 			];
-			file_put_contents($tmpDir . '/mimetypemapping.json', json_encode($mappings));
+			file_put_contents($tmpDir.'/mimetypemapping.json', json_encode($mappings));
 
 			/** @var IURLGenerator $urlGenerator */
 			$urlGenerator = $this->getMockBuilder(IURLGenerator::class)
@@ -179,8 +179,8 @@ 
 			$this->assertEquals('application/x-zeroone', $detection->detectPath('foo.001'));
 			$this->assertEquals('application/x-one', $detection->detectPath('foo.1'));
 		} finally {
-			@unlink($tmpDir . '/mimetypemapping.json');
-			@unlink($tmpDir . '/mimetypemapping.dist.json');
+			@unlink($tmpDir.'/mimetypemapping.json');
+			@unlink($tmpDir.'/mimetypemapping.dist.json');
 			@rmdir($tmpDir);
 		}
 	}
@@ -312,7 +312,7 @@ 
 		$urlGenerator->expects($this->exactly(2))
 			->method('imagePath')
 			->willReturnCallback(
-				function ($appName, $file) use (&$calls) {
+				function($appName, $file) use (&$calls) {
 					$expected = array_shift($calls);
 					$this->assertEquals($expected, [$appName, $file]);
 					if ($file === 'filetypes/my.png') {
@@ -345,7 +345,7 @@ 
 		$urlGenerator->expects($this->exactly(3))
 			->method('imagePath')
 			->willReturnCallback(
-				function ($appName, $file) use (&$calls) {
+				function($appName, $file) use (&$calls) {
 					$expected = array_shift($calls);
 					$this->assertEquals($expected, [$appName, $file]);
 					if ($file === 'filetypes/file.png') {