Mattbit\Flat\Storage\DocumentStore

Complexity

Total Complexity

18

Size/Duplication

Total Lines	100
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

95.12%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getNamespace()	0	4	1
A	getEngine()	0	4	1
A	truncate()	0	4	1
A	insert()	0	15	3
A	update()	0	8	2
A	remove()	0	4	1
A	find()	0	4	1
B	scan()	0	18	6
A	generateId()	0	6	1

<?php

namespace Mattbit\Flat\Storage;

use Mattbit\Flat\Model\DocumentInterface;
use Mattbit\Flat\Storage\EncoderInterface;
use Mattbit\Flat\Exception\DuplicateKeyException;
use Mattbit\Flat\Storage\Filesystem\FilesystemCursor;

class DocumentStore
{
    /**
     * @var EngineInterface
     */
    protected $engine;

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

    /**
     * Create a DocumentStore instance.
     *
     * @param EngineInterface $engine
     * @param string $namespace
     */
    public function __construct(EngineInterface $engine, $namespace)
    {
        $this->engine = $engine;
        $this->namespace = $namespace;
    }

    public function getNamespace()
    {
        return $this->namespace;
    }

    public function getEngine()
    {
        return $this->engine;
    }

    public function truncate()
    {
        return $this->engine->clear($this->namespace);
    }

    public function insert(DocumentInterface $document)
    {
        if (!$id = $document->getId()) {
            $id = $this->generateId();
            $document->setId($id);
        }

        if ($this->engine->has($id, $this->namespace)) {
            throw new DuplicateKeyException("Cannot insert document with duplicate key: {$id}");
        }

        $this->engine->put($document, $id, $this->namespace);

        return $id;
    }

    public function update(DocumentInterface $document)
    {
        if (!$id = $document->getId()) {
            throw new \Exception("Cannot update a document without _id!");
        }

        return $this->engine->put($document, $id, $this->namespace);
    }

    public function remove($id)
    {
        return $this->engine->delete($id, $this->namespace);
    }

    public function find($id)
    {
        return $this->engine->get($id, $this->namespace);
    }

    public function scan(callable $filter = null, $limit = null)
    {
        $documents = [];

        $index = 0;
        foreach ($this->engine->all($this->namespace) as $document) {
            if ($limit && $index >= $limit) {
                break;
            }
            $index += 1;

            if (!$filter || call_user_func($filter, $document)) {
                $documents[] = $document;
            }
        }

        return $documents;
    }

    protected function generateId()
    {
        // A simple uniqid should have enough entropy.
        // @todo: evaluate the usage of ramsey/uuid
        return uniqid();
    }
}