Karwana\Mime\Mime

Complexity

Total Complexity

31

Size/Duplication

Total Lines	187
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes	1
Bugs	0	Features	1

9 Methods

Rating	Name	Duplication	Size	Complexity
A	ensureDataLoaded()	0	6	2
B	getTypeForExtension()	0	14	5
A	getExtensionForType()	0	14	3
A	getExtensionsForType()	0	7	2
B	hasExtension()	0	16	5
A	hasType()	0	4	1
B	guessType()	0	19	5
B	guessExtension()	0	16	6
A	getMagicType()	0	10	2

<?php

/**
 * LICENSE: This source code is subject to the license that is available
 * in the LICENSE file distributed along with this package.
 *
 * @package    Mime
 * @author     Matthew Caruana Galizia <mcg@karwana.com>
 * @copyright  Karwana Ltd
 * @since      File available since Release 1.0.0
 */

namespace Karwana\Mime;

class Mime {

	private static $mime_types;

	private static function ensureDataLoaded() {
		if (!isset(static::$mime_types)) {

Since $mime_types is declared private, accessing it with static will lead to errors in possible sub-classes; consider using self, or increasing the visibility of $mime_types to at least protected.

			$json_path = implode(DIRECTORY_SEPARATOR, array(__DIR__, 'Resources', 'mime_types.json'));
			static::$mime_types = json_decode(file_get_contents($json_path), true);

Since $mime_types is declared private, accessing it with static will lead to errors in possible sub-classes; consider using self, or increasing the visibility of $mime_types to at least protected.

		}
	}


	/**
	 * Get the MIME type associated with a given extension.
	 *
	 * @param string $extension A file extension e.g. pdf.
	 *
	 * @return string|null The associated MIME type or null if none found.

Should the return type not be integer|string|null?

	 */
	public static function getTypeForExtension($extension) {
		static::ensureDataLoaded();

Since ensureDataLoaded() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of ensureDataLoaded() to at least protected.

		$extension = strtolower($extension);
		foreach (static::$mime_types as $mime_type => $extensions) {

Since $mime_types is declared private, accessing it with static will lead to errors in possible sub-classes; consider using self, or increasing the visibility of $mime_types to at least protected.

			if (is_array($extensions)) {
				if (in_array($extension, $extensions, true)) {
					return $mime_type;
				}
			} else if ($extension === $extensions) {
				return $mime_type;
			}
		}
	}


	/**
	 * Get the extension associated with a given MIME type.
	 *
	 * @param string $mime_type A MIME type e.g. application/pdf.
	 *
	 * @return string|null The first available associated extension or null if none found.
	 */
	public static function getExtensionForType($mime_type) {
		static::ensureDataLoaded();

Since ensureDataLoaded() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of ensureDataLoaded() to at least protected.

		if (!static::hasType($mime_type)) {
			return;
		}

		$extensions = static::$mime_types[$mime_type];

Since $mime_types is declared private, accessing it with static will lead to errors in possible sub-classes; consider using self, or increasing the visibility of $mime_types to at least protected.

		if (is_array($extensions)) {
			return $extensions[0];
		}

		return $extensions;
	}


	/**
	 * Get all the extensions associated with a given MIME type.
	 *
	 * @param string $mime_type A MIME type e.g. application/pdf.
	 *
	 * @return string[]|null An array of all the associated extensions or null if none found.

Should the return type not be array|null? Also, consider making the array more specific, something like array<String>, or String[].

	 */
	public static function getExtensionsForType($mime_type) {
		static::ensureDataLoaded();

Since ensureDataLoaded() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of ensureDataLoaded() to at least protected.

		if (static::hasType($mime_type)) {
			return (array) static::$mime_types[$mime_type];

Since $mime_types is declared private, accessing it with static will lead to errors in possible sub-classes; consider using self, or increasing the visibility of $mime_types to at least protected.

		}
	}


