RiakStore::__construct() - Code Metrics - Inspection of "Leaner dist packages" - webmozart/key-value-store - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#24)

unknown

created 2020-08-12 13:30 UTC

RiakStore::__construct() A

↳ Parent: RiakStore

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

Metric	Value
dl	0
loc	5
ccs	0
cts	5
cp	0
rs	10
c	0
b	0
f	0
nc	2
cc	2
nop	2
crap	6

<?php

/*
 * This file is part of the webmozart/key-value-store package.
 *
 * (c) Bernhard Schussek <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Webmozart\KeyValueStore;

use Basho\Riak\Riak;
use Exception;
use Webmozart\KeyValueStore\Api\KeyValueStore;
use Webmozart\KeyValueStore\Api\NoSuchKeyException;
use Webmozart\KeyValueStore\Api\ReadException;
use Webmozart\KeyValueStore\Api\WriteException;
use Webmozart\KeyValueStore\Util\KeyUtil;
use Webmozart\KeyValueStore\Util\Serializer;

/**
 * A key-value store backed by a Riak client.
 *
 * @since  1.0
 *
 * @author Bernhard Schussek <[email protected]>
 */
class RiakStore implements KeyValueStore
{
    /**
     * @var string
     */
    private $bucketName;

    /**
     * @var Riak
     */
    private $client;

    /**
     * Creates a store backed by a Riak client.
     *
     * If no client is passed, a new one is created using the default server
     * "127.0.0.1" and the default port 8098.
     *
     * @param string    $bucketName The name of the Riak bucket to use.
     * @param Riak|null $client     The client used to connect to Riak.
     */
    public function __construct($bucketName, Riak $client = null)
    {
        $this->bucketName = $bucketName;
        $this->client = $client ?: new Riak();
    }

