ORM::schema() - Code Metrics - Inspection of "record and record entity" - spiral/components - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — feature/pre-split (d91fae)

by Anton

created 2016-05-05 17:52 UTC

ORM::schema() B

↳ Parent: ORM

Complexity

Conditions	5
Paths	8

Size

Total Lines	4
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes	9
Bugs	0	Features	0

Metric	Value
cc	5
eloc	10
c	9
b	0
f	0
nc	8
nop	2
dl	0
loc	4
rs	8.8571

<?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 = [];


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

        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)

    {

    }

    /**
     * {@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");
        }
    }


}

1		<?php
2		/**
3		* Spiral Framework.
4		*
5		* @license MIT
6		* @author Anton Titov (Wolfy-J)
7		*/
8		namespace Spiral\ORM;
9
10		use Spiral\Core\Component;
11		use Spiral\Core\FactoryInterface;
12		use Spiral\Core\HippocampusInterface;
13		use Spiral\Database\DatabaseManager;
14		use Spiral\Debug\Traits\LoggerTrait;
15		use Spiral\ORM\Configs\ORMConfig;
16		use Spiral\ORM\Entities\EntityCache;
17		use Spiral\ORM\Entities\Loader;
18
19		class ORM extends Component implements ORMInterface
20		{
21		use LoggerTrait;
22
23		/**
24		* Memory section to store ORM schema.
25		*/
26		const MEMORY = 'orm.schema';
27
28		/**
29		* Normalized relation options.
30		*/
31		const R_TYPE = 0;
32		const R_TABLE = 1;
33		const R_DEFINITION = 2;
34		const R_DATABASE = 3;
35
36		/**
37		* Pivot table data location in Record fields. Pivot data only provided when record is loaded
38		* using many-to-many relation.
39		*/
40		const PIVOT_DATA = '@pivot';
41
42		/**
43		* Record mappers.
44		*
45		* @var RecordMapper[]
46		*/
47		private $mappers = [];
		0 ignored issues – show Unused Code introduced 2016-05-05 17:57 UTC by Report Bug Copy Issue Report The property `$mappers` is not used and could be removed. This check marks private properties in classes that are never used. Those properties can be removed. Loading history...
48
49		/**
50		* @var EntityCache
51		*/
52		private $cache = null;
53
54		/**
55		* @var ORMConfig
56		*/
57		protected $config = null;
58
59		/**
60		* @invisible
61		*
62		* @var DatabaseManager
63		*/
64		protected $databases = null;
65
66		/**
67		* Cached records schema.
68		*
69		* @var array\|null
70		*/
71		protected $schema = null;
72
73		/**
74		* @invisible
75		*
76		* @var FactoryInterface
77		*/
78		protected $factory = null;
79
80		/**
81		* @invisible
82		*
83		* @var HippocampusInterface
84		*/
85		protected $memory = null;
86
87		/**
88		* @param ORMConfig $config
89		* @param DatabaseManager $databases
90		* @param EntityCache $cache
91		* @param HippocampusInterface $memory
92		* @param FactoryInterface $factory
93		*/
94	View Code Duplication	public function __construct(
		0 ignored issues – show Duplication introduced 2016-05-05 17:57 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
95		ORMConfig $config,
96		DatabaseManager $databases,
97		EntityCache $cache,
98		HippocampusInterface $memory,
99		FactoryInterface $factory
100		) {
101		$this->config = $config;
102		$this->databases = $databases;
103
104		$this->cache = $cache;
105
106		//ORM schema (cached)
107		$this->memory = $memory;
108		$this->schema = (array)$memory->loadData(static::MEMORY);
109
110		$this->factory = $factory;
111		}
112
113		/**
114		* @param EntityCache $cache
115		* @return $this
116		*/
117		public function setCache(EntityCache $cache)
118		{
119		$this->cache = $cache;
120
121		return $this;
122		}
123
124		/**
125		* @return EntityCache
126		*/
127		public function entityCache()
128		{
129		return $this->cache;
130		}
131
132		/**
133		* {@inheritdoc}
134		*/
135		public function database($database)
136		{
137
138		}
139
140		/**
141		* {@inheritdoc}
142		*/
143		public function schema($item, $property = null)
144		{
145
146		}
147
148		/**
149		* {@inheritdoc}
150		*/
151		public function record($class, array $data, $cache = true)
152		{
153
154		}
155
156		/**
157		* {@inheritdoc}
158		*/
159		public function relation(
160		$type,
161		RecordInterface $parent,
162		$definition,
163		$data = null,
164		$loaded = false
165		) {
166
167		}
168
169		/**
170		* {@inheritdoc}
171		*/
172		public function selector($class, Loader $loader = null)
173		{
174
175		}
176
177		/**
178		* {@inheritdoc}
179		*/
180		public function loader($type, $container, array $definition, Loader $parent = null)
181		{
182
183		}
184
185		/**
186		* {@inheritdoc}
187		*/
188		public function source($class)
		0 ignored issues – show Unused Code introduced 2016-05-05 17:57 UTC by Report Bug Copy Issue Report The parameter `$class` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
189		{
190
191		}
192
193		/**
194		* {@inheritdoc}
195		*/
196		public function mapper($class)
197		{
198
199		}
200
201		/**
202		* When ORM is cloned we are automatically cloning it's cache as well to create
203		* new isolated area. Basically we have cache enabled per selection.
204		*
205		* @see RecordSelector::getIterator()
206		*/
207		public function __clone()
208		{
209		$this->cache = clone $this->cache;
210
211		if (!$this->cache->isEnabled()) {
212		$this->logger()->warning("ORM are cloned with disabled state");
213		}
214		}
215
216
217		}

spiral / components

Branch — feature/pre-split (d91fae)

ORM::schema() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like