Type::parse() - Code Metrics - Inspection of "Add MIME type descriptions and aliases taking from..." - FileEye/MimeMap - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#15)

by mon

created 2019-01-24 15:54 UTC

Type::parse() B

↳ Parent: Project

Complexity

Conditions	7
Paths	6

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	22
CRAP Score	7.004

Importance

Changes

Metric	Value
dl	0
loc	38
ccs	22
cts	23
cp	0.9565
rs	8.3786
c	0
b	0
f	0
cc	7
nc	6
nop	1
crap	7.004

<?php

namespace FileEye\MimeMap;

/**
 * Class for working with MIME types
 */
class Type
{
    /**
     * Short format [e.g. image/jpeg] for strings.
     */
    const SHORT_TEXT = 0;

    /**
     * Full format [e.g. image/jpeg; p="1"] for strings.
     */
    const FULL_TEXT = 1;

    /**
     * Full format with comments [e.g. image/jpeg; p="1" (comment)] for strings.
     */
    const FULL_TEXT_WITH_COMMENTS = 2;

    /**
     * The MIME media type.
     *
     * @var string
     */
    protected $media;

    /**
     * The MIME media type comment.
     *
     * @var string
     */
    protected $mediaComment;

    /**
     * The MIME media sub-type.
     *
     * @var string
     */
    protected $subType;

    /**
     * The MIME media sub-type comment.
     *
     * @var string
     */
    protected $subTypeComment;

    /**
     * Optional MIME parameters
     *
     * @var TypeParameter[]
     */
    protected $parameters = [];

    /**
     * Constructor.
     *
     * The type string will be parsed and the appropriate class vars set.
     *
     * @param string $type MIME type
     */
    public function __construct($type)
    {
        $this->parse($type);
    }

    /**
     * Parse a mime-type and set the class variables.
     *
     * @param string $type MIME type to parse
     *
     * @return void
     */
    protected function parse($type)
    {
        // Media and SubType are separated by a slash '/'.
        $media = TypeParser::parseStringPart($type, 0, '/');

        if (!$media['string']) {
            throw new MalformedTypeException('Media type not found');
        }
        if (!$media['delimiter_matched']) {
            throw new MalformedTypeException('Slash \'/\' to separate media type and subtype not found');
        }

        $this->media = strtolower($media['string']);
        $this->mediaComment = $media['comment'];

        // SubType and Parameters are separated by semicolons ';'.
        $sub = TypeParser::parseStringPart($type, $media['end_offset'] + 1, ';');

        if (!$sub['string']) {
            throw new MalformedTypeException('Media subtype not found');
        }

        $this->subType = strtolower($sub['string']);
        $this->subTypeComment = $sub['comment'];

        // Loops through the parameter.
        while ($sub['delimiter_matched']) {
            $sub = TypeParser::parseStringPart($type, $sub['end_offset'] + 1, ';');
            $tmp = explode('=', $sub['string'], 2);
            $p_name = trim($tmp[0]);
            $p_val = trim($tmp[1]);
            if ($p_val[0] == '"' && $p_val[strlen($p_val) - 1] == '"') {
                $p_val = substr($p_val, 1, -1);
            }
            $p_val = str_replace('\\"', '"', $p_val);
            $this->addParameter($p_name, $p_val, $sub['comment']);
        }
    }

    /**
     * Does this type have any parameters?
     *
     * @return boolean true if type has parameters, false otherwise
     */
    public function hasParameters()
    {
        return (bool) $this->parameters;
    }

    /**
     * Get a MIME type's parameters
     *
     * @return TypeParameter[] Type's parameters
     */
    public function getParameters()
    {
        return $this->parameters;
    }

    /**
     * Get a MIME type's parameter
     *
     * @param string $name Parameter name
     *
     * @return TypeParameter|null
     */
    public function getParameter($name)
    {
        return isset($this->parameters[$name]) ? $this->parameters[$name] : null;
    }