    /**
     * {@inheritdoc}
     */
    public function set($key, $value)
    {
        KeyUtil::validate($key);

        $serialized = Serializer::serialize($value);

        try {
            $this->client->bucket($this->bucketName)->newBinary($key, $serialized)->store();
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        } catch (Exception $e) {
            throw WriteException::forException($e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function get($key, $default = null)
    {
        KeyUtil::validate($key);

        try {
            $object = $this->client->bucket($this->bucketName)->getBinary($key);
            $exists = $object->exists();
        } catch (Exception $e) {
            throw ReadException::forException($e);
        }

        if (!$exists) {
            return $default;
        }

        return Serializer::unserialize($object->getData());
    }

    /**
     * {@inheritdoc}
     */
    public function getOrFail($key)
    {
        KeyUtil::validate($key);

        try {
            $object = $this->client->bucket($this->bucketName)->getBinary($key);
            $exists = $object->exists();
        } catch (Exception $e) {
            throw ReadException::forException($e);
        }

        if (!$exists) {
            throw NoSuchKeyException::forKey($key);
        }

        return Serializer::unserialize($object->getData());
    }

    /**
     * {@inheritdoc}
     */
    public function getMultiple(array $keys, $default = null)
    {
        KeyUtil::validateMultiple($keys);

        $values = array();

        try {
            $bucket = $this->client->bucket($this->bucketName);

            foreach ($keys as $key) {
                $object = $bucket->getBinary($key);

                $values[$key] = $object->exists() ? $object->getData() : false;
            }
        } catch (Exception $e) {
            throw ReadException::forException($e);
        }

        foreach ($values as $key => $value) {
            $values[$key] = false === $value
                ? $default
                : Serializer::unserialize($value);
        }

        return $values;
    }

    /**
     * {@inheritdoc}
     */
    public function getMultipleOrFail(array $keys)
    {
        KeyUtil::validateMultiple($keys);

        $values = array();
        $notFoundKeys = array();

        try {
            $bucket = $this->client->bucket($this->bucketName);

            foreach ($keys as $key) {
                $values[$key] = $bucket->getBinary($key);

                if (!$values[$key]->exists()) {
                    $notFoundKeys[] = $key;
                }
            }
        } catch (Exception $e) {
            throw ReadException::forException($e);
        }

        if (0 !== count($notFoundKeys)) {
            throw NoSuchKeyException::forKeys($notFoundKeys);
        }

        foreach ($values as $key => $object) {
            $values[$key] = Serializer::unserialize($object->getData());
        }

        return $values;
    }

    /**
     * {@inheritdoc}
     */
    public function remove($key)
    {
        KeyUtil::validate($key);

        try {
            $object = $this->client->bucket($this->bucketName)->get($key);

            if (!$object->exists()) {
                return false;
            }

            $object->delete();
        } catch (Exception $e) {
            throw WriteException::forException($e);
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function exists($key)
    {
        KeyUtil::validate($key);

        try {
            return $this->client->bucket($this->bucketName)->get($key)->exists();
        } catch (Exception $e) {
            throw ReadException::forException($e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function clear()
    {
        try {
            $bucket = $this->client->bucket($this->bucketName);

            foreach ($bucket->getKeys() as $key) {
                $bucket->get($key)->delete();
            }
        } catch (Exception $e) {
            throw WriteException::forException($e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function keys()
    {
        try {
            return $this->client->bucket($this->bucketName)->getKeys();
        } catch (Exception $e) {
            throw ReadException::forException($e);
        }
    }
}


1		<?php
2
3		/*
4		* This file is part of the webmozart/key-value-store package.
5		*
6		* (c) Bernhard Schussek <[email protected]>
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace Webmozart\KeyValueStore;
13
14		use Basho\Riak\Riak;
15		use Exception;
16		use Webmozart\KeyValueStore\Api\KeyValueStore;
17		use Webmozart\KeyValueStore\Api\NoSuchKeyException;
18		use Webmozart\KeyValueStore\Api\ReadException;
19		use Webmozart\KeyValueStore\Api\WriteException;
20		use Webmozart\KeyValueStore\Util\KeyUtil;
21		use Webmozart\KeyValueStore\Util\Serializer;
22
23		/**
24		* A key-value store backed by a Riak client.
25		*
26		* @since 1.0
27		*
28		* @author Bernhard Schussek <[email protected]>
29		*/
30		class RiakStore implements KeyValueStore
31		{
32		/**
33		* @var string
34		*/
35		private $bucketName;
36
37		/**
38		* @var Riak
39		*/
40		private $client;
41
42		/**
43		* Creates a store backed by a Riak client.
44		*
45		* If no client is passed, a new one is created using the default server
46		* "127.0.0.1" and the default port 8098.
47		*
48		* @param string $bucketName The name of the Riak bucket to use.
49		* @param Riak\|null $client The client used to connect to Riak.
50		*/
51		public function __construct($bucketName, Riak $client = null)
52		{
53		$this->bucketName = $bucketName;
54		$this->client = $client ?: new Riak();
55		}
56
57		/**
58		* {@inheritdoc}
59		*/
60		public function set($key, $value)
61		{
62		KeyUtil::validate($key);
63
64		$serialized = Serializer::serialize($value);
65
66		try {
67		$this->client->bucket($this->bucketName)->newBinary($key, $serialized)->store();
		0 ignored issues – show Documentation introduced 2015-12-28 16:08 UTC by Report Bug Copy Issue Report `$serialized` is of type `string`, but the function expects a `object`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
68		} catch (Exception $e) {
69		throw WriteException::forException($e);
70		}
71		}
72
73		/**
74		* {@inheritdoc}
75		*/
76	View Code Duplication	public function get($key, $default = null)
77		{
78		KeyUtil::validate($key);
79
80		try {
81		$object = $this->client->bucket($this->bucketName)->getBinary($key);
82		$exists = $object->exists();
83		} catch (Exception $e) {
84		throw ReadException::forException($e);
85		}
86
87		if (!$exists) {
88		return $default;
89		}
90
91		return Serializer::unserialize($object->getData());
92		}
93
94		/**
95		* {@inheritdoc}
96		*/
97	View Code Duplication	public function getOrFail($key)
98		{
99		KeyUtil::validate($key);
100
101		try {
102		$object = $this->client->bucket($this->bucketName)->getBinary($key);
103		$exists = $object->exists();
104		} catch (Exception $e) {
105		throw ReadException::forException($e);
106		}
107
108		if (!$exists) {
109		throw NoSuchKeyException::forKey($key);
110		}
111
112		return Serializer::unserialize($object->getData());
113		}
114
115		/**
116		* {@inheritdoc}
117		*/
118		public function getMultiple(array $keys, $default = null)
119		{
120		KeyUtil::validateMultiple($keys);
121
122		$values = array();
123
124		try {
125		$bucket = $this->client->bucket($this->bucketName);
126
127		foreach ($keys as $key) {
128		$object = $bucket->getBinary($key);
129
130		$values[$key] = $object->exists() ? $object->getData() : false;
131		}
132		} catch (Exception $e) {
133		throw ReadException::forException($e);
134		}
135
136		foreach ($values as $key => $value) {
137		$values[$key] = false === $value
138		? $default
139		: Serializer::unserialize($value);
140		}
141
142		return $values;
143		}
144
145		/**
146		* {@inheritdoc}
147		*/
148		public function getMultipleOrFail(array $keys)
149		{
150		KeyUtil::validateMultiple($keys);
151
152		$values = array();
153		$notFoundKeys = array();
154
155		try {
156		$bucket = $this->client->bucket($this->bucketName);
157
158		foreach ($keys as $key) {
159		$values[$key] = $bucket->getBinary($key);
160
161		if (!$values[$key]->exists()) {
162		$notFoundKeys[] = $key;
163		}
164		}
165		} catch (Exception $e) {
166		throw ReadException::forException($e);
167		}
168
169		if (0 !== count($notFoundKeys)) {
170		throw NoSuchKeyException::forKeys($notFoundKeys);
171		}
172
173		foreach ($values as $key => $object) {
174		$values[$key] = Serializer::unserialize($object->getData());
175		}
176
177		return $values;
178		}
179
180		/**
181		* {@inheritdoc}
182		*/
183		public function remove($key)
184		{
185		KeyUtil::validate($key);
186
187		try {
188		$object = $this->client->bucket($this->bucketName)->get($key);
189
190		if (!$object->exists()) {
191		return false;
192		}
193
194		$object->delete();
195		} catch (Exception $e) {
196		throw WriteException::forException($e);
197		}
198
199		return true;
200		}
201
202		/**
203		* {@inheritdoc}
204		*/
205		public function exists($key)
206		{
207		KeyUtil::validate($key);
208
209		try {
210		return $this->client->bucket($this->bucketName)->get($key)->exists();
211		} catch (Exception $e) {
212		throw ReadException::forException($e);
213		}
214		}
215
216		/**
217		* {@inheritdoc}
218		*/
219		public function clear()
220		{
221		try {
222		$bucket = $this->client->bucket($this->bucketName);
223
224		foreach ($bucket->getKeys() as $key) {
225		$bucket->get($key)->delete();
226		}
227		} catch (Exception $e) {
228		throw WriteException::forException($e);
229		}
230		}
231
232		/**
233		* {@inheritdoc}
234		*/
235		public function keys()
236		{
237		try {
238		return $this->client->bucket($this->bucketName)->getKeys();
239		} catch (Exception $e) {
240		throw ReadException::forException($e);
241		}
242		}
243		}
244

webmozart / key-value-store

Pull Request — master (#24)

RiakStore::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like