Respect\Structural\Mapper

Complexity

Total Complexity

60

Size/Duplication

Total Lines	372
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

47%

Importance

Changes	2
Bugs	1	Features	1

30 Methods

Rating	Name	Duplication	Size	Complexity
B	extractAndOperateMixins()	0	28	4
A	fetchSingle()	0	19	3
A	__construct()	0	6	1
A	__get()	0	4	1
A	flushSingle()	0	13	3
B	persist()	0	24	4
A	guessCondition()	0	8	1
A	rawDelete()	0	8	1
A	rawUpdate()	0	8	1
A	rawInsert()	0	5	1
A	flush()	0	12	3
A	createStatement()	0	10	1
A	generateQuery()	0	4	1
A	extractColumns()	0	6	1
A	hasComposition()	0	6	2
A	getNewEntityByName()	0	8	2
A	transformSingleRow()	0	10	2
A	inferSet()	0	10	2
A	fetchMulti()	0	14	2
A	createEntities()	0	23	3
B	buildEntitiesInstances()	0	24	6
B	postHydrate()	0	14	5
A	tryHydration()	0	11	3
A	getSetterStyle()	0	6	1
A	getFilters()	0	4	1
A	getMixins()	0	4	1
A	getType()	0	4	1
A	mixable()	0	4	1
A	typable()	0	4	1
A	filterable()	0	4	1

<?php

For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 27 and the first side effect is on line 13.

namespace Respect\Structural;

use Exception;
use Respect\Data\AbstractMapper;
use Respect\Data\CollectionIterator;
use Respect\Data\Collections as c;
use Respect\Data\Collections\Collection;
use SplObjectStorage;

/** Maps objects to nosql operations */
class Mapper extends AbstractMapper implements

