Doctrine\Bundle\DoctrineBundle\ConnectionFactory

Complexity

Total Complexity

19

Size/Duplication

Total Lines	162
Duplicated Lines	16.05 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	createConnection()	0	21	5
A	getDatabasePlatform()	0	15	2
A	initializeTypes()	0	12	3
B	markTypesCommented()	26	69	8

<?php

namespace Doctrine\Bundle\DoctrineBundle;

use Doctrine\Common\EventManager;
use Doctrine\DBAL\Configuration;
use Doctrine\DBAL\Connection;
use Doctrine\DBAL\DBALException;
use Doctrine\DBAL\DriverManager;
use Doctrine\DBAL\Exception\DriverException;
use Doctrine\DBAL\Platforms\AbstractPlatform;
use Doctrine\DBAL\Types\Type;
use const E_USER_DEPRECATED;
use function get_class;
use function trigger_error;

class ConnectionFactory
{
    /** @var mixed[][] */
    private $typesConfig = [];

    /** @var string[] */
    private $commentedTypes = [];

    /** @var bool */
    private $initialized = false;

    /**
     * @param mixed[][] $typesConfig
     */
    public function __construct(array $typesConfig)
    {
        $this->typesConfig = $typesConfig;
    }

    /**
     * Create a connection by name.
     *
     * @param mixed[]         $params
     * @param string[]|Type[] $mappingTypes
     *
     * @return Connection
     */
    public function createConnection(array $params, Configuration $config = null, EventManager $eventManager = null, array $mappingTypes = [])
    {
        if (! $this->initialized) {
            $this->initializeTypes();
        }

        $connection = DriverManager::getConnection($params, $config, $eventManager);

        if (! empty($mappingTypes)) {
            $platform = $this->getDatabasePlatform($connection);
            foreach ($mappingTypes as $dbType => $doctrineType) {
                $platform->registerDoctrineTypeMapping($dbType, $doctrineType);

It seems like $doctrineType defined by $doctrineType on line 54 can also be of type object<Doctrine\DBAL\Types\Type>; however, Doctrine\DBAL\Platforms\AbstractPlatform::registerDoctrineTypeMapping() does only seem to accept string, maybe add an additional type check?

            }
        }

        if (! empty($this->typesConfig)) {
            $this->markTypesCommented($this->getDatabasePlatform($connection));
        }

        return $connection;
    }

    /**
     * Try to get the database platform.
     *
     * This could fail if types should be registered to an predefined/unused connection
     * and the platform version is unknown.
     * For details have a look at DoctrineBundle issue #673.
     *
     * @return AbstractPlatform
     *
     * @throws DBALException
     */
    private function getDatabasePlatform(Connection $connection)
    {
        try {
            return $connection->getDatabasePlatform();
        } catch (DriverException $driverException) {
            throw new DBALException(
                'An exception occured while establishing a connection to figure out your platform version.' . PHP_EOL .
                "You can circumvent this by setting a 'server_version' configuration value" . PHP_EOL . PHP_EOL .
                'For further information have a look at:' . PHP_EOL .
                'https://github.com/doctrine/DoctrineBundle/issues/673',
                0,
                $driverException
            );
        }
    }

    /**
     * initialize the types
     */
    private function initializeTypes()
    {
        foreach ($this->typesConfig as $typeName => $typeConfig) {
            if (Type::hasType($typeName)) {
                Type::overrideType($typeName, $typeConfig['class']);
            } else {
                Type::addType($typeName, $typeConfig['class']);
            }
        }

        $this->initialized = true;
    }

    private function markTypesCommented(AbstractPlatform $platform) : void
    {
        if (! $this->initialized) {
            $this->initializeTypes();
        }

        foreach ($this->typesConfig as $typeName => $typeConfig) {
            $type                   = Type::getType($typeName);
            $requiresSQLCommentHint = $type->requiresSQLCommentHint($platform);

            // Attribute is missing, make sure a type that doesn't require a comment is marked as commented
            // This is deprecated behaviour that will be dropped in 2.0.
            if ($typeConfig['commented'] === null) {
                if (! $requiresSQLCommentHint) {

This code seems to be duplicated across your project.

                    @trigger_error(

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

                        sprintf(
                            'The type "%s" was implicitly marked as commented due to the configuration. This is deprecated and will be removed in DoctrineBundle 2.0. Either set the "commented" attribute in the configuration to "false" or mark the type as commented in "%s::requiresSQLCommentHint()."',
                            $typeName,
                            get_class($type)
                        ),
                        E_USER_DEPRECATED
                    );

                    $platform->markDoctrineTypeCommented($type);
                }

                continue;
            }

            // The following logic generates appropriate deprecation notices telling the user how to update their type configuration.
            if ($typeConfig['commented']) {
                if (! $requiresSQLCommentHint) {

This code seems to be duplicated across your project.

                    @trigger_error(

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

                        sprintf(
                            'The type "%s" was marked as commented in its configuration but not in the type itself. This is deprecated and will be removed in DoctrineBundle 2.0. Please update the return value of "%s::requiresSQLCommentHint()."',
                            $typeName,
                            get_class($type)
                        ),
                        E_USER_DEPRECATED
                    );

                    $platform->markDoctrineTypeCommented($type);

                    continue;
                }

                @trigger_error(

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

                    sprintf(
                        'The type "%s" was explicitly marked as commented in its configuration. This is no longer necessary and will be removed in DoctrineBundle 2.0. Please remove the "commented" attribute from the type configuration.',
                        $typeName
                    ),
                    E_USER_DEPRECATED
                );

                continue;
            }

            if ($requiresSQLCommentHint) {
                @trigger_error(

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

                    sprintf(
                        'Disabling type commenting for the commented type "%s" is deprecated and will be removed in DoctrineBundle 2.0. Please remove the "commented" attribute from the configuration and instead disable type commenting in "%s::requiresSQLCommentHint()" if you no longer want the type to be commented.',
                        $typeName,
                        get_class($type)
                    ),
                    E_USER_DEPRECATED
                );
            }
        }
    }
}