Fresh\DoctrineEnumBundle\DBAL\Types\AbstractEnumType

Complexity

Total Complexity

18

Size/Duplication

Total Lines	162
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	requiresSQLCommentHint()	0	4	1
A	getName()	0	4	2
A	convertToDatabaseValue()	0	12	3
B	getSqlDeclaration()	0	22	4
A	getChoices()	0	4	1
A	getValues()	0	4	1
A	getReadableValues()	0	4	1
A	getReadableValue()	0	8	2
A	isValueExist()	0	4	1
A	getMappedDatabaseTypes()	0	13	2

<?php

For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 29 and the first side effect is on line 14.

/*
 * This file is part of the FreshDoctrineEnumBundle
 *
 * (c) Artem Genvald <genvaldartem@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Fresh\DoctrineEnumBundle\DBAL\Types;

use Doctrine\DBAL\Platforms\AbstractPlatform;
Doctrine\DBAL\Platforms\MySqlPlatform;
use Doctrine\DBAL\Platforms\PostgreSqlPlatform;
use Doctrine\DBAL\Platforms\SqlitePlatform;
use Doctrine\DBAL\Platforms\SQLServerPlatform;
use Doctrine\DBAL\Types\Type;

/**
 * AbstractEnumType.
 *
 * Provides support of MySQL ENUM type for Doctrine in Symfony applications.
 *
 * @author Artem Genvald <genvaldartem@gmail.com>
 * @author Ben Davies <ben.davies@gmail.com>
 * @author Jaik Dean <jaik@fluoresce.co>
 */
abstract class AbstractEnumType extends Type
{
    /**
     * @var string
     */
    protected $name = '';

    /**
     * @var array Array of ENUM Values, where ENUM values are keys and their readable versions are values
     * @static
     */
    protected static $choices = [];

    /**
     * {@inheritdoc}
     */
    public function convertToDatabaseValue($value, AbstractPlatform $platform)
    {
        if (null === $value) {
            return;
        }

        if (!isset(static::$choices[$value])) {
            throw new \InvalidArgumentException(sprintf('Invalid value "%s" for ENUM "%s".', $value, $this->getName()));
        }

        return $value;
    }

    /**
     * {@inheritdoc}
     */
    public function getSqlDeclaration(array $fieldDeclaration, AbstractPlatform $platform)
    {
        $values = implode(
            ', ',
            array_map(
                function ($value) {
                    return "'{$value}'";
                },
                static::getValues()
            )
        );

        if ($platform instanceof SqlitePlatform) {
            return sprintf('TEXT CHECK(%s IN (%s))', $fieldDeclaration['name'], $values);
        }

        if ($platform instanceof PostgreSqlPlatform || $platform instanceof SQLServerPlatform) {
            return sprintf('VARCHAR(255) CHECK(%s IN (%s))', $fieldDeclaration['name'], $values);
        }

        return sprintf('ENUM(%s)', $values);
    }

    /**
     * {@inheritdoc}
     */
    public function requiresSQLCommentHint(AbstractPlatform $platform)
    {
        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function getName()
    {
        return $this->name ?: array_search(get_class($this), self::getTypesMap(), true);

The expression $this->name ?: array_search(get_class($this), self::getTypesMap(), true); of type false|integer|string adds false to the return on line 97 which is incompatible with the return type declared by the abstract method Doctrine\DBAL\Types\Type::getName of type string. It seems like you forgot to handle an error condition.

    }

    /**
     * Get readable choices for the ENUM field.
     *
     * @static
     *
     * @return array Values for the ENUM field
     */
    public static function getChoices()
    {
        return array_flip(static::$choices);
    }

    /**
     * Get values for the ENUM field.
     *
     * @static
     *
     * @return array Values for the ENUM field
     */
    public static function getValues()
    {
        return array_keys(static::$choices);
    }

    /**
     * Get array of ENUM Values, where ENUM values are keys and their readable versions are values.
     *
     * @static
     *
     * @return array Array of values with readable format
     */
    public static function getReadableValues()
    {
        return static::$choices;
    }

    /**
     * Get value in readable format.
     *
     * @param string $value ENUM value
     *
     * @static
     *
     * @return string|null $value Value in readable format
     *
     * @throws \InvalidArgumentException
     */
    public static function getReadableValue($value)
    {
        if (!isset(static::$choices[$value])) {
            throw new \InvalidArgumentException(sprintf('Invalid value "%s" for ENUM type "%s".', $value, get_called_class()));
        }

        return static::$choices[$value];
    }

    /**
     * Check if some string value exists in the array of ENUM values.
     *
     * @param string $value ENUM value
     *
     * @static
     *
     * @return bool
     */
    public static function isValueExist($value)
    {
        return isset(static::$choices[$value]);
    }
    
    /**
     * Gets an array of database types that map to this Doctrine type.
     *
     * @param \Doctrine\DBAL\Platforms\AbstractPlatform $platform
     *
     * @return array
     */
    public function getMappedDatabaseTypes(AbstractPlatform $platform)
    {
        if ($platform instanceof MySqlPlatform) {

The class Fresh\DoctrineEnumBundle\DBAL\Types\MySqlPlatform does not exist. Did you forget a USE statement, or did you not list all dependencies?

            return array_merge(
                parent::getMappedDatabaseTypes($platform),
                [
                    'enum',
                ]
            );
        }
        
        return parent::getMappedDatabaseTypes($platform);
    }
}