Spiral\ORM\ORM

Complexity

Total Complexity

25

Size/Duplication

Total Lines	199
Duplicated Lines	9.05 %

Coupling/Cohesion

Components	3
Dependencies	6

Importance

Changes	13
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	18	18	1
A	setCache()	0	6	1
A	entityCache()	0	4	1
A	database()	0	4	1
B	schema()	0	4	5
B	record()	0	4	6
A	relation()	0	9	1
A	selector()	0	4	1
A	loader()	0	4	1
A	source()	0	4	2
A	mapper()	0	4	2
A	__clone()	0	8	2

<?php
/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */
namespace Spiral\ORM;

use Spiral\Core\Component;
use Spiral\Core\FactoryInterface;
use Spiral\Core\HippocampusInterface;
use Spiral\Database\DatabaseManager;
use Spiral\Debug\Traits\LoggerTrait;
use Spiral\ORM\Configs\ORMConfig;
use Spiral\ORM\Entities\EntityCache;
use Spiral\ORM\Entities\Loader;

class ORM extends Component implements ORMInterface
{
    use LoggerTrait;

    /**
     * Memory section to store ORM schema.
     */
    const MEMORY = 'orm.schema';

    /**
     * Normalized relation options.
     */
    const R_TYPE       = 0;
    const R_TABLE      = 1;
    const R_DEFINITION = 2;
    const R_DATABASE   = 3;

    /**
     * Pivot table data location in Record fields. Pivot data only provided when record is loaded
     * using many-to-many relation.
     */
    const PIVOT_DATA = '@pivot';

    /**
     * Record mappers.
     *
     * @var RecordMapper[]
     */
    private $mappers = [];

The property $mappers is not used and could be removed.

    /**
     * @var EntityCache
     */
    private $cache = null;

    /**
     * @var ORMConfig
     */
    protected $config = null;

    /**
     * @invisible
     *
     * @var DatabaseManager
     */
    protected $databases = null;

    /**
     * Cached records schema.
     *
     * @var array|null
     */
    protected $schema = null;

    /**
     * @invisible
     *
     * @var FactoryInterface
     */
    protected $factory = null;

    /**
     * @invisible
     *
     * @var HippocampusInterface
     */
    protected $memory = null;

    /**
     * @param ORMConfig            $config
     * @param DatabaseManager      $databases
     * @param EntityCache          $cache
     * @param HippocampusInterface $memory
     * @param FactoryInterface     $factory
     */
    public function __construct(

This method seems to be duplicated in your project.

        ORMConfig $config,
        DatabaseManager $databases,
        EntityCache $cache,
        HippocampusInterface $memory,
        FactoryInterface $factory
    ) {
        $this->config = $config;
        $this->databases = $databases;

        $this->cache = $cache;

        //ORM schema (cached)
        $this->memory = $memory;
        $this->schema = (array)$memory->loadData(static::MEMORY);

        $this->factory = $factory;
    }

    /**
     * @param EntityCache $cache
     * @return $this
     */
    public function setCache(EntityCache $cache)
    {
        $this->cache = $cache;

        return $this;
    }

    /**
     * @return EntityCache
     */
    public function entityCache()
    {
        return $this->cache;
    }

    /**
     * {@inheritdoc}
     */
    public function database($database)
    {

    }

    /**
     * {@inheritdoc}
     */
    public function schema($item, $property = null)
    {

    }

    /**
     * {@inheritdoc}
     */
    public function record($class, array $data, $cache = true)
    {

    }

    /**
     * {@inheritdoc}
     */
    public function relation(
        $type,
        RecordInterface $parent,
        $definition,
        $data = null,
        $loaded = false
    ) {

    }

    /**
     * {@inheritdoc}
     */
    public function selector($class, Loader $loader = null)
    {

    }

    /**
     * {@inheritdoc}
     */
    public function loader($type, $container, array $definition, Loader $parent = null)
    {

    }

    /**
     * {@inheritdoc}
     */
    public function source($class)

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

    {

    }

    /**
     * {@inheritdoc}
     */
    public function mapper($class)
    {

    }

    /**
     * When ORM is cloned we are automatically cloning it's cache as well to create
     * new isolated area. Basically we have cache enabled per selection.
     *
     * @see RecordSelector::getIterator()
     */
    public function __clone()
    {
        $this->cache = clone $this->cache;

        if (!$this->cache->isEnabled()) {
            $this->logger()->warning("ORM are cloned with disabled state");
        }
    }


}