hanneskod\yaysondb\Engine\FlysystemEngine

Complexity

Total Complexity

22

Size/Duplication

Total Lines	144
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	2
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\SourceModifiedException;
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 $fs;

    /**
     * @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;

    public function __construct(string $fname, FilesystemInterface $fs, DecoderInterface $decoder = null)
    {
        $this->fname = $fname;
        $this->fs = $fs;
        $this->decoder = $decoder ?: $this->guessDecoder();
        $this->reset();
    }

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

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

It seems like $raw defined by $this->fs->read($this->fname) on line 61 can also be of type false; however, hanneskod\yaysondb\Engine\DecoderInterface::decode() does only seem to accept string, did you maybe forget to handle an error condition?

    }

    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 ($this->docs) {

The expression $this->docs of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $this->inTransaction = true;
            $this->docs = [];
        }
    }

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

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

        $raw = $this->decoder->encode($this->docs);
        $this->fs->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->fs->getMimetype($this->fname)) {
            case 'application/x-httpd-php':
                return new PhpDecoder;
            case 'text/plain':
            case 'application/json':
            default:
                return new JsonDecoder;
        }
    }
}