    /**
     * Gets a MIME type's media.
     *
     * Note: 'media' refers to the portion before the first slash.
     *
     * @return string Type's media.
     */
    public function getMedia()
    {
        return $this->media;
    }

    /**
     * Gets a MIME type's media comment.
     *
     * @return string Type's media comment.
     */
    public function getMediaComment()
    {
        return $this->mediaComment;
    }

    /**
     * Sets a MIME type's media comment.
     *
     * @param string Type's media comment.
     *
     * @return $this
     */
    public function setMediaComment($comment)
    {
        $this->mediaComment = $comment;
        return $this;
    }

    /**
     * Gets a MIME type's subtype.
     *
     * @return string Type's subtype, null if invalid mime type.
     */
    public function getSubType()
    {
        return $this->subType;
    }

    /**
     * Gets a MIME type's subtype comment.
     *
     * @return string Type's subtype comment, null if invalid mime type.
     */
    public function getSubTypeComment()
    {
        return $this->subTypeComment;
    }

    /**
     * Sets a MIME type's subtype comment.
     *
     * @param string Type's subtype comment.
     *
     * @return $this
     */
    public function setSubTypeComment($comment)
    {
        $this->subTypeComment = $comment;
        return $this;
    }

    /**
     * Create a textual MIME type from object values
     *
     * This function performs the opposite function of parse().
     *
     * @param int $format The format of the output string.
     *
     * @return string MIME type string
     */
    public function toString($format = Type::FULL_TEXT)
    {
        $type = strtolower($this->media);
        if ($format > Type::FULL_TEXT && isset($this->mediaComment)) {
            $type .= ' (' .  $this->mediaComment . ')';
        }
        $type .= '/' . strtolower($this->subType);
        if ($format > Type::FULL_TEXT && isset($this->subTypeComment)) {
            $type .= ' (' .  $this->subTypeComment . ')';
        }
        if ($format > Type::SHORT_TEXT && count($this->parameters)) {
            foreach ($this->parameters as $parameter) {
                $type .= '; ' . $parameter->toString($format);
            }
        }
        return $type;
    }

    /**
     * Is this type experimental?
     *
     * Note: Experimental types are denoted by a leading 'x-' in the media or
     *       subtype, e.g. text/x-vcard or x-world/x-vrml.
     *
     * @return boolean true if type is experimental, false otherwise
     */
    public function isExperimental()
    {
        if (substr($this->getMedia(), 0, 2) == 'x-' || substr($this->getSubType(), 0, 2) == 'x-') {
            return true;
        }
        return false;
    }

    /**
     * Is this a vendor MIME type?
     *
     * Note: Vendor types are denoted with a leading 'vnd. in the subtype.
     *
     * @return boolean true if type is a vendor type, false otherwise
     */
    public function isVendor()
    {
        if (substr($this->getSubType(), 0, 4) == 'vnd.') {
            return true;
        }
        return false;
    }

    /**
     * Is this a wildcard type?
     *
     * @return boolean true if type is a wildcard, false otherwise.
     */
    public function isWildcard()
    {
        if (($this->getMedia() === '*' && $this->getSubtype() === '*') || strpos($this->getSubtype(), '*') !== false) {
            return true;
        }
        return false;
    }

    /**
     * Is this an alias?
     *
     * @return boolean true if type is an alias, false otherwise.
     */
    public function isAlias()
    {
        if ($this->isWildcard()) {
            return false;
        }

        $map = MapHandler::map();
        $subject = $this->toString(static::SHORT_TEXT);
        return $map->hasAlias($subject);
    }

