Mattbit\Flat\Storage\DocumentStore

Complexity

Total Complexity

19

Size/Duplication

Total Lines	126
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes	3
Bugs	1	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	getNamespace()	0	4	1
A	truncate()	0	10	2
A	insertDocument()	0	14	3
A	updateDocument()	0	11	2
A	removeDocument()	0	6	1
A	findDocument()	0	7	1
B	scanDocuments()	0	20	6
A	path()	0	4	1
A	generateId()	0	5	1

<?php

namespace Mattbit\Flat\Storage;

use Mattbit\Flat\Document\Document;
use Mattbit\Flat\Document\Identifiable;

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

    /**
     * @var EncoderInterface
     */
    protected $encoder;

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

    /**
     * @var \League\Flysystem\FilesystemInterface
     */
    protected $filesystem;

    /**
     * Create a RecordStore instance.
     *
     * @param Engine $engine
     * @param string $namespace
     */
    public function __construct(Engine $engine, $namespace)
    {
        $this->engine = $engine;
        $this->namespace = $namespace;
        $this->filesystem = $this->engine->getFilesystem();
        $this->encoder = $this->engine->getEncoder();
    }

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

    public function truncate()
    {
        $files = $this->filesystem->listContents($this->namespace);

        foreach ($files as $file) {
            $this->filesystem->delete($file['path']);
        }

        return true;
    }

    public function insertDocument(Identifiable $document)
    {
        $id = $document->getId() ?: $this->generateId();
        $path = $this->path($id);

        if ($this->filesystem->has($this->path($id))) {
            throw new \Exception("Duplicate _id: {$id}");
        }

        $data = $this->encoder->encode($document);

$document is of type object<Mattbit\Flat\Document\Identifiable>, but the function expects a object<Mattbit\Flat\Document\Encodable>.

        $this->filesystem->put($path, $data);

        return $id;
    }

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

        $data = $this->encoder->encode($document);

$document is of type object<Mattbit\Flat\Document\Identifiable>, but the function expects a object<Mattbit\Flat\Document\Encodable>.

        $path = $this->path($id);

        return $this->filesystem->put($path, $data);
    }

    public function removeDocument($documentId)
    {
        $path = $this->path($documentId);

        return $this->filesystem->delete($path);
    }

    public function findDocument($documentId)
    {
        $path = $this->path($documentId);
        $data = $this->filesystem->read($path);

        return $this->encoder->decode($data);
    }

    public function scanDocuments(callable $filter = null, $limit = null)
    {
        $files = $this->filesystem->listContents($this->namespace);
        $documents = [];

        foreach ($files as $index => $file) {
            if ($limit && $index >= $limit) {
                break;
            }

            $data = $this->filesystem->read($file['path']);
            $document = $this->encoder->decode($data);

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

        return $documents;
    }

    protected function path($id)
    {
        return sprintf('%s/%s.%s', $this->namespace, $id, $this->encoder->getExtension());
    }

    protected function generateId()
    {
        // A simple uniqid should have enough entropy.
        return uniqid();
    }
}