DatabaseCommand::__construct() - Code Metrics - Inspection of "Adding connection factory and registry" - b2pweb/bdf-prime - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 7a6bdd...324ce1 )

by Sébastien

created 2020-06-12 13:37 UTC

DatabaseCommand::__construct() A

↳ Parent: DatabaseCommand

Complexity

Conditions	2
Paths	2

Size

Total Lines	18
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	12
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	11
c	1
b	0
f	0
dl	0
loc	18
ccs	12
cts	12
cp	1
rs	9.9
cc	2
nc	2
nop	2
crap	2

<?php

namespace Bdf\Prime\Console;

use Bdf\Prime\Connection\ConnectionInterface;

use Bdf\Prime\Connection\ConnectionRegistry;
use Bdf\Prime\Connection\Factory\ChainFactory;
use Bdf\Prime\Connection\Factory\ConnectionFactory;
use Bdf\Prime\Connection\Factory\ConnectionFactoryInterface;
use Bdf\Prime\Connection\Factory\MasterSlaveConnectionFactory;
use Bdf\Prime\Connection\Factory\ShardingConnectionFactory;
use Bdf\Prime\ConnectionManager;

use Bdf\Prime\ConnectionRegistryInterface;
use Bdf\Prime\ServiceLocator;
use Bdf\Util\Console\BdfStyle;
use Doctrine\DBAL\Connection as DoctrineConnection;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * @todo manage Shard and Master/slave connection

 * @todo remonve doctrine dependency

 */
abstract class DatabaseCommand extends Command
{
    /**
     * @var ConnectionRegistryInterface
     */
    private $registry;


    /**
     * @var ConnectionFactoryInterface
     */
    private $connectionFactory;

    /**
     * @var BdfStyle
     */
    protected $io;

    /**
     * DatabaseCommand constructor.
     *
     * @param ConnectionRegistryInterface $registry
     * @param ConnectionFactoryInterface $connectionFactory
     */
    public function __construct(/* ConnectionRegistryInterface */ $registry, ConnectionFactoryInterface $connectionFactory = null)

    {
        $this->registry = $registry;
        $this->connectionFactory = $connectionFactory;

        if ($registry instanceof ServiceLocator) {
            @trigger_error(__METHOD__.' signature has changed since 1.1. Inject instances '.ConnectionRegistryInterface::class.' '.ConnectionFactoryInterface::class);


            $factory = new ConnectionFactory();
            $this->connectionFactory = new ChainFactory([
                new MasterSlaveConnectionFactory($factory),
                new ShardingConnectionFactory($factory),
                $factory,
            ]);
            $this->registry = new ConnectionRegistry([], $this->connectionFactory, $registry->config());
            $this->registry = new ConnectionRegistry([], $this->connectionFactory, /** @scrutinizer ignore-deprecated */ $registry->config());
        }

        parent::__construct(static::$defaultName);
    }

    /**
     * {@inheritdoc}
     */
    protected function configure()
    {
        $this->addOption('connection', null, InputOption::VALUE_OPTIONAL, 'Interacts only on the database from this connection');
        $this->addOption('user', 'u', InputOption::VALUE_REQUIRED, 'Set the user name.', 'root');
        $this->addOption('password', 'p', InputOption::VALUE_REQUIRED, 'Set the user password.', '');
    }

    /**

     * {@inheritdoc}
     */
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $this->io = new BdfStyle($input, $output);

        $name = $this->io->option('connection');

        $connections = $name ? [$name] : $this->registry->getConnectionNames();


        foreach ($connections as $connectionName) {
            $connection = $this->registry->getConnection($connectionName);

            if (!$connection instanceof DoctrineConnection) {
                $this->io->line('Connection <comment>%s</comment> is ignored: only doctrine connection can be managed', $connectionName);
                continue;
            }

            $parameters = $connection->getParams();

            // Skip connections marked as "ignore" on configuration
            // Permit to declare SQLite connections, which do not supports database management
            if (!empty($parameters['ignore'])) {
                $this->io->line('Connection <comment>%s</comment> is ignored.', $connectionName);
                continue;
            }

            $dbName = $this->prepareConnectionConfig($parameters);
            $connectionTmp = $this->connectionFactory->create($connectionName, $parameters, $connection->getConfiguration());
            $schema = $connectionTmp->schema();

            if ($schema->hasDatabase($dbName)) {
                $this->interactWithDatabase($connectionTmp, $dbName);
                continue;
            }

            $this->interactWithNoDatabase($connectionTmp, $dbName);

            $connectionTmp->close();
                            close();
        }


        return 0;
    }

    /**
     * Prepare the configuration of the connection
     * Change the user and remove db name.

     *
     * @param array $parameters
     *
     * @return string The db name to interact
     */
    protected function prepareConnectionConfig(&$parameters): string

    {
        $user = $this->io->option('user');

        if (!isset($parameters['user']) || $parameters['user'] !== $user) {
            $parameters['user'] = $user;
            $parameters['password'] = $this->io->option('password');
        }

        // Force the connection with no database to allow doctrine to connect.
        $dbName = $parameters['dbname'] ?? $parameters['path'];

        $parameters['dbname'] = $parameters['path'] = $parameters['url'] = null;


        return $dbName;
    }

    /**
     * Interact if the database exists
     *
     * @param ConnectionInterface $connection
     * @param string $dbName
     */
    abstract protected function interactWithDatabase($connection, $dbName);


    /**
     * Interact if the database does not exist
     *
     * @param ConnectionInterface $connection
     * @param string $dbName
     */
    abstract protected function interactWithNoDatabase($connection, $dbName);

}


b2pweb / bdf-prime

Push — master ( 7a6bdd...324ce1 )

DatabaseCommand::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like