    /**
     * Perform a wildcard match on a MIME type
     *
     * Example:
     * $type = new Type('image/png');
     * $type->wildcardMatch('image/*');
     *
     * @param string $wildcard Wildcard to check against
     *
     * @return boolean true if there was a match, false otherwise
     */
    public function wildcardMatch($wildcard)
    {
        $wildcard_type = new static($wildcard);

        if (!$wildcard_type->isWildcard()) {
            return false;
        }

        $wildcard_re = strtr($wildcard_type->toString(static::SHORT_TEXT), [
            '/' => '\\/',
            '*' => '.*',
        ]);
        $subject = $this->toString(static::SHORT_TEXT);

        return preg_match("/$wildcard_re/", $subject) === 1;
    }

    /**
     * Add a parameter to this type
     *
     * @param string $name    Parameter name
     * @param string $value   Parameter value
     * @param string $comment Comment for this parameter
     *
     * @return void
     */
    public function addParameter($name, $value, $comment = null)
    {
        $this->parameters[$name] = new TypeParameter($name, $value, $comment);
    }

    /**
     * Remove a parameter from this type
     *
     * @param string $name Parameter name
     *
     * @return void
     */
    public function removeParameter($name)
    {
        unset($this->parameters[$name]);
    }

    /**
     * Builds a list of MIME types.
     *
     * If the current type is a wildcard, than all the types matching the
     * wildcard will be returned.
     *
     * @param bool $strict
     *   (Optional) if true a MappingException is thrown when no type is
     *   found, if false it returns an empty array as a default.
     *   Defaults to true.
     *
     * @throws MappingException if no mapping found and $strict is true.
     *
     * @return string[]
     */
    public function buildTypesList($strict = true)
    {
        $map = MapHandler::map();
        $subject = $this->toString(static::SHORT_TEXT);

        // Find all types.
        $types = [];
        if (!$this->isWildcard()) {
            if ($map->hasType($subject)) {
                $types[] = $subject;
            }
        } else {
            foreach ($map->listTypes($subject) as $t) {
                $types[] = $t;
            }
        }

        // No types found, throw exception or return emtpy array.
        if (empty($types)) {
            if ($strict) {
                throw new MappingException('No MIME type found for ' . $subject . ' in map');
            } else {
                return [];
            }
        }

        return $types;
    }

