Mime::guessExtension() - Code Metrics - Inspection of "Uploader module added." - nazar-pc/CleverStyle-Framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a99636...57f009 )

by Nazar

created 2015-12-27 13:17 UTC

Mime::guessExtension() B

↳ Parent: Mime

Complexity

Conditions	6
Paths	6

Size

Total Lines	16
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	16
rs	8.8571
cc	6
eloc	9
nc	6
nop	3

<?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 <[email protected]>
 * @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)) {
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
			$json_path = implode(DIRECTORY_SEPARATOR, array(__DIR__, 'Resources', 'mime_types.json'));
			static::$mime_types = json_decode(file_get_contents($json_path), true);
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
		}
	}


	/**
	 * 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.

	 */
	public static function getTypeForExtension($extension) {
		static::ensureDataLoaded();
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}

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

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
			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();
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}

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

		$extensions = static::$mime_types[$mime_type];
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
		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.

	 */
	public static function getExtensionsForType($mime_type) {
		static::ensureDataLoaded();
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}

		if (static::hasType($mime_type)) {
			return (array) static::$mime_types[$mime_type];
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
		}
	}


	/**
	 * Check if an extension is known.
	 *
	 * @param string $extension An extension e.g. pdf.
	 *
	 * @return boolean
	 */
	public static function hasExtension($extension) {
		static::ensureDataLoaded();
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}

		$extension = strtolower($extension);
		foreach (static::$mime_types as $extensions) {
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
			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();
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
		return isset(static::$mime_types[$mime_type]);
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
	}


	/**
	 * 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.

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

	 */
	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)) {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
			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.

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

	 */
	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)) {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
			return strtolower($extension);
		}

		$mime_type = static::getMagicType($file_path);
		if ($mime_type and $extension = static::getExtensionForType($mime_type)) {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
			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;
		}
	}
}


Push — master ( a99636...57f009 )

Mime::guessExtension() B

Complexity

Size

Duplication

Importance

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

nazar-pc / CleverStyle-Framework

Push — master ( a99636...57f009 )

Mime::guessExtension() B

Complexity

Size

Duplication

Importance

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Duplication Side-by-Side

Filter issues like