	/**
	 * Check if an extension is known.
	 *
	 * @param string $extension An extension e.g. pdf.
	 *
	 * @return boolean
	 */
	public static function hasExtension($extension) {
		static::ensureDataLoaded();

Since ensureDataLoaded() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of ensureDataLoaded() to at least protected.

		$extension = strtolower($extension);
		foreach (static::$mime_types as $extensions) {

Since $mime_types is declared private, accessing it with static will lead to errors in possible sub-classes; consider using self, or increasing the visibility of $mime_types to at least protected.

			if (is_array($extensions)) {
				if (in_array($extension, $extensions, true)) {
					return true;
				}
			} else if ($extension === $extensions) {
				return true;
			}
		}

		return false;
	}


	/**
	 * Check if a MIME type is known.
	 *
	 * @param string $mime_type A MIME type e.g. application/pdf.
	 *
	 * @return boolean
	 */
	public static function hasType($mime_type) {
		static::ensureDataLoaded();

Since ensureDataLoaded() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of ensureDataLoaded() to at least protected.

		return isset(static::$mime_types[$mime_type]);

Since $mime_types is declared private, accessing it with static will lead to errors in possible sub-classes; consider using self, or increasing the visibility of $mime_types to at least protected.

	}


	/**
	 * Guess the MIME type of a given file, first by checking the extension then by falling back to magic.
	 *
	 * @param string $file_path Relative or absolute path to an existing file.
	 * @param string $reference_name Use this name for detection based on the extension.

Should the type for parameter $reference_name not be string|null?

	 * @param string $default Default MIME type.
	 *
	 * @return string|null The associated MIME type or the default if none found.

Should the return type not be integer|string?

	 */
	public static function guessType($file_path, $reference_name = null, $default = 'application/octet-stream') {
		if (!$reference_name) {
			$reference_name = basename($file_path);
		}

		$extension = pathinfo($reference_name, PATHINFO_EXTENSION);
		if ($extension and $mime_type = static::getTypeForExtension($extension)) {

Using logical operators such as and instead of && is generally not recommended.

			return $mime_type;
		}

		// While it's true that the extension doesn't determine the type,
		// only use finfo as a fallback because it's bad at detecting text
		// types like CSS and JavaScript.
		if ($mime_type = static::getMagicType($file_path)) {
			return $mime_type;
		}

		return $default;
	}


	/**
	 * Guess the extension of a given file, first by checking the path then by falling back to magic.
	 *
	 * @param string $file_path Relative or absolute path to an existing file.
	 * @param string $reference_name Use this name for detection based on the extension.

Should the type for parameter $reference_name not be string|null?

	 * @param string $default Default extension.
	 *
	 * @return string|null The associated extension or the default if none found.

Consider making the return type a bit more specific; maybe use string.

	 */
	public static function guessExtension($file_path, $reference_name = null, $default = 'bin') {
		if (!$reference_name) {
			$reference_name = basename($file_path);
		}

		if ($extension = pathinfo($reference_name, PATHINFO_EXTENSION) and static::hasExtension($extension)) {

Using logical operators such as and instead of && is generally not recommended.

			return strtolower($extension);
		}

		$mime_type = static::getMagicType($file_path);
		if ($mime_type and $extension = static::getExtensionForType($mime_type)) {

Using logical operators such as and instead of && is generally not recommended.

			return $extension;
		}

		return $default;
	}


	/**
	 * Get the MIME type of a file using magic.
	 *
	 * @param string $file_path Relative or absolute path to an existing file.
	 *
	 * @return string|null The associated MIME type or null if no known type was detected.
	 */
	public static function getMagicType($file_path) {
		$file_info = finfo_open(FILEINFO_MIME_TYPE);
		$mime_type = finfo_file($file_info, $file_path);
		finfo_close($file_info);

		// Only return valid types, in order to maintain circular compatibility between methods.
		if (static::hasType($mime_type)) {
			return $mime_type;
		}
	}
}