Relation::isPopulatable() - Code Metrics - Inspection of "add check for is Populatable for load results in r..." - bytic/orm - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — master ( 3bfa70...333906 )

by Gabriel

created 2018-10-24 18:17 UTC

Relation::isPopulatable() A

↳ Parent: Relation

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	5
ccs	3
cts	3
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0
crap	1

<?php

namespace Nip\Records\Relations;

use Nip\Database\Connections\Connection;
use Nip\Database\Query\AbstractQuery;
use Nip\Database\Query\Select as Query;
use Nip\HelperBroker;
use Exception;
use Nip\Records\Collections\Collection;
use Nip\Records\Collections\Collection as RecordCollection;
use Nip\Records\Locator\Exceptions\InvalidModelException;
use Nip\Records\Locator\ModelLocator;
use Nip\Records\Record;
use Nip\Records\RecordManager;
use Nip\Records\Relations\Exceptions\RelationsNeedsAName;
use Nip\Records\Relations\Traits\HasManagerTrait;
use Nip\Records\Traits\Relations\HasRelationsRecordsTrait;
use Nip\Records\Traits\Relations\HasRelationsRecordTrait;
use Nip_Helper_Arrays as ArraysHelper;

/**
 * Class Relation
 * @package Nip\Records\Relations
 */
abstract class Relation
{
    use HasManagerTrait;

    /**
     * @var
     */
    protected $name = null;

    /**
     * @var string
     */
    protected $type = 'relation';

    /**
     * @var Record
     */
    protected $item;

    /**
     * @var RecordManager
     */
    protected $with = null;

    /**
     * @var null|string
     */
    protected $table = null;

    /**
     * @var null|string
     */
    protected $fk = null;

    /**
     * @var Query
     */
    protected $query;

    /**
     * @var bool
     */
    protected $populated = false;

    /**
     * @var array
     */
    protected $params = [];

    /**
     * @var null|Collection|Record
     */
    protected $results = null;

    /**
     * @return Query
     * @throws Exception
     */
    public function getQuery()
    {
        if ($this->query == null) {
            $this->initQuery();
        }

        return $this->query;
    }

    /**
     * @param $query
     * @return static
     */
    public function setQuery($query)
    {
        $this->query = $query;

        return $this;
    }

    /**
     * @throws Exception
     */
    public function initQuery()
    {
        $query = $this->newQuery();
        $this->populateQuerySpecific($query);

        $this->query = $query;
    }

    /**
     * @return Query
     * @throws Exception
     */
    public function newQuery()
    {
        return $this->getWith()->paramsToQuery();
    }

    /**
     * @return RecordManager
     * @throws Exception
     */
    public function getWith()
    {
        if ($this->with == null) {
            $this->initWith();
        }

        return $this->with;
    }

    /**
     * @param RecordManager|HasRelationsRecordsTrait $object
     * @return $this
     */
    public function setWith($object)
    {
        $this->with = $object;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}

