hanneskod\yaysondb\Engine\FlysystemEngine

Complexity

Total Complexity

23

Size/Duplication

Total Lines	151
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	3
A	getId()	0	4	1
A	reset()	0	7	1
A	getIterator()	0	6	2
A	has()	0	4	1
A	read()	0	8	2
A	write()	0	14	2
A	delete()	0	11	2
A	clear()	0	7	2
A	inTransaction()	0	4	1
A	commit()	0	11	2
A	guessDecoder()	0	11	4

<?php

declare(strict_types = 1);

namespace hanneskod\yaysondb\Engine;

use hanneskod\yaysondb\Exception\FileNotFoundException;
use hanneskod\yaysondb\Exception\FileModifiedException;
use League\Flysystem\FilesystemInterface;

/**
 * Engine based on a flysystem
 */
class FlysystemEngine implements EngineInterface
{
    /**
     * @var string Name of source file
     */
    private $fname;

    /**
     * @var FilesystemInterface Filesystem where source is found
     */
    private $fsystem;

    /**
     * @var DecoderInterface Decoder used to encode and deconde content
     */
    private $decoder;

    /**
     * @var array Loaded documents
     */
    private $docs;

    /**
     * @var string Hash of source at last reset
     */
    private $hash;

    /**
     * @var bool Flag if there are un-commited changes
     */
    private $inTransaction;

    /**
     * @throws FileNotFoundException If fname does not exist in filesystem
     */
    public function __construct(string $fname, FilesystemInterface $fsystem, DecoderInterface $decoder = null)
    {
        if (!$fsystem->has($fname)) {
            throw new FileNotFoundException("Unable to read file $fname");
        }

        $this->fname = $fname;
        $this->fsystem = $fsystem;
        $this->decoder = $decoder ?: $this->guessDecoder();
        $this->reset();
    }

    public function getId(): string
    {
        return $this->fname;
    }

    public function reset()
    {
        $this->inTransaction = false;
        $raw = (string)$this->fsystem->read($this->fname);
        $this->hash = md5($raw);
        $this->docs = $this->decoder->decode($raw);
    }

    public function getIterator(): \Generator
    {
        foreach ($this->docs as $id => $doc) {
            yield $id => $doc;
        }
    }

    public function has(string $id): bool
    {
        return isset($this->docs[$id]);
    }

    public function read(string $id): array
    {
        if ($this->has($id)) {
            return (array)$this->docs[$id];
        }

        return [];
    }

    public function write(string $id, array $doc): string
    {
        $this->inTransaction = true;

        if ('' !== $id) {
            $this->docs[$id] = $doc;
            return $id;
        }

        $this->docs[] = $doc;
        end($this->docs);

        return (string)key($this->docs);
    }

    public function delete(string $id): bool
    {
        if ($this->has($id)) {
            $this->inTransaction = true;
            unset($this->docs[$id]);

            return true;
        }

        return false;
    }

    public function clear()
    {
        if (!empty($this->docs)) {
            $this->inTransaction = true;
            $this->docs = [];
        }
    }

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

    /**
     * @throws FileModifiedException If source is out of date
     */
    public function commit()
    {
        if (md5($this->fsystem->read($this->fname)) != $this->hash) {
            throw new FileModifiedException('Unable to commit changes: source data has changed');
        }

        $raw = $this->decoder->encode($this->docs);
        $this->fsystem->update($this->fname, $raw);
        $this->hash = md5($raw);
        $this->inTransaction = false;
    }

    /**
     * Create a decoder based of source file mime-type
     */
    private function guessDecoder(): DecoderInterface
    {
        switch ($this->fsystem->getMimetype($this->fname)) {
            case 'application/x-httpd-php':
                return new PhpDecoder;
            case 'text/plain':
            case 'application/json':
            default:
                return new JsonDecoder;
        }
    }
}