FileEye\MimeMap\MapHandler

Complexity

Total Complexity

28

Size/Duplication

Total Lines	266
Duplicated Lines	16.54 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

96.25%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	2
A	get()	0	4	1
A	sort()	0	6	1
A	addMapEntry()	0	11	3
A	removeMapEntry()	0	30	5
A	addMapping()	0	13	1
A	removeMapping()	0	13	2
A	removeType()	0	17	3
A	setTypeDefaultExtension()	22	22	5
A	setExtensionDefaultType()	22	22	5

<?php

namespace FileEye\MimeMap;

/**
 * Class for managing the type-to-extension map.
 */
class MapHandler
{
    /**
     * Mapping between file extensions and MIME types.
     *
     * The array has two main keys, 'types' that maps MIME types to file
     * extensions, and 'extensions' that map file extensions to MIME types.
     *
     * @var array
     */
    protected $map;

    /**
     * Constructor.
     *
     * @param array $map
     *   (Optional) The mapping to be used for this instance. If null, the
     *   default map will be used.
     */
    public function __construct(array $map = null)
    {
        if (is_null($map)) {
            $this->map = &TypeExtensionMap::$map;
        } else {
            $this->map = $map;
        }
    }

    /**
     * Returns the map associated with this instance.
     *
     * @return array
     */
    public function get()
    {
        return $this->map;
    }

    /**
     * Sorts the map.
     *
     * @return $this
     */
    public function sort()
    {
        ksort($this->map['types']);
        ksort($this->map['extensions']);
        return $this;
    }

    /**
     * Adds an entry to the map.
     *
     * Checks that no duplicate entries are made.
     *
     * @param string $key
     *   The main array key.
     * @param string $entry
     *   The sub array key.
     * @param string $value
     *   The value to add.
     *
     * @return $this
     */
    protected function addMapEntry($key, $entry, $value)
    {
        if (!isset($this->map[$key][$entry])) {
            $this->map[$key][$entry] = [$value];
        } else {
            if (array_search($value, $this->map[$key][$entry]) === false) {
                $this->map[$key][$entry][] = $value;
            }
        }
        return $this;
    }

    /**
     * Removes an entry from the map.
     *
     * @param string $key
     *   The main array key.
     * @param string $entry
     *   The sub array key.
     * @param string $value
     *   The value.
     *
     * @return bool
     *   true if the entry was removed, false if the entry was not present.
     */
    protected function removeMapEntry($key, $entry, $value)
    {
        // Return false if no entry.
        if (!isset($this->map[$key][$entry])) {
            return false;
        }

        // Return false if no value.
        $k = array_search($value, $this->map[$key][$entry]);
        if ($k === false) {
            return false;
        }

        // Remove the map entry.
        unset($this->map[$key][$entry][$k]);

        // Remove the entry itself if no more values.
        if (empty($this->map[$key][$entry])) {
            unset($this->map[$key][$entry]);
        } else {
            // Resequence the remaining values.
            $tmp = [];
            foreach ($this->map[$key][$entry] as $v) {
                $tmp[] = $v;
            }
            $this->map[$key][$entry] = $tmp;
        }

        return true;
    }

    /**
     * Adds a type-to-extension mapping.
     *
     * @param string $type
     *   A MIME type.
     * @param string $extension
     *   A file extension.
     *
     * @return $this
     */
    public function addMapping($type, $extension)
    {
        $type = strtolower($type);
        $extension = (string) strtolower($extension);

        // Add entry to 'types'.
        $this->addMapEntry('types', $type, $extension);

        // Add entry to 'extensions'.
        $this->addMapEntry('extensions', $extension, $type);

        return $this;
    }

    /**
     * Removes a type-to-extension mapping.
     *
     * @param string $type
     *   A MIME type.
     * @param string $extension
     *   A file extension.
     *
     * @return bool
     *   true if the mapping was removed, false if the mapping was not present.
     */
    public function removeMapping($type, $extension)
    {
        $type = strtolower($type);
        $extension = (string) strtolower($extension);

        // Remove entry from 'types'.
        $type_ret = $this->removeMapEntry('types', $type, $extension);

        // Remove entry from 'extensions'.
        $extension_ret = $this->removeMapEntry('extensions', $extension, $type);

        return $type_ret && $extension_ret;
    }

    /**
     * Removes the entire mapping of a type.
     *
     * @param string $type
     *   A MIME type.
     *
     * @return bool
     *   true if the mapping was removed, false if the type was not present.
     */
    public function removeType($type)
    {
        $type = strtolower($type);

        // Return false if type is not found.
        if (!isset($this->map['types'][$type])) {
            return false;
        }

        // Loop through all the associated extensions and remove them. This
        // is also removing the type itself when the last extension is removed.
        foreach ($this->map['types'][$type] as $extension) {
            $this->removeMapping($type, $extension);
        }

        return true;
    }

    /**
     * Changes the default extension for a MIME type.
     *
     * @param string $type
     *   A MIME type.
     * @param string $extension
     *   A file extension.
     *
     * @throws MappingException if no mapping found.
     *
     * @return $this
     */
    public function setTypeDefaultExtension($type, $extension)

This method seems to be duplicated in your project.

    {
        $type = strtolower($type);
        $extension = (string) strtolower($extension);

        if (!isset($this->map['types'][$type])) {
            throw new MappingException('Cannot set ' . $extension . ' as default extension for type ' . $type . ', type not defined');
        }
        $key = array_search($extension, $this->map['types'][$type]);
        if ($key === false) {
            throw new MappingException('Cannot set ' . $extension . ' as default extension for type ' . $type . ', extension not associated to this type');
        }
        $tmp = [$extension];
        foreach ($this->map['types'][$type] as $k => $v) {
            if ($k === $key) {
                continue;
            }
            $tmp[] = $v;
        }
        $this->map['types'][$type] = $tmp;
        return $this;
    }

    /**
     * Changes the default MIME type for a file extension.
     *
     * @param string $extension
     *   A file extension.
     * @param string $type
     *   A MIME type.
     *
     * @throws MappingException if no mapping found.
     *
     * @return $this
     */
    public function setExtensionDefaultType($extension, $type)

This method seems to be duplicated in your project.

    {
        $type = strtolower($type);
        $extension = (string) strtolower($extension);

        if (!isset($this->map['extensions'][$extension])) {
            throw new MappingException('Cannot set ' . $type . ' as default type for extension ' . $extension . ', extension not defined');
        }
        $key = array_search($type, $this->map['extensions'][$extension]);
        if ($key === false) {
            throw new MappingException('Cannot set ' . $type . ' as default type for extension ' . $extension . ', type not associated to this extension');
        }
        $tmp = [$type];
        foreach ($this->map['extensions'][$extension] as $k => $v) {
            if ($k === $key) {
                continue;
            }
            $tmp[] = $v;
        }
        $this->map['extensions'][$extension] = $tmp;
        return $this;
    }
}