Comodojo\Cache\Drivers\Memory

Complexity

Total Complexity

28

Size/Duplication

Total Lines	184
Duplicated Lines	17.93 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

96.67%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	1	1
A	test()	0	5	1
A	get()	0	6	2
A	set()	0	14	3
A	delete()	0	9	2
A	clear()	0	20	3
A	getMultiple()	11	11	2
A	setMultiple()	11	11	2
A	deleteMultiple()	11	11	2
A	has()	0	5	1
A	stats()	0	5	1
A	checkNamespace()	0	12	3
B	checkMemory()	0	16	5

<?php namespace Comodojo\Cache\Drivers;

use \DateTime;

/**
 * @package     Comodojo Cache
 * @author      Marco Giovinazzi <marco.giovinazzi@comodojo.org>
 * @license     MIT
 *
 * LICENSE:
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

class Memory extends AbstractDriver {

    const DRIVER_NAME = "memory";

    /**
     * Cache repository
     *
     * @param array
     */
    private $data = [];

    /**
     * {@inheritdoc}
     */
    public function __construct(array $configuration = []) {}

        /**
         * {@inheritdoc}
         */
        public function test() {

        return true;

    }

    /**
     * {@inheritdoc}
     */
    public function get($key, $namespace) {

        return $this->checkMemory($key, $namespace) ?
            $this->data[$namespace][$key]['data'] : null;

    }

    /**
     * {@inheritdoc}
     */
    public function set($key, $namespace, $value, $ttl = null) {

        $this->checkNamespace($namespace, true);

        $expire = is_null($ttl) || $ttl == 0 ? 0 : new DateTime("now + $ttl secs");

        $this->data[$namespace][$key] = [
            'data' => $value,
            'expire' => $expire
        ];

        return true;

    }

    /**
     * {@inheritdoc}
     */
    public function delete($key, $namespace) {

        if ( !$this->checkMemory($key, $namespace) ) return false;

        unset($this->data[$namespace][$key]);

        return true;

    }

    /**
     * {@inheritdoc}
     */
    public function clear($namespace = null) {

        if ( $namespace == null ) {

It seems like you are loosely comparing $namespace of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

            $this->data = [];

            return true;

        } else {

            if ( $this->checkNamespace($namespace) ) {
                unset($this->data[$namespace]);
                return true;
            }

            return false;

        }

    }

    /**
     * {@inheritdoc}
     */
    public function getMultiple(array $keys, $namespace) {

This method seems to be duplicated in your project.

        $result = [];

        foreach ( $keys as $key ) {
            $result[$key] = $this->get($key, $namespace);
        }

        return $result;

    }

    /**
     * {@inheritdoc}
     */
    public function setMultiple(array $key_values, $namespace, $ttl = null) {

This method seems to be duplicated in your project.

        $result = [];

        foreach ( $key_values as $key => $value ) {
            $result[$key] = $this->set($key, $namespace, $value, $ttl);
        }

        return !in_array(false, $result);

    }

    /**
     * {@inheritdoc}
     */
    public function deleteMultiple(array $keys, $namespace) {

This method seems to be duplicated in your project.

        $result = [];

        foreach ( $keys as $key ) {
            $result[] = $this->delete($key, $namespace);
        }

        return !in_array(false, $result);

    }

    /**
     * {@inheritdoc}
     */
    public function has($key, $namespace) {

        return $this->checkMemory($key, $namespace);

    }

    /**
     * {@inheritdoc}
     */
    public function stats() {

        return ['objects' => count($this->data)];

    }

    private function checkNamespace($namespace, $create = false) {

        if ( array_key_exists($namespace, $this->data) ) {
            return true;
        } else if ( $create ) {
            $this->data[$namespace] = [];
            return true;
        } else {
            return false;
        }

    }

    private function checkMemory($key, $namespace) {

        $time = new DateTime('now');

        if ( !array_key_exists($namespace, $this->data)
            || !array_key_exists($key, $this->data[$namespace]) ) {
            return false;
        } else if ( $this->data[$namespace][$key]['expire'] === 0
            || $this->data[$namespace][$key]['expire'] > $time ) {
            return true;
        } else {
            unset($this->data[$namespace][$key]);
            return false;
        }

    }

}