SfCod\SocketIoBundle\Service\RedisDriver

Complexity

Total Complexity

24

Size/Duplication

Total Lines	176
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getClient()	0	15	3
A	getHost()	0	4	1
A	getPort()	0	4	1
A	getUser()	0	4	1
A	getPassword()	0	4	1
A	getDatabase()	0	4	1
A	getSocket()	0	4	1
B	parseDsn()	0	33	11
A	parseParameters()	0	19	3

<?php

namespace SfCod\SocketIoBundle\Service;

use Predis\Client;

/**
 * Class RedisDriver.
 *
 * @package SfCod\SocketIoBundle\drivers
 */
class RedisDriver
{
    /**
     * @var string
     */
    protected $dsn;

    /**
     * @var string
     */
    protected $host;

    /**
     * @var int
     */
    protected $port;

    /**
     * @var string
     */
    protected $user;

    /**
     * @var string
     */
    protected $password;

    /**
     * @var string
     */
    protected $database;

    /**
     * @var string
     */
    protected $socket;

    /**
     * @var
     */
    protected $client;

    /**
     * RedisDriver constructor.
     */
    public function __construct(string $dsn = 'redis://localhost:6379')
    {
        $this->dsn = $dsn;
        $this->parseDsn($dsn);
    }

    /**
     * Get redis client.
     */
    public function getClient(bool $reset = false): Client
    {
        if (is_null($this->client) || $reset) {
            $this->client = new Client([
                'scheme' => 'tcp',
                'read_write_timeout' => 0,
                'host' => $this->host,
                'port' => $this->port,
                'database' => $this->database,
                'password' => $this->password,
            ]);
        }

        return $this->client;
    }

    public function getHost(): string
    {
        return $this->host;
    }

    public function getPort(): int
    {
        return $this->port;
    }

    /**
     * @return string
     */
    public function getUser(): ?string
    {
        return $this->user;
    }

    /**
     * @return string
     */
    public function getPassword(): ?string
    {
        return $this->password;
    }

    /**
     * @return string
     */
    public function getDatabase(): ?string
    {
        return $this->database;
    }

    /**
     * @return string
     */
    public function getSocket(): ?string
    {
        return $this->socket;
    }

    /**
     * Parse dsn and get all needed attributes.
     *
     * @param string $dsn
     */
    protected function parseDsn($dsn)
    {
        $dsn = str_replace('redis://', '', $dsn); // remove "redis://"
        if (false !== $pos = strrpos($dsn, '@')) {
            // parse password
            $password = substr($dsn, 0, $pos);
            if (strstr($password, ':')) {
                list(, $password) = explode(':', $password, 2);
            }
            $this->password = urldecode($password);
            $dsn = substr($dsn, $pos + 1);
        }
        $dsn = preg_replace_callback('/\?(.*)$/', [$this, 'parseParameters'], $dsn); // parse parameters
        if (preg_match('#^(.*)/(\d+|%[^%]+%|env_\w+_[[:xdigit:]]{32,})$#', $dsn, $matches)) {
            // parse database
            $this->database = is_numeric($matches[2]) ? (int)$matches[2] : $matches[2];

It seems like is_numeric($matches[2]) ? (int) $matches[2] : $matches[2] can also be of type integer. However, the property $database is declared as type string. Maybe add an additional type check?

            $dsn = $matches[1];
        }
        if (preg_match('#^([^:]+)(:(\d+|%[^%]+%|env_\w+_[[:xdigit:]]{32,}))?$#', $dsn, $matches)) {
            if (!empty($matches[1])) {
                // parse host/ip or socket
                if ('/' === $matches[1][0]) {
                    $this->socket = $matches[1];
                } else {
                    $this->host = $matches[1];
                }
            }
            if (null === $this->socket && !empty($matches[3])) {
                // parse port
                $this->port = is_numeric($matches[3]) ? (int)$matches[3] : $matches[3];

It seems like is_numeric($matches[3]) ? (int) $matches[3] : $matches[3] can also be of type string. However, the property $port is declared as type integer. Maybe add an additional type check?

            }
        }
    }

    /**
     * @param array $matches
     *
     * @return string
     */
    protected function parseParameters($matches)
    {
        parse_str($matches[1], $params);
        foreach ($params as $key => $val) {

The expression $params of type null|array is not guaranteed to be traversable. How about adding an additional type check?

            if (!$val) {
                continue;
            }
//            switch ($key) {
//                case 'weight':
//                    $this->weight = (int)$val;
//                    break;
//                case 'alias':
//                    $this->alias = $val;
//                    break;
//            }
        }

        return '';
    }
}