Prozorov\Repositories\FixturableRepository

Complexity

Total Complexity

26

Size/Duplication

Total Lines	201
Duplicated Lines	0 %

Test Coverage

Coverage

14.75%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	first()	0	7	2
A	delete()	0	9	2
A	update()	0	9	2
A	getById()	0	7	2
A	exists()	0	7	2
A	get()	0	7	2
A	getByIdOrFail()	0	7	2
A	count()	0	7	2
A	rollbackTransaction()	0	9	2
A	create()	0	7	2
A	fixtures()	0	3	1
A	isFake()	0	4	1
A	commitTransaction()	0	9	2
A	openTransaction()	0	9	2

<?php

declare(strict_types=1);

namespace Prozorov\Repositories;

use Prozorov\Repositories\Contracts\RepositoryInterface;
use Prozorov\Repositories\Exceptions\DataNotFound;
use Prozorov\Repositories\Exceptions\NotImplemented;

abstract class FixturableRepository implements RepositoryInterface
{
    abstract protected function doGet($params): ?iterable;

    abstract protected function doFirst(array $filter);

    abstract protected function doGetById(int $id, array $select = null);

    abstract protected function doGetByIdOrFail(int $id, array $select = null);

    abstract protected function doCreate(array $data);

    abstract protected function doUpdate($model, array $data): void;

    abstract protected function doDelete($model): void;

    abstract protected function doExists(array $filter): bool;

    abstract protected function doCount(array $filter = []): int;

    abstract protected function doOpenTransaction(): void;

    abstract protected function doCommitTransaction(): void;

    abstract protected function doRollbackTransaction(): void;

    /**
     * isFake.
     *
     * @access	protected
     * @return	bool
     */
    protected function isFake(): bool
    {
        // Fixtures mode is disabled by default. Please refer to the documentation
        return false;
    }

    /**
     * getFixtures.
     *
     * @access	protected
     * @return	ArrayRepository
     */
    protected function fixtures(): ArrayRepository
    {
        throw new RuntimeException('Fixtures mode is disabled. Please refer to the documentation');

The type Prozorov\Repositories\RuntimeException was not found. Did you mean RuntimeException? If so, make sure to prefix the type with \.

    }

    /**
     * {@inheritDoc}
     */
    public function get($params): ?iterable
    {
        if ($this->isFake()) {
            return $this->fixtures()->get($params);
        }

        return $this->doGet($params);
    }

    /**
     * {@inheritDoc}
     */
    public function first(array $filter)
    {
        if ($this->isFake()) {
            return $this->fixtures()->first($filter);
        }

        return $this->doFirst($filter);
    }

    /**
     * {@inheritDoc}
     */
    public function getById(int $id, array $select = null)
    {
        if ($this->isFake()) {
            return $this->fixtures()->getById($id, $select);
        }

        return $this->doGetById($id, $select);
    }

    /**
     * {@inheritDoc}
     */
    public function getByIdOrFail(int $id, array $select = null)
    {
        if ($this->isFake()) {
            return $this->fixtures()->getByIdOrFail($id, $select);
        }

        return $this->doGetByIdOrFail($id, $select);
    }

    /**
     * {@inheritDoc}
     */
    public function create(array $data)
    {
        if ($this->isFake()) {
            return $this->fixtures()->create($data);
        }

        return $this->doCreate($data);
    }

    /**
     * {@inheritDoc}
     */
    public function update($model, array $data): void
    {
        if ($this->isFake()) {
            $this->fixtures()->update($model, $data);

            return;
        }

        $this->doUpdate($model, $data);
    }

    /**
     * {@inheritDoc}
     */
    public function delete($model): void
    {
        if ($this->isFake()) {
            $this->fixtures()->delete($model);

            return;
        }

        $this->doDelete($model);
    }

    /**
     * {@inheritDoc}
     */
    public function exists(array $filter): bool
    {
        if ($this->isFake()) {
            return $this->fixtures()->exists($filter);
        }

        return $this->doExists($filter);
    }

    /**
     * {@inheritDoc}
     */
    public function count(array $filter = []): int
    {
        if ($this->isFake()) {
            return $this->fixtures()->count($filter);
        }

        return $this->doCount($filter);
    }

    /**
     * {@inheritDoc}
     */
    public function openTransaction(): void
    {
        if ($this->isFake()) {
            $this->fixtures()->openTransaction();

            return;
        }

        $this->doOpenTransaction();
    }

    /**
     * {@inheritDoc}
     */
    public function commitTransaction(): void
    {
        if ($this->isFake()) {
            $this->fixtures()->commitTransaction();

            return;
        }

        $this->doCommitTransaction();
    }

    /**
     * {@inheritDoc}
     */
    public function rollbackTransaction(): void
    {
        if ($this->isFake()) {
            $this->fixtures()->rollbackTransaction();

            return;
        }

        $this->doRollbackTransaction();
    }
}