SimpleMapper\ActiveRow

Complexity

Total Complexity

28

Size/Duplication

Total Lines	261
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

80.36%

Importance

Changes	1
Bugs	0	Features	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	__get()	0	5	2
A	getRecord()	0	4	1
A	getTable()	0	4	1
A	setTable()	0	4	1
A	__toString()	0	4	1
A	toArray()	0	4	1
A	getPrimary()	0	4	1
A	getSignature()	0	4	1
A	update()	0	4	1
A	delete()	0	4	1
A	ref()	0	11	2
A	related()	0	5	2
A	getIterator()	0	4	1
A	offsetGet()	0	5	2
A	offsetExists()	0	4	1
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
A	setReferencingRecord()	0	4	1
A	getReferencingRecord()	0	4	1
A	mmRelated()	0	8	2
A	prepareRecord()	0	5	1
A	prepareSelection()	0	5	1

<?php

declare(strict_types=1);

namespace SimpleMapper;

use Nette\Database\Table\Selection as NetteDatabaseSelection;
use Nette\Database\Table\ActiveRow as NetteDatabaseActiveRow;
use ArrayIterator;
use IteratorAggregate;
use Nette\Database\Table\IRow;
use Nette\DeprecatedException;
use SimpleMapper\Exception\ActiveRowException;
use SimpleMapper\Structure\Structure;

class ActiveRow implements IteratorAggregate, IRow
{
    /** @var NetteDatabaseActiveRow */
    protected $record;

    /** @var Structure */
    protected $structure;

    /** @var ActiveRow|null */
    protected $referencingRecord;

    /**
     * @param NetteDatabaseActiveRow $record
     * @param Structure $structure
     */
    public function __construct(NetteDatabaseActiveRow $record, Structure $structure)
    {
        $this->record = $record;
        $this->structure = $structure;
    }

    /**
     * @param string $name
     * @return mixed|ActiveRow
     */
    public function __get($name)
    {
        $result = $this->record->$name;
        return $result instanceof IRow ? $this->prepareRecord($result) : $result;
    }

    /**
     * @return NetteDatabaseActiveRow
     */
    public function getRecord(): NetteDatabaseActiveRow
    {
        return $this->record;
    }

    /**
     * @return NetteDatabaseSelection
     */
    public function getTable(): NetteDatabaseSelection
    {
        return $this->record->getTable();
    }

    /**
     * @param NetteDatabaseSelection $selection
     * @throws ActiveRowException
     */
    public function setTable(NetteDatabaseSelection $selection): void
    {
        throw new ActiveRowException('Internal IRow interface method');
    }

    /**********************************************************************\
     * Wrapper function
    \**********************************************************************/

    /**
     * @return string
     */
    public function __toString(): string
    {
        return (string) $this->record;
    }

    /**
     * @return array
     */
    public function toArray(): array
    {
        return $this->record->toArray();
    }

    /**
     * @param bool|true $need
     * @return mixed
     */
    public function getPrimary($need = true)
    {
        return $this->record->getPrimary($need);
    }

    /**
     * @param bool|true $need
     * @return string
     */
    public function getSignature($need = true): string
    {
        return $this->record->getSignature($need);
    }

    /**
     * @param array|\Traversable $data
     * @return bool
     */
    public function update($data): bool
    {
        return $this->record->update($data);
    }

    /**
     * @return int
     */
    public function delete(): int
    {
        return $this->record->delete();
    }

    /**
     * Returns referenced row
     * @param string $key
     * @param string $throughColumn
     * @return ActiveRow|null
     */
    public function ref($key, $throughColumn = null): ?ActiveRow
    {
        $row = $this->record->ref($key, $throughColumn);
        if($row instanceof IRow) {
            $result = $this->prepareRecord($row);
            $result->setReferencingRecord($this);
            return $result;
        }

        return null;
    }

    /**
     * Returns referencing rows
     * @param string $key
     * @param string $throughColumn
     * @return Selection
     */
    public function related($key, $throughColumn = null): ?Selection
    {
        $selection = $this->record->related($key, $throughColumn);
        return $selection instanceof NetteDatabaseSelection ? $this->prepareSelection($selection) : null;
    }

    /**********************************************************************\
     * IteratorAggregate interface
    \**********************************************************************/

    /**
     * @return ArrayIterator
     */
    public function getIterator(): ArrayIterator
    {
        return $this->record->getIterator();
    }

    /**********************************************************************\
     * ArrayAccess interface
    \**********************************************************************/

    /**
     * Returns value of column
     * @param string $key  column name
     * @return mixed
     */
    public function offsetGet($key)
    {
        $result = $this->record->offsetGet($key);
        return $result instanceof IRow ? $this->prepareRecord($result) : $result;
    }

    /**
     * Tests if column exists
     * @param string $key   column name
     * @return bool
     */
    public function offsetExists($key): bool
    {
        return $this->record->offsetExists($key);
    }

    /**
     * Stores value in column
     * @param string $key   column name
     * @param string $value
     * @throws DeprecatedException
     */
    public function offsetSet($key, $value): void
    {
        $this->record->offsetSet($key, $value);
    }

    /**
     * Removes column from data
     * @param string $key column name
     * @throws DeprecatedException
     */
    public function offsetUnset($key): void
    {
        $this->record->offsetUnset($key);
    }

    /**********************************************************************\
     * Extend methods
    \**********************************************************************/

    /**
     * @param ActiveRow $row
     */
    public function setReferencingRecord(ActiveRow $row): void
    {
        $this->referencingRecord = $row;
    }

    /**
     * @return null|ActiveRow
     */
    public function getReferencingRecord(): ?ActiveRow
    {
        return $this->referencingRecord;
    }

    /**
     * Returns mm referencing rows
     * @param Selection $selection
     * @param string $ref
     * @param string $refPrimary
     * @return array
     */
    protected function mmRelated(Selection $selection, string $ref, string $refPrimary = 'id'): array
    {
        $result = [];
        foreach ($selection as $row) {
            $result[$row->ref($ref)->$refPrimary] = $row->ref($ref);
        }
        return $result;
    }

    /**********************************************************************\
     * Build methods
    \**********************************************************************/

    /**
     * Prepare one record
     * @param IRow $row
     * @return ActiveRow
     */
    protected function prepareRecord(IRow $row): ActiveRow
    {
        $recordClass = $this->structure->getActiveRowClass($row->getTable()->getName());
        return new $recordClass($row, $this->structure);
    }

    /**
     * Prepare selection
     * @param NetteDatabaseSelection $selection
     * @return Selection
     */
    protected function prepareSelection(NetteDatabaseSelection $selection): Selection
    {
        $selectionClass = $this->structure->getSelectionClass($selection->getName());
        return new $selectionClass($selection, $this->structure);
    }
}