        return $this;
    }

    /**
     * @throws Exception
     */
    public function initWith()
    {
        $className = $this->getWithClass();
        $this->setWithClass($className);
    }

    /**
     * @return string
     */
    public function getWithClass()
    {
        return inflector()->pluralize($this->getName());
    }

    /**
     * @return mixed
     * @throws RelationsNeedsAName
     */
    public function getName()
    {
        if ($this->name === null) {
            throw new RelationsNeedsAName();
        }
        return $this->name;
    }

    /**
     * @param string $name
     */
    public function setName($name)
    {
        $this->name = $name;
    }

    /**
     * @param string $name
     * @throws Exception
     */
    public function setWithClass($name)
    {
        try {
            $manager = $this->getModelManagerInstance($name);
            $this->setWith($manager);
        } catch (InvalidModelException $exception) {
            throw new Exception(
                'Cannot instance records [' . $name . '] in ' . $this->debugString()
                . '|| with message ' . $exception->getMessage()
            );
        }
    }

    /**
     * @param $name
     * @return RecordManager
     * @throws InvalidModelException
     */
    public function getModelManagerInstance($name)
    {
        return ModelLocator::get($name);
    }

    /**
     * @return Record
     */
    public function getItem()
    {
        return $this->item;
    }

    /**
     * @param Record|HasRelationsRecordTrait $item
     * @return $this
     */
    public function setItem(Record $item)
    {
        $this->item = $item;

        return $this;
    }

    /**
     * @param AbstractQuery $query
     */
    abstract public function populateQuerySpecific(AbstractQuery $query);

    /**
     * @return \Nip\Database\Query\Delete
     * @throws Exception
     */
    public function getDeleteQuery()
    {
        $query = $this->getWith()->newDeleteQuery();
        $this->populateQuerySpecific($query);

        return $query;
    }

    /**
     * @return Connection
     */
    public function getDB()
    {
        return $this->getManager()->getDB();
    }

    /**
     * @param $key
     * @return mixed
     */
    public function getParam($key)
    {
        return $this->hasParam($key) ? $this->params[$key] : null;
    }

    /**
     * @param $key
     * @return boolean
     */
    public function hasParam($key)
    {
        return isset($this->params[$key]);
    }

    /**
     * @param $params
     * @throws Exception
     */
    public function addParams($params)
    {
        $this->checkParamClass($params);
        $this->checkParamWith($params);
        $this->checkParamTable($params);
        $this->checkParamFk($params);
        $this->setParams($params);
    }

    /**
     * @param $params
     * @throws Exception
     */
    public function checkParamClass($params)
    {
        if (isset($params['class'])) {
            $this->setWithClass($params['class']);
            unset($params['class']);
        }
    }

    /**
     * @param $params
     */
    public function checkParamWith($params)
    {
        if (isset($params['with'])) {
            $this->setWith($params['with']);
            unset($params['with']);
        }
    }

    /**
     * @param $params
     */
    public function checkParamTable($params)
    {
        if (isset($params['table'])) {
            $this->setTable($params['table']);
            unset($params['table']);
        }
    }

    /**
     * @param $params
     */
    public function checkParamFk($params)
    {
        if (isset($params['fk'])) {
            $this->setFK($params['fk']);
            unset($params['fk']);
        }
    }

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

    /**
     * @param $params
     */
    public function setParams($params)
    {
        $this->params = $params;
    }

    /**
     * @return string
     */
    public function getTable()
    {
        if ($this->table == null) {

            $this->initTable();
        }

        return $this->table;
    }

    /**
     * @param $name
     */
    public function setTable($name)
    {
        $this->table = $name;
    }

    protected function initTable()
    {
        $this->setTable($this->generateTable());
    }

    /**
     * @return string
     * @throws Exception
     */
    protected function generateTable()
    {
        return $this->getWith()->getTable();
    }

    /**
     * Get the results of the relationship.
     * @return Record|RecordCollection
     */
    public function getResults()
    {
        if (!$this->isPopulated()) {
            $this->initResults();
        }

        return $this->results;
    }

    /**
     * @param $results
     * @return null
     */
    public function setResults($results)
    {
        $this->results = $results;
        $this->populated = true;

        return $this->results;
    }

    /**
     * @return bool
     */
    public function isPopulatable()
    {
        $pk1 = $this->getManager()->getPrimaryKey();
        return !empty($this->getItem()->{$pk1});
    }

    /**
     * @return bool
     */
    public function isPopulated()
    {
        return $this->populated == true;

    }

    abstract public function initResults();

    /**
     * @param RecordCollection $collection
     * @return RecordCollection
     * @throws Exception
     */
    public function getEagerResults($collection)
    {
        if ($collection->count() < 1) {
            return $this->getWith()->newCollection();
        }
        $query = $this->getEagerQuery($collection);

        return $this->getWith()->findByQuery($query);
    }

    /**
     * @param RecordCollection $collection
     * @return Query
     * @throws Exception
     */
    public function getEagerQuery(RecordCollection $collection)
    {
        $fkList = $this->getEagerFkList($collection);
        $query = $this->populateEagerQueryFromFkList($this->newQuery(), $fkList);
        return $query;
    }

    /**
     * @param Query $query
     * @param array $fkList
     * @return Query
     * @throws Exception
     */
    protected function populateEagerQueryFromFkList($query, $fkList)
    {
        $query->where($this->getWithPK() . ' IN ?', $fkList);

        return $query;
    }

    /**
     * @param RecordCollection $collection
     * @return array
     */
    public function getEagerFkList(RecordCollection $collection)
    {
        /** @var ArraysHelper $arrayHelper */
        $arrayHelper = HelperBroker::get('Arrays');
        $return = $arrayHelper->pluck($collection, $this->getFK());

        return array_unique($return);
    }

    /**
     * @return string
     */
    public function getFK()
    {
        if ($this->fk == null) {

            $this->initFK();
        }

        return $this->fk;
    }

    /**
     * @param $name
     */
    public function setFK($name)
    {
        $this->fk = $name;
    }

    protected function initFK()
    {
        $this->setFK($this->generateFK());
    }

    /**
     * @return string
     */
    protected function generateFK()
    {
        return $this->getManager()->getPrimaryFK();
    }

    /**
     * @return string
     * @throws Exception
     */
    public function getWithPK()
    {
        return $this->getWith()->getPrimaryKey();
    }

    /**
     * @param RecordCollection $collection
     * @param RecordCollection $recordsLoaded
     *
     * @return RecordCollection
     */
    public function match(RecordCollection $collection, RecordCollection $recordsLoaded)
    {
        $dictionary = $this->buildDictionary($recordsLoaded);

        foreach ($collection as $record) {
            /** @var Record $record */
            $results = $this->getResultsFromCollectionDictionary($dictionary, $collection, $record);
            $record->getRelation($this->getName())->setResults($results);
        }

        return $recordsLoaded;
    }

    /**
     * Build model dictionary keyed by the relation's foreign key.
     *
     * @param RecordCollection $collection
     * @return array
     */
    abstract protected function buildDictionary(RecordCollection $collection);

    /**
     * @param $dictionary
     * @param Collection $collection
     * @param Record $record
     * @return mixed
     */
    abstract public function getResultsFromCollectionDictionary($dictionary, $collection, $record);

    public function save()
    {
    }

    /**
     * @return string
     */
    public function getType()
    {
        return $this->type;
    }

    /**
     * @return string
     */
    protected function debugString()
    {
        return 'Relation'
            . ' Manager:[' . ($this->hasManager() ? $this->getManager()->getClassName() : '') . ']'
            . ' name:[' . $this->getName() . '] '
            . ' params:[' . serialize($this->getParams()) . ']';
    }
}


