ConnectionManager::declareConnection() - Code Metrics - Inspection of "#30 Adding support of configuration by connection" - b2pweb/bdf-prime - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#31)

by Vincent

created 2021-06-30 14:12 UTC

ConnectionManager::declareConnection() A

↳ Parent: ConnectionManager

Complexity

Conditions	2
Paths	2

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	2

Importance

Changes

Metric	Value
eloc	2
dl	0
loc	4
ccs	1
cts	1
cp	1
rs	10
c	0
b	0
f	0
cc	2
nc	2
nop	2
crap	2

<?php

namespace Bdf\Prime;

use Bdf\Prime\Connection\ConnectionInterface;
use Bdf\Prime\Connection\ConnectionRegistry;
use Bdf\Prime\Connection\SubConnectionManagerInterface;
use Bdf\Prime\Exception\DBALException;
use LogicException;

/**
 * ConnectionManager
 * 
 * doctrine dbal connection registry

 */
class ConnectionManager implements ConnectionRegistryInterface
{
    /**
     * The connection registry
     *
     * @var ConnectionRegistryInterface
     */
    private $registry;

    /**
     * Connections list
     *
     * @var ConnectionInterface[]
     */
    private $connections = [];

    /**
     * Default connection to use
     * 
     * @var string 

     */
    private $defaultConnection;


    /**
     * Set default configuration
     *
     * @param ConnectionRegistryInterface $registry
     */
    public function __construct(ConnectionRegistryInterface $registry = null)

    {
        $this->registry = $registry ?: new ConnectionRegistry();

    }

    /**
     * Add database connection
     *
     * @param ConnectionInterface $connection Unique name for the connection
     * @param boolean             $default    Use this connection as the default? The first connection added is automatically set as the default, even if this flag is false.

     *
     * @throws LogicException if connection exists

     */
    public function addConnection(ConnectionInterface $connection, bool $default = false)
    {
        // Connection name must be unique
        if (isset($this->connections[$connection->getName()])) {
            throw new LogicException('Connection for "'.$connection->getName().'" already exists. Connection name must be unique.');
        }

        // Set as default connection?
        if (true === $default || null === $this->defaultConnection) {
            $this->defaultConnection = $connection->getName();
        }

        $this->connections[$connection->getName()] = $connection;
    }

    /**
     * Remove a connection by its name
     *
     * @param string $name
     */
    public function removeConnection(string $name)
    {
        if (!isset($this->connections[$name])) {
            return;
        }
        
        $this->connections[$name]->close();
                                   close();
        unset($this->connections[$name]);
    }

    /**
     * Get connection by name
     *
     * @param string $name Unique name of the connection to be returned
     * 
     * @return ConnectionInterface
     * 
     * @throws DBALException
     *
     * @deprecated Since 1.1 use getConnection

     */
    public function connection(string $name = null): ConnectionInterface
    {
        return $this->getConnection($name);
    }

    /**

     * {@inheritDoc}
     */
    public function getConnection(string $name = null): ConnectionInterface
    {
        if ($name === null) {
            $name = $this->defaultConnection;
        }

        // Connection name must be unique
        if (!isset($this->connections[$name]) && !$this->loadSubConnection($name)) {
            $this->addConnection($this->registry->getConnection($name));
        }

        return $this->connections[$name];
    }

    /**
     * Associate configuration to connection
     *
     * @param string $connectionName
     * @param string|array $parameters
     */
    public function declareConnection(string $connectionName, $parameters)
    {
        if ($this->registry instanceof ConnectionRegistry) {
            $this->registry->declareConnection($connectionName, $parameters);
        }
    }

    /**
     * Get all connections
     *
     * @return ConnectionInterface[] Array of connection objects
     */
    public function connections()
    {
        return $this->connections;
    }

    /**
     * {@inheritDoc}
     */
    public function getConnectionNames(): array
    {
        return array_unique(array_merge($this->getCurrentConnectionNames(), $this->registry->getConnectionNames()));
    }

    /**
     * Gets the name of connections in progress
     */
    public function getCurrentConnectionNames(): array
    {
        return array_keys($this->connections);
    }

    /**
     * Set the default connection name
     *
     * @param string $name
     */
    public function setDefaultConnection($name)
    {
        $this->defaultConnection = $name;
    }

    /**
     * Get the default connection name
     *
     * @return string
     */
    public function getDefaultConnection()
    {
        return $this->defaultConnection;
    }

    /**
     * Try to load a sub connection
     *
     * This method allows connection as "name.otherName".
     * Works only if connection "name" is a SubConnectionManagerInterface.
     *
     * @param string $connectionName
     * 
     * @return bool  The connection has been loaded

     */
    private function loadSubConnection($connectionName)

    {
        $names = explode('.', $connectionName, 2);

        if (!isset($names[1])) {
            return false;
        }

        $connection = $this->getConnection($names[0]);

        if ($connection instanceof SubConnectionManagerInterface) {
            //TODO doit on concerver une reference sur la sous connection ?

            $this->connections[$connectionName] = $connection->getConnection($names[1]);
            return true;
        }

        return false;
    }
}


b2pweb / bdf-prime

Pull Request — master (#31)

ConnectionManager::declareConnection() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like