Possible parse error: class missing opening or closing brace

    c\Filterable,
    c\Mixable,
    c\Typable
{
    /** @var \Respect\Structural\Driver Holds our connector* */
    protected $driver;

    /** @var string Namespace to look for entities * */
    public $entityNamespace = '\\';

    /**
     * @param Driver $driver
     */
    public function __construct(Driver $driver)
    {
        parent::__construct();

        $this->driver = $driver;
    }

    /**
     * @return Mapper
     */
    public function __get($name)
    {
        return parent::__get($name);
    }

    /**
     * Flushes a single instance into the database. This method supports
     * mixing, so flushing a mixed instance will flush distinct tables on the
     * database
     *
     * @param object $entity Entity instance to be flushed
     *
     * @return null
     */
    protected function flushSingle($entity)
    {
        $coll = $this->tracked[$entity];
        $cols = $this->extractColumns($entity, $coll);

        if ($this->removed->contains($entity)) {
            $this->rawDelete($coll, $entity);
        } elseif ($this->new->contains($entity)) {
            $this->rawInsert($coll, $entity);
        } else {
            $this->rawUpdate($cols, $coll);
        }
    }

    public function persist($object, Collection $onCollection)
    {
        $next = $onCollection->getNext();

        if ($this->filterable($onCollection)) {
            $next->setMapper($this);
            $next->persist($object);

            return;
        }

        if ($next) {
            $remote = $this->getStyle()->remoteIdentifier($next->getName());
            $next->setMapper($this);
            $next->persist($object->$remote);
        }

        foreach ($onCollection->getChildren() as $child) {
            $remote = $this->getStyle()->remoteIdentifier($child->getName());
            $child->persist($object->$remote);
        }

        return parent::persist($object, $onCollection);
    }

    /**
     * Receives columns from an entity and her collection. Returns the columns
     * that belong only to the main entity. This method supports mixing, so
     * extracting mixins will also persist them on their respective
     * tables
     *
     * @param \Respect\Data\Collections\Collection $collection Target collection
     * @param array                                $cols       Entity columns
     *
     * @return array Columns left for the main collection
     */
    protected function extractAndOperateMixins(Collection $collection, $cols)
    {
        if (!$this->mixable($collection)) {
            return $cols;
        }

        foreach ($this->getMixins($collection) as $mix => $spec) {
            //Extract from $cols only the columns from the mixin
            $mixCols = array_intersect_key(
                $cols,
                array_combine(//create array with keys only
                    $spec,
                    array_fill(0, count($spec), '')
                )
            );
            if (isset($cols["{$mix}_id"])) {
                $mixCols['id'] = $cols["{$mix}_id"];
                $cols = array_diff($cols, $mixCols); //Remove mixin columns
                $this->rawUpdate($mixCols, $this->__get($mix));

$this->__get($mix) is of type object<Respect\Structural\Mapper>, but the function expects a object<Respect\Data\Collections\Collection>.

            } else {
                $mixCols['id'] = null;
                $cols = array_diff($cols, $mixCols); //Remove mixin columns
                $this->rawinsert($mixCols, $this->__get($mix));

$mixCols is of type array<string,null,{"id":"null"}>, but the function expects a object<Respect\Data\Collections\Collection>.

            }
        }

        return $cols;
    }

    protected function guessCondition(&$columns, Collection $collection)
    {
        $primaryName = $this->getStyle()->identifier($collection->getName());
        $condition = [$primaryName => $columns[$primaryName]];
        unset($columns[$primaryName]);

        return $condition;
    }

    protected function rawDelete(Collection $collection, $entity)
    {
        $name = $collection->getName();
        $columns = $this->extractColumns($entity, $collection);
        $condition = $this->guessCondition($columns, $collection);

        return $this->driver->remove($name, $condition);
    }

    protected function rawUpdate(array $columns, Collection $collection)
    {
        $columns = $this->extractAndOperateMixins($collection, $columns);
        $name = $collection->getName();
        $condition = $this->guessCondition($columns, $collection);

        $this->driver->update($name, $condition, $columns);
    }

    protected function rawInsert(Collection $collection, $entity = null)
    {
        $name = $collection->getName();
        $this->driver->insert($name, $entity);
    }

    public function flush()
    {
        try {
            foreach ($this->changed as $entity) {
                $this->flushSingle($entity);
            }
        } catch (Exception $e) {
            throw $e;
        }

        $this->reset();
    }

    protected function createStatement(Collection $collection, $withExtra = null)
    {
        $query = $this->generateQuery($collection);

        $withExtraList = (array)$withExtra;

        $withExtraList = array_merge($withExtraList, $query);

        return $this->driver->find($collection->getName(), $withExtraList);
    }

    protected function generateQuery(Collection $collection)
    {
        return $this->driver->generateQuery($collection);
    }

    protected function extractColumns($entity, Collection $collection)

The parameter $collection is not used and could be removed.

    {
        $cols = get_object_vars($entity);

        return $cols;
    }

    protected function hasComposition($entity, $next, $parent)
    {
        $style = $this->getStyle();

        return $entity === $style->composed($parent, $next) || $entity === $style->composed($next, $parent);
    }

    protected function fetchSingle(Collection $collection, $statement)
    {
        $name = $collection->getName();
        $entityName = $name;
        $row = $this->driver->fetch($statement);

        if (!$row) {

The expression $row 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.

            return false;
        }

        if ($this->typable($collection)) {
            $entityName = $row->{$this->getType($collection)};
        }

        $entities = new SplObjectStorage();
        $entities[$this->transformSingleRow($row, $entityName)] = $collection;

        return $entities;
    }

    protected function getNewEntityByName($entityName)
    {
        $entityName = $this->getStyle()->styledName($entityName);
        $entityClass = $this->entityNamespace . $entityName;
        $entityClass = class_exists($entityClass) ? $entityClass : '\stdClass';

        return new $entityClass;
    }

    protected function transformSingleRow($row, $entityName)
    {
        $newRow = $this->getNewEntityByName($entityName);

        foreach ($row as $prop => $value) {
            $this->inferSet($newRow, $prop, $value);
        }

        return $newRow;
    }

    protected function inferSet(&$entity, $prop, $value)
    {
        try {
            $mirror = new \ReflectionProperty($entity, $prop);
            $mirror->setAccessible(true);
            $mirror->setValue($entity, $value);
        } catch (\ReflectionException $e) {
            $entity->$prop = $value;
        }
    }

    protected function fetchMulti(Collection $collection, $statement)
    {
        $row = $this->driver->fetch($statement);

        if (!$row) {

The expression $row 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.

            return false;
        }

        $this->postHydrate(
            $entities = $this->createEntities($row, $statement, $collection)
        );

        return $entities;
    }

    protected function createEntities($row, $statement, Collection $collection)
    {
        $entities = new SplObjectStorage();
        $entitiesInstances = $this->buildEntitiesInstances($collection, $entities);
        $entityInstance = array_pop($entitiesInstances);

        //Reversely traverses the columns to avoid conflicting foreign key names
        foreach (array_reverse($row, true) as $col => $value) {
            $columnMeta = $statement->getColumnMeta($col);
            $columnName = $columnMeta['name'];
            $primaryName = $this->getStyle()->identifier(
                $entities[$entityInstance]->getName()
            );

            $this->inferSet($entityInstance, $columnName, $value);

            if ($primaryName == $columnName) {
                $entityInstance = array_pop($entitiesInstances);
            }
        }

        return $entities;
    }

    protected function buildEntitiesInstances(Collection $collection, SplObjectStorage $entities)
    {
        $entitiesInstances = [];

        foreach (CollectionIterator::recursive($collection) as $c) {
            if ($this->filterable($c) && !$this->getFilters($c)) {
                continue;
            }

            $entityInstance = $this->getNewEntityByName($c->getName());

            if ($this->mixable($c)) {
                $mixins = $this->getMixins($c);
                foreach ($mixins as $mix) {
                    $entitiesInstances[] = $entityInstance;
                }
            }

            $entities[$entityInstance] = $c;
            $entitiesInstances[] = $entityInstance;
        }

        return $entitiesInstances;
    }

    protected function postHydrate(SplObjectStorage $entities)
    {
        $entitiesClone = clone $entities;

        foreach ($entities as $instance) {
            foreach ($instance as $field => &$value) {
                if ($this->getStyle()->isRemoteIdentifier($field)) {
                    foreach ($entitiesClone as $sub) {
                        $this->tryHydration($entities, $sub, $field, $value);
                    }
                }
            }
        }
    }

    protected function tryHydration($entities, $sub, $field, &$value)
    {
        $tableName = $entities[$sub]->getName();
        $primaryName = $this->getStyle()->identifier($tableName);

        if ($tableName === $this->getStyle()->remoteFromIdentifier($field)
            && $sub->{$primaryName} === $value
        ) {
            $value = $sub;
        }
    }

    protected function getSetterStyle($name)
    {
        $name = str_replace('_', '', $this->getStyle()->styledProperty($name));

        return "set{$name}";
    }

    public function getFilters(Collection $collection)
    {
        return $collection->getExtra('filters');
    }

    public function getMixins(Collection $collection)
    {
        return $collection->getExtra('mixins');
    }

    public function getType(Collection $collection)
    {
        return $collection->getExtra('type');
    }

    public function mixable(Collection $collection)
    {
        return $collection->have('mixins');
    }

    public function typable(Collection $collection)
    {
        return $collection->have('type');
    }

    public function filterable(Collection $collection)
    {
        return $collection->have('filters');
    }
}

It seems like the identation of this line is off (expected at least 4 spaces, but found 0).