1		<?php
2
3		namespace Nip\Records\Relations;
4
5		use Nip\Database\Connections\Connection;
6		use Nip\Database\Query\AbstractQuery;
7		use Nip\Database\Query\Select as Query;
8		use Nip\HelperBroker;
9		use Exception;
10		use Nip\Records\Collections\Collection;
11		use Nip\Records\Collections\Collection as RecordCollection;
12		use Nip\Records\Locator\Exceptions\InvalidModelException;
13		use Nip\Records\Locator\ModelLocator;
14		use Nip\Records\Record;
15		use Nip\Records\RecordManager;
16		use Nip\Records\Relations\Exceptions\RelationsNeedsAName;
17		use Nip\Records\Relations\Traits\HasManagerTrait;
18		use Nip\Records\Traits\Relations\HasRelationsRecordsTrait;
19		use Nip\Records\Traits\Relations\HasRelationsRecordTrait;
20		use Nip_Helper_Arrays as ArraysHelper;
21
22		/**
23		* Class Relation
24		* @package Nip\Records\Relations
25		*/
26		abstract class Relation
27		{
28		use HasManagerTrait;
29
30		/**
31		* @var
32		*/
33		protected $name = null;
34
35		/**
36		* @var string
37		*/
38		protected $type = 'relation';
39
40		/**
41		* @var Record
42		*/
43		protected $item;
44
45		/**
46		* @var RecordManager
47		*/
48		protected $with = null;
49
50		/**
51		* @var null\|string
52		*/
53		protected $table = null;
54
55		/**
56		* @var null\|string
57		*/
58		protected $fk = null;
59
60		/**
61		* @var Query
62		*/
63		protected $query;
64
65		/**
66		* @var bool
67		*/
68		protected $populated = false;
69
70		/**
71		* @var array
72		*/
73		protected $params = [];
74
75		/**
76		* @var null\|Collection\|Record
77		*/
78		protected $results = null;
79
80		/**
81		* @return Query
82		* @throws Exception
83		*/
84	1	public function getQuery()
85		{
86	1	if ($this->query == null) {
87	1	$this->initQuery();
88		}
89
90	1	return $this->query;
91		}
92
93		/**
94		* @param $query
95		* @return static
96		*/
97		public function setQuery($query)
98		{
99		$this->query = $query;
100
101		return $this;
102		}
103
104		/**
105		* @throws Exception
106		*/
107	1	public function initQuery()
108		{
109	1	$query = $this->newQuery();
110	1	$this->populateQuerySpecific($query);
111
112	1	$this->query = $query;
113	1	}
114
115		/**
116		* @return Query
117		* @throws Exception
118		*/
119	3	public function newQuery()
120		{
121	3	return $this->getWith()->paramsToQuery();
122		}
123
124		/**
125		* @return RecordManager
126		* @throws Exception
127		*/
128	9	public function getWith()
129		{
130	9	if ($this->with == null) {
131	4	$this->initWith();
132		}
133
134	9	return $this->with;
135		}
136
137		/**
138		* @param RecordManager\|HasRelationsRecordsTrait $object
139		* @return $this
140		*/
141	9	public function setWith($object)
142		{
143	9	$this->with = $object;
		0 ignored issues – show Documentation Bug introduced 2018-02-02 00:15 UTC by Report Bug Copy Issue Report It seems like `$object` can also be of type `object<Nip\Records\Trait...sRelationsRecordsTrait>`. However, the property `$with` is declared as type `object<Nip\Records\RecordManager>`. Maybe add an additional type check? Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a mixed type is assigned to a property that is type hinted more strictly. For example, imagine you have a variable `$accountId` that can either hold an Id object or false (if there is no account id yet). Your code now assigns that value to the `id` property of an instance of the `Account` class. This class holds a proper account, so the id value must no longer be false. Either this assignment is in error or a type check should be added for that assignment. class Id { public $id; public function __construct($id) { $this->id = $id; } } class Account { /** @var Id $id */ public $id; } $account_id = false; if (starsAreRight()) { $account_id = new Id(42); } $account = new Account(); if ($account instanceof Id) { $account->id = $account_id; } Loading history...
144
145	9	return $this;
146		}
147
148		/**
149		* @throws Exception
150		*/
151	4	public function initWith()
152		{
153	4	$className = $this->getWithClass();
154	4	$this->setWithClass($className);
155	4	}
156
157		/**
158		* @return string
159		*/
160	3	public function getWithClass()
161		{
162	3	return inflector()->pluralize($this->getName());
163		}
164
165		/**
166		* @return mixed
167		* @throws RelationsNeedsAName
168		*/
169	4	public function getName()
170		{
171	4	if ($this->name === null) {
172		throw new RelationsNeedsAName();
173		}
174	4	return $this->name;
175		}
176
177		/**
178		* @param string $name
179		*/
180	9	public function setName($name)
181		{
182	9	$this->name = $name;
183	9	}
184
185		/**
186		* @param string $name
187		* @throws Exception
188		*/
189	4	public function setWithClass($name)
190		{
191		try {
192	4	$manager = $this->getModelManagerInstance($name);
193	4	$this->setWith($manager);
194		} catch (InvalidModelException $exception) {
195		throw new Exception(
196		'Cannot instance records [' . $name . '] in ' . $this->debugString()
197		. '\|\| with message ' . $exception->getMessage()
198		);
199		}
200	4	}
201
202		/**
203		* @param $name
204		* @return RecordManager
205		* @throws InvalidModelException
206		*/
207	4	public function getModelManagerInstance($name)
208		{
209	4	return ModelLocator::get($name);
210		}
211
212		/**
213		* @return Record
214		*/
215	8	public function getItem()
216		{
217	8	return $this->item;
218		}
219
220		/**
221		* @param Record\|HasRelationsRecordTrait $item
222		* @return $this
223		*/
224	9	public function setItem(Record $item)
225		{
226	9	$this->item = $item;
227
228	9	return $this;
229		}
230
231		/**
232		* @param AbstractQuery $query
233		*/
234		abstract public function populateQuerySpecific(AbstractQuery $query);
235
236		/**
237		* @return \Nip\Database\Query\Delete
238		* @throws Exception
239		*/
240		public function getDeleteQuery()
241		{
242		$query = $this->getWith()->newDeleteQuery();
243		$this->populateQuerySpecific($query);
244
245		return $query;
246		}
247
248		/**
249		* @return Connection
250		*/
251	1	public function getDB()
252		{
253	1	return $this->getManager()->getDB();
254		}
255
256		/**
257		* @param $key
258		* @return mixed
259		*/
260	2	public function getParam($key)
261		{
262	2	return $this->hasParam($key) ? $this->params[$key] : null;
263		}
264
265		/**
266		* @param $key
267		* @return boolean
268		*/
269	2	public function hasParam($key)
270		{
271	2	return isset($this->params[$key]);
272		}
273
274		/**
275		* @param $params
276		* @throws Exception
277		*/
278	3	public function addParams($params)
279		{
280	3	$this->checkParamClass($params);
281	3	$this->checkParamWith($params);
282	3	$this->checkParamTable($params);
283	3	$this->checkParamFk($params);
284	3	$this->setParams($params);
285	3	}
286
287		/**
288		* @param $params
289		* @throws Exception
290		*/
291	3	public function checkParamClass($params)
292		{
293	3	if (isset($params['class'])) {
294		$this->setWithClass($params['class']);
295		unset($params['class']);
296		}
297	3	}
298
299		/**
300		* @param $params
301		*/
302	3	public function checkParamWith($params)
303		{
304	3	if (isset($params['with'])) {
305		$this->setWith($params['with']);
306		unset($params['with']);
307		}
308	3	}
309
310		/**
311		* @param $params
312		*/
313	3	public function checkParamTable($params)
314		{
315	3	if (isset($params['table'])) {
316		$this->setTable($params['table']);
317		unset($params['table']);
318		}
319	3	}
320
321		/**
322		* @param $params
323		*/
324	3	public function checkParamFk($params)
325		{
326	3	if (isset($params['fk'])) {
327		$this->setFK($params['fk']);
328		unset($params['fk']);
329		}
330	3	}
331
332		/**
333		* @return array
334		*/
335	1	public function getParams(): array
336		{
337	1	return $this->params;
338		}
339
340		/**
341		* @param $params
342		*/
343	3	public function setParams($params)
344		{
345	3	$this->params = $params;
346	3	}
347
348		/**
349		* @return string
350		*/
351	2	public function getTable()
352		{
353	2	if ($this->table == null) {
		0 ignored issues – show Bug introduced 2018-02-02 00:15 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing `$this->table` of type `null\|string` against `null`; this is ambiguous if the string can be empty. Consider using a strict comparison `===` instead. Loading history...
354	2	$this->initTable();
355		}
356
357	2	return $this->table;
358		}
359
360		/**
361		* @param $name
362		*/
363	2	public function setTable($name)
364		{
365	2	$this->table = $name;
366	2	}
367
368	2	protected function initTable()
369		{
370	2	$this->setTable($this->generateTable());
371	2	}
372
373		/**
374		* @return string
375		* @throws Exception
376		*/
377		protected function generateTable()
378		{
379		return $this->getWith()->getTable();
380		}
381
382		/**
383		* Get the results of the relationship.
384		* @return Record\|RecordCollection
385		*/
386	3	public function getResults()
387		{
388	3	if (!$this->isPopulated()) {
389	3	$this->initResults();
390		}
391
392	3	return $this->results;
393		}
394
395		/**
396		* @param $results
397		* @return null
398		*/
399	3	public function setResults($results)
400		{
401	3	$this->results = $results;
402	3	$this->populated = true;
403
404	3	return $this->results;
405		}
406
407		/**
408		* @return bool
409		*/
410	1	public function isPopulatable()
411		{
412	1	$pk1 = $this->getManager()->getPrimaryKey();
413	1	return !empty($this->getItem()->{$pk1});
414		}
415
416		/**
417		* @return bool
418		*/
419	3	public function isPopulated()
420		{
421	3	return $this->populated == true;
		0 ignored issues – show Coding Style Best Practice introduced 2018-02-02 00:15 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing two booleans. Considering using the strict comparison `===` instead. When comparing two booleans, it is generally considered safer to use the strict comparison operator. Loading history...
422		}
423
424		abstract public function initResults();
425
426		/**
427		* @param RecordCollection $collection
428		* @return RecordCollection
429		* @throws Exception
430		*/
431		public function getEagerResults($collection)
432		{
433		if ($collection->count() < 1) {
434		return $this->getWith()->newCollection();
435		}
436		$query = $this->getEagerQuery($collection);
437
438		return $this->getWith()->findByQuery($query);
439		}
440
441		/**
442		* @param RecordCollection $collection
443		* @return Query
444		* @throws Exception
445		*/
446	2	public function getEagerQuery(RecordCollection $collection)
447		{
448	2	$fkList = $this->getEagerFkList($collection);
449	2	$query = $this->populateEagerQueryFromFkList($this->newQuery(), $fkList);
450	2	return $query;
451		}
452
453		/**
454		* @param Query $query
455		* @param array $fkList
456		* @return Query
457		* @throws Exception
458		*/
459	1	protected function populateEagerQueryFromFkList($query, $fkList)
460		{
461	1	$query->where($this->getWithPK() . ' IN ?', $fkList);
462
463	1	return $query;
464		}
465
466		/**
467		* @param RecordCollection $collection
468		* @return array
469		*/
470	2	public function getEagerFkList(RecordCollection $collection)
471		{
472		/** @var ArraysHelper $arrayHelper */
473	2	$arrayHelper = HelperBroker::get('Arrays');
474	2	$return = $arrayHelper->pluck($collection, $this->getFK());
475
476	2	return array_unique($return);
477		}
478
479		/**
480		* @return string
481		*/
482	12	public function getFK()
483		{
484	12	if ($this->fk == null) {
		0 ignored issues – show Bug introduced 2018-02-02 00:15 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing `$this->fk` of type `null\|string` against `null`; this is ambiguous if the string can be empty. Consider using a strict comparison `===` instead. Loading history...
485	12	$this->initFK();
486		}
487
488	12	return $this->fk;
489		}
490
491		/**
492		* @param $name
493		*/
494	12	public function setFK($name)
495		{
496	12	$this->fk = $name;
497	12	}
498
499	12	protected function initFK()
500		{
501	12	$this->setFK($this->generateFK());
502	12	}
503
504		/**
505		* @return string
506		*/
507		protected function generateFK()
508		{
509		return $this->getManager()->getPrimaryFK();
510		}
511
512		/**
513		* @return string
514		* @throws Exception
515		*/
516	1	public function getWithPK()
517		{
518	1	return $this->getWith()->getPrimaryKey();
519		}
520
521		/**
522		* @param RecordCollection $collection
523		* @param RecordCollection $recordsLoaded
524		*
525		* @return RecordCollection
526		*/
527		public function match(RecordCollection $collection, RecordCollection $recordsLoaded)
528		{
529		$dictionary = $this->buildDictionary($recordsLoaded);
530
531		foreach ($collection as $record) {
532		/** @var Record $record */
533		$results = $this->getResultsFromCollectionDictionary($dictionary, $collection, $record);
534		$record->getRelation($this->getName())->setResults($results);
535		}
536
537		return $recordsLoaded;
538		}
539
540		/**
541		* Build model dictionary keyed by the relation's foreign key.
542		*
543		* @param RecordCollection $collection
544		* @return array
545		*/
546		abstract protected function buildDictionary(RecordCollection $collection);
547
548		/**
549		* @param $dictionary
550		* @param Collection $collection
551		* @param Record $record
552		* @return mixed
553		*/
554		abstract public function getResultsFromCollectionDictionary($dictionary, $collection, $record);
555
556		public function save()
557		{
558		}
559
560		/**
561		* @return string
562		*/
563		public function getType()
564		{
565		return $this->type;
566		}
567
568		/**
569		* @return string
570		*/
571	1	protected function debugString()
572		{
573		return 'Relation'
574	1	. ' Manager:[' . ($this->hasManager() ? $this->getManager()->getClassName() : '') . ']'
575	1	. ' name:[' . $this->getName() . '] '
576	1	. ' params:[' . serialize($this->getParams()) . ']';
577		}
578		}
579

bytic / orm

Push — master ( 3bfa70...333906 )

Relation::isPopulatable() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like