    /**
     * Returns a description for the MIME type, if existing in the map.
     *
     * @param bool $include_acronym
     *   (Optional) if true and an acronym description exists for the type,
     *   the returned description will contain the acronym and its description,
     *   appended with a comma. Defaults to false.
     *
     * @return string|null
     */
    public function getDescription($include_acronym = false)
    {
        if ($this->isWildcard()) {
            return null;
        }

        $map = MapHandler::map();
        $subject = $this->toString(static::SHORT_TEXT);
        $descriptions = $map->getTypeDescriptions($subject);
        $res = null;
        if (isset($descriptions[0]) {

            $res = $descriptions[0];
        }
        if ($include_acronym && isset($descriptions[1]) {
            $res .= ', ' . $descriptions[1];
        }
        return array_keys($res);
    }

    /**
     * Returns all the aliases related to the MIME type(s).
     *
     * If the current type is a wildcard, than all aliases of all the
     * types matching the wildcard will be returned.
     *
     * @param bool $strict
     *   (Optional) if true a MappingException is thrown when no mapping is
     *   found, if false it returns an empty array as a default.
     *   Defaults to true.
     *
     * @throws MappingException if no mapping found and $strict is true.
     *
     * @return string[]
     */
    public function getAliases($strict = true)
    {
        $map = MapHandler::map();
        $types = $this->buildTypesList($strict);

        // Build the array of aliases.
        $aliases = [];
        foreach ($types as $t) {
            foreach ($map->getTypeAliases($t) as $a) {
                $aliases[$a] = $a;
            }
        }

        return array_keys($aliases);
    }

    /**
     * Returns the MIME type's preferred file extension.
     *
     * @param bool $strict
     *   (Optional) if true a MappingException is thrown when no mapping is
     *   found, if false it returns null as a default.
     *   Defaults to true.
     *
     * @throws MappingException if no mapping found and $strict is true.
     *
     * @return string
     */
    public function getDefaultExtension($strict = true)
    {
        $map = MapHandler::map();
        $subject = $this->toString(static::SHORT_TEXT);

        if (!$this->isWildcard()) {
            $proceed = $map->hasType($subject);
        } else {
            $proceed = count($map->listTypes($subject)) === 1;
        }

        if (!$proceed) {
            if ($strict) {
                throw new MappingException('Cannot determine default extension for type: ' . $this->toString(static::SHORT_TEXT));
            } else {
                return null;
            }
        }

        return $this->getExtensions()[0];
    }

    /**
     * Returns all the file extensions related to the MIME type(s).
     *
     * If the current type is a wildcard, than all extensions of all the
     * types matching the wildcard will be returned.
     *
     * @param bool $strict
     *   (Optional) if true a MappingException is thrown when no mapping is
     *   found, if false it returns an empty array as a default.
     *   Defaults to true.
     *
     * @throws MappingException if no mapping found and $strict is true.
     *
     * @return string[]
     */
    public function getExtensions($strict = true)
    {
        $map = MapHandler::map();
        $types = $this->buildTypesList($strict);

        // Build the array of extensions.
        $extensions = [];
        foreach ($types as $t) {
            foreach ($map->getTypeExtensions($t) as $e) {
                $extensions[$e] = $e;
            }
        }

        return array_keys($extensions);
    }
}


1			<?php
2
3			namespace FileEye\MimeMap;
4
5			/**
6			* Class for working with MIME types
7			*/
8			class Type
9			{
10			/**
11			* Short format [e.g. image/jpeg] for strings.
12			*/
13			const SHORT_TEXT = 0;
14
15			/**
16			* Full format [e.g. image/jpeg; p="1"] for strings.
17			*/
18			const FULL_TEXT = 1;
19
20			/**
21			* Full format with comments [e.g. image/jpeg; p="1" (comment)] for strings.
22			*/
23			const FULL_TEXT_WITH_COMMENTS = 2;
24
25			/**
26			* The MIME media type.
27			*
28			* @var string
29			*/
30			protected $media;
31
32			/**
33			* The MIME media type comment.
34			*
35			* @var string
36			*/
37			protected $mediaComment;
38
39			/**
40			* The MIME media sub-type.
41			*
42			* @var string
43			*/
44			protected $subType;
45
46			/**
47			* The MIME media sub-type comment.
48			*
49			* @var string
50			*/
51			protected $subTypeComment;
52
53			/**
54			* Optional MIME parameters
55			*
56			* @var TypeParameter[]
57			*/
58			protected $parameters = [];
59
60			/**
61			* Constructor.
62			*
63			* The type string will be parsed and the appropriate class vars set.
64			*
65			* @param string $type MIME type
66			*/
67			public function __construct($type)
68			{
69			$this->parse($type);
70			}
71
72			/**
73			* Parse a mime-type and set the class variables.
74			*
75			* @param string $type MIME type to parse
76			*
77			* @return void
78			*/
79			protected function parse($type)
80			{
81			// Media and SubType are separated by a slash '/'.
82			$media = TypeParser::parseStringPart($type, 0, '/');
83
84			if (!$media['string']) {
85			throw new MalformedTypeException('Media type not found');
86			}
87			if (!$media['delimiter_matched']) {
88			throw new MalformedTypeException('Slash \'/\' to separate media type and subtype not found');
89			}
90
91			$this->media = strtolower($media['string']);
92			$this->mediaComment = $media['comment'];
93
94			// SubType and Parameters are separated by semicolons ';'.
95			$sub = TypeParser::parseStringPart($type, $media['end_offset'] + 1, ';');
96
97			if (!$sub['string']) {
98			throw new MalformedTypeException('Media subtype not found');
99			}
100
101			$this->subType = strtolower($sub['string']);
102			$this->subTypeComment = $sub['comment'];
103
104			// Loops through the parameter.
105			while ($sub['delimiter_matched']) {
106			$sub = TypeParser::parseStringPart($type, $sub['end_offset'] + 1, ';');
107			$tmp = explode('=', $sub['string'], 2);
108			$p_name = trim($tmp[0]);
109			$p_val = trim($tmp[1]);
110			if ($p_val[0] == '"' && $p_val[strlen($p_val) - 1] == '"') {
111			$p_val = substr($p_val, 1, -1);
112			}
113			$p_val = str_replace('\\"', '"', $p_val);
114			$this->addParameter($p_name, $p_val, $sub['comment']);
115			}
116			}
117
118			/**
119			* Does this type have any parameters?
120			*
121			* @return boolean true if type has parameters, false otherwise
122			*/
123			public function hasParameters()
124			{
125			return (bool) $this->parameters;
126			}
127
128			/**
129			* Get a MIME type's parameters
130			*
131			* @return TypeParameter[] Type's parameters
132			*/
133			public function getParameters()
134			{
135			return $this->parameters;
136			}
137
138			/**
139			* Get a MIME type's parameter
140			*
141			* @param string $name Parameter name
142			*
143			* @return TypeParameter\|null
144			*/
145			public function getParameter($name)
146			{
147			return isset($this->parameters[$name]) ? $this->parameters[$name] : null;
148			}
149
150			/**
151			* Gets a MIME type's media.
152			*
153			* Note: 'media' refers to the portion before the first slash.
154			*
155			* @return string Type's media.
156			*/
157			public function getMedia()
158			{
159			return $this->media;
160			}
161
162			/**
163			* Gets a MIME type's media comment.
164			*
165			* @return string Type's media comment.
166			*/
167			public function getMediaComment()
168			{
169			return $this->mediaComment;
170			}
171
172			/**
173			* Sets a MIME type's media comment.
174			*
175			* @param string Type's media comment.
176			*
177			* @return $this
178			*/
179			public function setMediaComment($comment)
180			{
181			$this->mediaComment = $comment;
182			return $this;
183			}
184
185			/**
186			* Gets a MIME type's subtype.
187			*
188			* @return string Type's subtype, null if invalid mime type.
189			*/
190			public function getSubType()
191			{
192			return $this->subType;
193			}
194
195			/**
196			* Gets a MIME type's subtype comment.
197			*
198			* @return string Type's subtype comment, null if invalid mime type.
199			*/
200			public function getSubTypeComment()
201			{
202			return $this->subTypeComment;
203			}
204
205			/**
206			* Sets a MIME type's subtype comment.
207			*
208			* @param string Type's subtype comment.
209			*
210			* @return $this
211			*/
212			public function setSubTypeComment($comment)
213			{
214			$this->subTypeComment = $comment;
215			return $this;
216			}
217
218			/**
219			* Create a textual MIME type from object values
220			*
221			* This function performs the opposite function of parse().
222			*
223			* @param int $format The format of the output string.
224			*
225			* @return string MIME type string
226			*/
227			public function toString($format = Type::FULL_TEXT)
228			{
229			$type = strtolower($this->media);
230			if ($format > Type::FULL_TEXT && isset($this->mediaComment)) {
231			$type .= ' (' . $this->mediaComment . ')';
232			}
233			$type .= '/' . strtolower($this->subType);
234			if ($format > Type::FULL_TEXT && isset($this->subTypeComment)) {
235			$type .= ' (' . $this->subTypeComment . ')';
236			}
237			if ($format > Type::SHORT_TEXT && count($this->parameters)) {
238			foreach ($this->parameters as $parameter) {
239			$type .= '; ' . $parameter->toString($format);
240			}
241			}
242			return $type;
243			}
244
245			/**
246			* Is this type experimental?
247			*
248			* Note: Experimental types are denoted by a leading 'x-' in the media or
249			* subtype, e.g. text/x-vcard or x-world/x-vrml.
250			*
251			* @return boolean true if type is experimental, false otherwise
252			*/
253			public function isExperimental()
254			{
255			if (substr($this->getMedia(), 0, 2) == 'x-' \|\| substr($this->getSubType(), 0, 2) == 'x-') {
256			return true;
257			}
258			return false;
259			}
260
261			/**
262			* Is this a vendor MIME type?
263			*
264			* Note: Vendor types are denoted with a leading 'vnd. in the subtype.
265			*
266			* @return boolean true if type is a vendor type, false otherwise
267			*/
268			public function isVendor()
269			{
270			if (substr($this->getSubType(), 0, 4) == 'vnd.') {
271			return true;
272			}
273			return false;
274			}
275
276			/**
277			* Is this a wildcard type?
278			*
279			* @return boolean true if type is a wildcard, false otherwise.
280			*/
281			public function isWildcard()
282			{
283			if (($this->getMedia() === '' && $this->getSubtype() === '') \|\| strpos($this->getSubtype(), '*') !== false) {
284			return true;
285			}
286			return false;
287			}
288
289			/**
290			* Is this an alias?
291			*
292			* @return boolean true if type is an alias, false otherwise.
293			*/
294			public function isAlias()
295			{
296			if ($this->isWildcard()) {
297			return false;
298			}
299
300			$map = MapHandler::map();
301			$subject = $this->toString(static::SHORT_TEXT);
302			return $map->hasAlias($subject);
303			}
304
305			/**
306			* Perform a wildcard match on a MIME type
307			*
308			* Example:
309			* $type = new Type('image/png');
310			* $type->wildcardMatch('image/*');
311			*
312			* @param string $wildcard Wildcard to check against
313			*
314			* @return boolean true if there was a match, false otherwise
315			*/
316			public function wildcardMatch($wildcard)
317			{
318			$wildcard_type = new static($wildcard);
319
320			if (!$wildcard_type->isWildcard()) {
321			return false;
322			}
323
324			$wildcard_re = strtr($wildcard_type->toString(static::SHORT_TEXT), [
325			'/' => '\\/',
326			'' => '.',
327			]);
328			$subject = $this->toString(static::SHORT_TEXT);
329
330			return preg_match("/$wildcard_re/", $subject) === 1;
331			}
332
333			/**
334			* Add a parameter to this type
335			*
336			* @param string $name Parameter name
337			* @param string $value Parameter value
338			* @param string $comment Comment for this parameter
339			*
340			* @return void
341			*/
342			public function addParameter($name, $value, $comment = null)
343			{
344			$this->parameters[$name] = new TypeParameter($name, $value, $comment);
345			}
346
347			/**
348			* Remove a parameter from this type
349			*
350			* @param string $name Parameter name
351			*
352			* @return void
353			*/
354			public function removeParameter($name)
355			{
356			unset($this->parameters[$name]);
357			}
358
359			/**
360			* Builds a list of MIME types.
361			*
362			* If the current type is a wildcard, than all the types matching the
363			* wildcard will be returned.
364			*
365			* @param bool $strict
366			* (Optional) if true a MappingException is thrown when no type is
367			* found, if false it returns an empty array as a default.
368			* Defaults to true.
369			*
370			* @throws MappingException if no mapping found and $strict is true.
371			*
372			* @return string[]
373			*/
374			public function buildTypesList($strict = true)
375			{
376			$map = MapHandler::map();
377			$subject = $this->toString(static::SHORT_TEXT);
378
379			// Find all types.
380			$types = [];
381			if (!$this->isWildcard()) {
382			if ($map->hasType($subject)) {
383			$types[] = $subject;
384			}
385			} else {
386			foreach ($map->listTypes($subject) as $t) {
387			$types[] = $t;
388			}
389			}
390
391			// No types found, throw exception or return emtpy array.
392			if (empty($types)) {
393			if ($strict) {
394			throw new MappingException('No MIME type found for ' . $subject . ' in map');
395			} else {
396			return [];
397			}
398			}
399
400			return $types;
401			}
402
403			/**
404			* Returns a description for the MIME type, if existing in the map.
405			*
406			* @param bool $include_acronym
407			* (Optional) if true and an acronym description exists for the type,
408			* the returned description will contain the acronym and its description,
409			* appended with a comma. Defaults to false.
410			*
411			* @return string\|null
412			*/
413			public function getDescription($include_acronym = false)
414			{
415			if ($this->isWildcard()) {
416			return null;
417			}
418
419			$map = MapHandler::map();
420			$subject = $this->toString(static::SHORT_TEXT);
421			$descriptions = $map->getTypeDescriptions($subject);
422			$res = null;
423			if (isset($descriptions[0]) {
			0 ignored issues – show Bug introduced 2019-01-24 15:56 UTC by Report Bug Copy Issue Report This code did not parse for me. Apparently, there is an error somewhere around this line: Syntax error, unexpected '{' Loading history...
424			$res = $descriptions[0];
425			}
426			if ($include_acronym && isset($descriptions[1]) {
427			$res .= ', ' . $descriptions[1];
428			}
429			return array_keys($res);
430			}
431
432			/**
433			* Returns all the aliases related to the MIME type(s).
434			*
435			* If the current type is a wildcard, than all aliases of all the
436			* types matching the wildcard will be returned.
437			*
438			* @param bool $strict
439			* (Optional) if true a MappingException is thrown when no mapping is
440			* found, if false it returns an empty array as a default.
441			* Defaults to true.
442			*
443			* @throws MappingException if no mapping found and $strict is true.
444			*
445			* @return string[]
446			*/
447			public function getAliases($strict = true)
448			{
449			$map = MapHandler::map();
450			$types = $this->buildTypesList($strict);
451
452			// Build the array of aliases.
453			$aliases = [];
454			foreach ($types as $t) {
455			foreach ($map->getTypeAliases($t) as $a) {
456			$aliases[$a] = $a;
457			}
458			}
459
460			return array_keys($aliases);
461			}
462
463			/**
464			* Returns the MIME type's preferred file extension.
465			*
466			* @param bool $strict
467			* (Optional) if true a MappingException is thrown when no mapping is
468			* found, if false it returns null as a default.
469			* Defaults to true.
470			*
471			* @throws MappingException if no mapping found and $strict is true.
472			*
473			* @return string
474			*/
475			public function getDefaultExtension($strict = true)
476			{
477			$map = MapHandler::map();
478			$subject = $this->toString(static::SHORT_TEXT);
479
480			if (!$this->isWildcard()) {
481			$proceed = $map->hasType($subject);
482			} else {
483			$proceed = count($map->listTypes($subject)) === 1;
484			}
485
486			if (!$proceed) {
487			if ($strict) {
488			throw new MappingException('Cannot determine default extension for type: ' . $this->toString(static::SHORT_TEXT));
489			} else {
490			return null;
491			}
492			}
493
494			return $this->getExtensions()[0];
495			}
496
497			/**
498			* Returns all the file extensions related to the MIME type(s).
499			*
500			* If the current type is a wildcard, than all extensions of all the
501			* types matching the wildcard will be returned.
502			*
503			* @param bool $strict
504			* (Optional) if true a MappingException is thrown when no mapping is
505			* found, if false it returns an empty array as a default.
506			* Defaults to true.
507			*
508			* @throws MappingException if no mapping found and $strict is true.
509			*
510			* @return string[]
511			*/
512			public function getExtensions($strict = true)
513			{
514			$map = MapHandler::map();
515			$types = $this->buildTypesList($strict);
516
517			// Build the array of extensions.
518			$extensions = [];
519			foreach ($types as $t) {
520			foreach ($map->getTypeExtensions($t) as $e) {
521			$extensions[$e] = $e;
522			}
523			}
524
525			return array_keys($extensions);
526			}
527			}
528

FileEye / MimeMap

Pull Request — master (#15)

Type::parse() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like