MemcachedAdapter::__construct() - Code Metrics - Inspection of "fix: migrate to 7.4" - LinioIT/cache - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#46)

by Klaus

created 2020-01-02 16:48 UTC

MemcachedAdapter::__construct() B

↳ Parent: Project

Complexity

Conditions	10
Paths	48

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	36
rs	7.6666
c	0
b	0
f	0
cc	10
nc	48
nop	1

How to fix Complexity

<?php

declare(strict_types=1);

namespace Linio\Component\Cache\Adapter;

use Linio\Component\Cache\Exception\InvalidConfigurationException;
use Linio\Component\Cache\Exception\KeyNotFoundException;
use Memcached;

class MemcachedAdapter extends AbstractAdapter implements AdapterInterface
{
    protected int $ttl = 0;

    protected Memcached $memcached;

    public function __construct(array $config = [])
    {
        $this->validateMemcacheConfiguration($config);

        // default config
        $this->ttl = 0;

        // config
        if (isset($config['ttl'])) {
            $this->ttl = (int) $config['ttl'];
        }

        $persistentId = null;
        if (isset($config['connection_persistent']) && $config['connection_persistent']) {
            $persistentId = '1';

            if (isset($config['pool_size']) && $config['pool_size'] > 1) {
                $persistentId = (string) random_int(1, $config['pool_size']);
            }
        }

        $this->memcached = new Memcached($persistentId);
        $this->memcached->addServers($config['servers']);

        if (isset($config['options']) && !empty($config['options'])) {
            $this->memcached->setOptions($config['options']);
        }

        if ($this->namespace) {
            $this->memcached->setOption(Memcached::OPT_PREFIX_KEY, $this->namespace);
        }

        if (isset($config['cache_not_found_keys'])) {
            $this->cacheNotFoundKeys = (bool) $config['cache_not_found_keys'];
        }
    }

    /**
     * @return mixed
     */
    public function get(string $key)
    {
        $value = $this->memcached->get($key);

        if ($this->memcached->getResultCode() == Memcached::RES_NOTFOUND) {
            throw new KeyNotFoundException();
        }

        return $value;
    }

    public function getMulti(array $keys): array
    {
        $values = $this->memcached->getMulti($keys);

        if ($values === false) {
            throw new KeyNotFoundException();
        }

        return $values;
    }

    /**
     * @param mixed $value
     */
    public function set(string $key, $value): bool
    {
        return $this->memcached->set($key, $value, $this->ttl);
    }

    public function setMulti(array $data): bool
    {
        return $this->memcached->setMulti($data, $this->ttl);
    }

    public function contains(string $key): bool
    {
        try {
            $this->get($key);
        } catch (KeyNotFoundException $exception) {
            return false;
        }

        return true;
    }

    public function delete(string $key): bool
    {
        $this->memcached->delete($key);

        return true;
    }

    public function deleteMulti(array $keys): bool
    {
        $this->memcached->deleteMulti($keys);

        return true;
    }

    public function flush(): bool
    {
        return $this->memcached->flush();
    }

    protected function validateMemcacheConfiguration(array $config): void
    {
        if (!array_key_exists('servers', $config)) {
            throw new InvalidConfigurationException('Missing configuration parameter: servers');
        }

        if (!is_array($config['servers'])) {
            throw new InvalidConfigurationException('Invalid configuration parameter: servers');
        }

        foreach ($config['servers'] as $server) {
            if (!is_array($server) || count($server) < 2 || count($server) > 3 || !is_numeric($server[1]) || (isset($server[2]) && !is_numeric($server[2]))) {
                throw new InvalidConfigurationException('Invalid configuration parameter: servers');
            }
        }

        if (array_key_exists('options', $config) && !is_array($config['options'])) {
            throw new InvalidConfigurationException('Invalid configuration parameter: options');
        }

        if (isset($config['ttl']) && !is_numeric($config['ttl'])) {
            throw new InvalidConfigurationException('Invalid configuration parameter: ttl');
        }
    }

    public function setNamespace(string $namespace): void
    {
        parent::setNamespace($namespace);
        $this->memcached->setOption(Memcached::OPT_PREFIX_KEY, $this->namespace);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Linio\Component\Cache\Adapter;
6
7			use Linio\Component\Cache\Exception\InvalidConfigurationException;
8			use Linio\Component\Cache\Exception\KeyNotFoundException;
9			use Memcached;
10
11			class MemcachedAdapter extends AbstractAdapter implements AdapterInterface
12			{
13			protected int $ttl = 0;
			0 ignored issues – show Bug introduced 2020-01-02 16:29 UTC by Report Bug Copy Issue Report This code did not parse for me. Apparently, there is an error somewhere around this line: Syntax error, unexpected T_STRING, expecting T_FUNCTION or T_CONST Loading history...
14			protected Memcached $memcached;
15
16			public function __construct(array $config = [])
17			{
18			$this->validateMemcacheConfiguration($config);
19
20			// default config
21			$this->ttl = 0;
22
23			// config
24			if (isset($config['ttl'])) {
25			$this->ttl = (int) $config['ttl'];
26			}
27
28			$persistentId = null;
29			if (isset($config['connection_persistent']) && $config['connection_persistent']) {
30			$persistentId = '1';
31
32			if (isset($config['pool_size']) && $config['pool_size'] > 1) {
33			$persistentId = (string) random_int(1, $config['pool_size']);
34			}
35			}
36
37			$this->memcached = new Memcached($persistentId);
38			$this->memcached->addServers($config['servers']);
39
40			if (isset($config['options']) && !empty($config['options'])) {
41			$this->memcached->setOptions($config['options']);
42			}
43
44			if ($this->namespace) {
45			$this->memcached->setOption(Memcached::OPT_PREFIX_KEY, $this->namespace);
46			}
47
48			if (isset($config['cache_not_found_keys'])) {
49			$this->cacheNotFoundKeys = (bool) $config['cache_not_found_keys'];
50			}
51			}
52
53			/**
54			* @return mixed
55			*/
56			public function get(string $key)
57			{
58			$value = $this->memcached->get($key);
59
60			if ($this->memcached->getResultCode() == Memcached::RES_NOTFOUND) {
61			throw new KeyNotFoundException();
62			}
63
64			return $value;
65			}
66
67			public function getMulti(array $keys): array
68			{
69			$values = $this->memcached->getMulti($keys);
70
71			if ($values === false) {
72			throw new KeyNotFoundException();
73			}
74
75			return $values;
76			}
77
78			/**
79			* @param mixed $value
80			*/
81			public function set(string $key, $value): bool
82			{
83			return $this->memcached->set($key, $value, $this->ttl);
84			}
85
86			public function setMulti(array $data): bool
87			{
88			return $this->memcached->setMulti($data, $this->ttl);
89			}
90
91			public function contains(string $key): bool
92			{
93			try {
94			$this->get($key);
95			} catch (KeyNotFoundException $exception) {
96			return false;
97			}
98
99			return true;
100			}
101
102			public function delete(string $key): bool
103			{
104			$this->memcached->delete($key);
105
106			return true;
107			}
108
109			public function deleteMulti(array $keys): bool
110			{
111			$this->memcached->deleteMulti($keys);
112
113			return true;
114			}
115
116			public function flush(): bool
117			{
118			return $this->memcached->flush();
119			}
120
121			protected function validateMemcacheConfiguration(array $config): void
122			{
123			if (!array_key_exists('servers', $config)) {
124			throw new InvalidConfigurationException('Missing configuration parameter: servers');
125			}
126
127			if (!is_array($config['servers'])) {
128			throw new InvalidConfigurationException('Invalid configuration parameter: servers');
129			}
130
131			foreach ($config['servers'] as $server) {
132			if (!is_array($server) \|\| count($server) < 2 \|\| count($server) > 3 \|\| !is_numeric($server[1]) \|\| (isset($server[2]) && !is_numeric($server[2]))) {
133			throw new InvalidConfigurationException('Invalid configuration parameter: servers');
134			}
135			}
136
137			if (array_key_exists('options', $config) && !is_array($config['options'])) {
138			throw new InvalidConfigurationException('Invalid configuration parameter: options');
139			}
140
141			if (isset($config['ttl']) && !is_numeric($config['ttl'])) {
142			throw new InvalidConfigurationException('Invalid configuration parameter: ttl');
143			}
144			}
145
146			public function setNamespace(string $namespace): void
147			{
148			parent::setNamespace($namespace);
149			$this->memcached->setOption(Memcached::OPT_PREFIX_KEY, $this->namespace);
150			}
151			}
152

LinioIT / cache

Pull Request — master (#46)

MemcachedAdapter::__construct() B

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like