MetadataRelationHolder::getRelationsByKey() - Code Metrics - Inspection of "Fix relation calculation, attempt 2" - Algo-Web/POData-Laravel - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#107)

by Alex

created 2017-09-04 13:38 UTC

MetadataRelationHolder::getRelationsByKey() D

↳ Parent: MetadataRelationHolder

Complexity

Conditions	18
Paths	15

Size

Total Lines	86
Code Lines	55

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	86
rs	4.7996
c	0
b	0
f	0
cc	18
eloc	55
nc	15
nop	2

How to fix Long Method Complexity

<?php

namespace AlgoWeb\PODataLaravel\Models;

use Illuminate\Database\Eloquent\Model;

class MetadataRelationHolder
{
    protected $multConstraints = [ '0..1' => ['1'], '1' => ['0..1', '*'], '*' => ['1', '*']];
    protected $relations = [];

    public function __construct()
    {
    }

    /**
     * Add model's relationships to holder
     *
     * @param Model $model
     */
    public function addModel(Model $model)
    {
        if (!in_array('AlgoWeb\\PODataLaravel\\Models\\MetadataTrait', class_uses($model))) {
            $msg = 'Supplied model does not use MetadataTrait';
            throw new \InvalidArgumentException($msg);
        }
        $className = get_class($model);
        if (array_key_exists($className, $this->relations)) {
            $msg = $className.' already added';
            throw new \InvalidArgumentException($msg);
        }
        $this->relations[$className] = $model->getRelationships();
    }

    public function getRelationsByKey($className, $keyName)
    {
        $this->checkClassExists($className);

        $rels = $this->relations[$className];
        if (!array_key_exists($keyName, $rels)) {
            $msg = 'Key ' . $keyName . ' not registered on ' . $className;
            throw new \InvalidArgumentException($msg);
        }

        $result = [];
        $payload = $rels[$keyName];
        $principalType = $className;
        $numRel = 0;
        $isKnown = false;

        foreach ($payload as $dependentType => $targDeets) {
            if (!array_key_exists($dependentType, $this->relations)) {
                continue;
            }
            // if principal and ostensible dependent type are equal, drop through to specific handler
            // at moment, this is only for morphTo relations - morphedByMany doesn't cause this
            if ($principalType === $dependentType) {
                $morphToLines = $this->getMorphToRelations($principalType, $targDeets, $keyName);
                foreach ($morphToLines as $morph) {
                    if (!in_array($morph, $result)) {
                        $result[] = $morph;
                    }
                }
                $isKnown = true;
                continue;
            }

            $foreign = $this->relations[$dependentType];

            foreach ($targDeets as $principalProperty => $rawDeets) {
                $targKey = $rawDeets['local'];
                $principalMult = $rawDeets['multiplicity'];
                $principalProperty = $rawDeets['property'];
                if (!array_key_exists($targKey, $foreign)) {
                    continue;
                }
                $numRel++;

                $foreignDeets = $foreign[$targKey];
                foreach ($foreignDeets as $foreignType => $raw) {
                    if (!array_key_exists($foreignType, $this->relations)) {
                        continue;
                    }
                    foreach ($raw as $dependentProperty => $dependentPayload) {
                        if ($principalType !== $foreignType) {
                            if (null === $dependentPayload['type']) {
                                continue;
                            }
                        }
                        if ($keyName == $dependentPayload['local']) {
                            $dependentMult = $dependentPayload['multiplicity'];
                            // generate forward and reverse relations
                            list($forward, $reverse) = $this->calculateRoundTripRelationsGenForwardReverse(
                                $principalType,
                                $principalMult,
                                $principalProperty,
                                $dependentType,
                                $dependentMult,
                                $dependentProperty
                            );
                            if (!in_array($forward, $result)) {
                                // add forward relation
                                $result[] = $forward;
                            }
                            if (!in_array($reverse, $result)) {
                                // add reverse relation
                                $result[] = $reverse;
                            }
                        }
                    }
                }
            }
        }

        $maxRel = $isKnown ? PHP_INT_MAX : 2 * $numRel;
        $msg = 'Key '.$keyName. ' on class '.$className . ' should have no more than '
               .$maxRel.' lines, has '.count($result);
        assert($maxRel >= count($result), $msg);
        return $result;
    }

    public function getRelationsByClass($className)
    {
        $this->checkClassExists($className);

        $rels = $this->relations[$className];
        $keys = array_keys($rels);
        $results = [];
        foreach ($keys as $key) {
            $lines = $this->getRelationsByKey($className, $key);
            foreach ($lines as $line) {
                if (!in_array($line, $results)) {
                    $results[] = $line;
                }
            }
        }

        return $results;
    }

    public function getRelations()
    {
        $results = [];
        $registered = array_keys($this->relations);

        foreach ($registered as $className) {
            $lines = $this->getRelationsByClass($className);
            foreach ($lines as $line) {
                if (!in_array($line, $results)) {
                    $results[] = $line;
                }
            }
        }
        return $results;
    }

    public function hasClass($className)
    {
        return array_key_exists($className, $this->relations);
    }

    private function getMorphToRelations($principalType, $targDeets, $keyName)
    {
        $result = [];
        $deetKeys = array_keys($targDeets);
        $principalProperty = $deetKeys[0];
        $principalDeets = $targDeets[$principalProperty];
        $principalMult = $principalDeets['multiplicity'];

        foreach ($this->relations as $dependentType => $dependentDeets) {
            foreach ($dependentDeets as $targKey => $rawDeets) {
                foreach ($rawDeets as $targType => $interDeets) {
                    if ($targType != $principalType) {
                        continue;
                    }
                    foreach ($interDeets as $dependentProperty => $finalDeets) {
                        if ($keyName !== $finalDeets['local']) {
                            continue;
                        }
                        $dependentMult = $finalDeets['multiplicity'];
                        list($forward, $reverse) = $this->calculateRoundTripRelationsGenForwardReverse(
                            $principalType,
                            $principalMult,
                            $principalProperty,
                            $dependentType,
                            $dependentMult,
                            $dependentProperty
                        );
                        if (!in_array($forward, $result)) {
                            // add forward relation
                            $result[] = $forward;
                        }
                        if (!in_array($reverse, $result)) {
                            // add reverse relation
                            $result[] = $reverse;
                        }
                    }
                }
            }
        }
        return $result;
    }

    /**
     * @param $principalType
     * @param $principalMult
     * @param $principalProperty
     * @param $dependentType
     * @param $dependentMult
     * @param $dependentProperty
     * @return array[]
     */
    private function calculateRoundTripRelationsGenForwardReverse(
        $principalType,
        $principalMult,
        $principalProperty,
        $dependentType,
        $dependentMult,
        $dependentProperty
    ) {
        assert(
            in_array($dependentMult, $this->multConstraints[$principalMult]),
            'Cannot pair multiplicities ' . $dependentMult . ' and ' . $principalMult
        );
        assert(
            in_array($principalMult, $this->multConstraints[$dependentMult]),
            'Cannot pair multiplicities ' . $principalMult . ' and ' . $dependentMult
        );
        $forward = [
            'principalType' => $principalType,
            'principalMult' => $dependentMult,
            'principalProp' => $principalProperty,
            'dependentType' => $dependentType,
            'dependentMult' => $principalMult,
            'dependentProp' => $dependentProperty,
            'principalRSet' => $principalType,
            'dependentRSet' => $dependentType
        ];
        $reverse = [
            'principalType' => $dependentType,
            'principalMult' => $principalMult,
            'principalProp' => $dependentProperty,
            'dependentType' => $principalType,
            'dependentMult' => $dependentMult,
            'dependentProp' => $principalProperty,
            'principalRSet' => $dependentType,
            'dependentRSet' => $principalType
        ];
        return [$forward, $reverse];
    }

    /**
     * @param $className
     */
    protected function checkClassExists($className)
    {
        if (!array_key_exists($className, $this->relations)) {
            $msg = $className . ' does not exist in holder';
            throw new \InvalidArgumentException($msg);
        }
    }
}


1		<?php
2
3		namespace AlgoWeb\PODataLaravel\Models;
4
5		use Illuminate\Database\Eloquent\Model;
6
7		class MetadataRelationHolder
8		{
9		protected $multConstraints = [ '0..1' => ['1'], '1' => ['0..1', ''], '' => ['1', '*']];
10		protected $relations = [];
11
12		public function __construct()
13		{
14		}
15
16		/**
17		* Add model's relationships to holder
18		*
19		* @param Model $model
20		*/
21		public function addModel(Model $model)
22		{
23		if (!in_array('AlgoWeb\\PODataLaravel\\Models\\MetadataTrait', class_uses($model))) {
24		$msg = 'Supplied model does not use MetadataTrait';
25		throw new \InvalidArgumentException($msg);
26		}
27		$className = get_class($model);
28		if (array_key_exists($className, $this->relations)) {
29		$msg = $className.' already added';
30		throw new \InvalidArgumentException($msg);
31		}
32		$this->relations[$className] = $model->getRelationships();
33		}
34
35		public function getRelationsByKey($className, $keyName)
36		{
37		$this->checkClassExists($className);
38
39		$rels = $this->relations[$className];
40		if (!array_key_exists($keyName, $rels)) {
41		$msg = 'Key ' . $keyName . ' not registered on ' . $className;
42		throw new \InvalidArgumentException($msg);
43		}
44
45		$result = [];
46		$payload = $rels[$keyName];
47		$principalType = $className;
48		$numRel = 0;
49		$isKnown = false;
50
51		foreach ($payload as $dependentType => $targDeets) {
52		if (!array_key_exists($dependentType, $this->relations)) {
53		continue;
54		}
55		// if principal and ostensible dependent type are equal, drop through to specific handler
56		// at moment, this is only for morphTo relations - morphedByMany doesn't cause this
57		if ($principalType === $dependentType) {
58		$morphToLines = $this->getMorphToRelations($principalType, $targDeets, $keyName);
59		foreach ($morphToLines as $morph) {
60		if (!in_array($morph, $result)) {
61		$result[] = $morph;
62		}
63		}
64		$isKnown = true;
65		continue;
66		}
67
68		$foreign = $this->relations[$dependentType];
69
70		foreach ($targDeets as $principalProperty => $rawDeets) {
71		$targKey = $rawDeets['local'];
72		$principalMult = $rawDeets['multiplicity'];
73		$principalProperty = $rawDeets['property'];
74		if (!array_key_exists($targKey, $foreign)) {
75		continue;
76		}
77		$numRel++;
78
79		$foreignDeets = $foreign[$targKey];
80		foreach ($foreignDeets as $foreignType => $raw) {
81		if (!array_key_exists($foreignType, $this->relations)) {
82		continue;
83		}
84		foreach ($raw as $dependentProperty => $dependentPayload) {
85		if ($principalType !== $foreignType) {
86		if (null === $dependentPayload['type']) {
87		continue;
88		}
89		}
90		if ($keyName == $dependentPayload['local']) {
91		$dependentMult = $dependentPayload['multiplicity'];
92		// generate forward and reverse relations
93		list($forward, $reverse) = $this->calculateRoundTripRelationsGenForwardReverse(
94		$principalType,
95		$principalMult,
96		$principalProperty,
97		$dependentType,
98		$dependentMult,
99		$dependentProperty
100		);
101		if (!in_array($forward, $result)) {
102		// add forward relation
103		$result[] = $forward;
104		}
105		if (!in_array($reverse, $result)) {
106		// add reverse relation
107		$result[] = $reverse;
108		}
109		}
110		}
111		}
112		}
113		}
114
115		$maxRel = $isKnown ? PHP_INT_MAX : 2 * $numRel;
116		$msg = 'Key '.$keyName. ' on class '.$className . ' should have no more than '
117		.$maxRel.' lines, has '.count($result);
118		assert($maxRel >= count($result), $msg);
119		return $result;
120		}
121
122		public function getRelationsByClass($className)
123		{
124		$this->checkClassExists($className);
125
126		$rels = $this->relations[$className];
127		$keys = array_keys($rels);
128		$results = [];
129	View Code Duplication	foreach ($keys as $key) {
130		$lines = $this->getRelationsByKey($className, $key);
131		foreach ($lines as $line) {
132		if (!in_array($line, $results)) {
133		$results[] = $line;
134		}
135		}
136		}
137
138		return $results;
139		}
140
141		public function getRelations()
142		{
143		$results = [];
144		$registered = array_keys($this->relations);
145
146	View Code Duplication	foreach ($registered as $className) {
147		$lines = $this->getRelationsByClass($className);
148		foreach ($lines as $line) {
149		if (!in_array($line, $results)) {
150		$results[] = $line;
151		}
152		}
153		}
154		return $results;
155		}
156
157		public function hasClass($className)
158		{
159		return array_key_exists($className, $this->relations);
160		}
161
162		private function getMorphToRelations($principalType, $targDeets, $keyName)
163		{
164		$result = [];
165		$deetKeys = array_keys($targDeets);
166		$principalProperty = $deetKeys[0];
167		$principalDeets = $targDeets[$principalProperty];
168		$principalMult = $principalDeets['multiplicity'];
169
170		foreach ($this->relations as $dependentType => $dependentDeets) {
171		foreach ($dependentDeets as $targKey => $rawDeets) {
172		foreach ($rawDeets as $targType => $interDeets) {
173		if ($targType != $principalType) {
174		continue;
175		}
176		foreach ($interDeets as $dependentProperty => $finalDeets) {
177		if ($keyName !== $finalDeets['local']) {
178		continue;
179		}
180		$dependentMult = $finalDeets['multiplicity'];
181		list($forward, $reverse) = $this->calculateRoundTripRelationsGenForwardReverse(
182		$principalType,
183		$principalMult,
184		$principalProperty,
185		$dependentType,
186		$dependentMult,
187		$dependentProperty
188		);
189		if (!in_array($forward, $result)) {
190		// add forward relation
191		$result[] = $forward;
192		}
193		if (!in_array($reverse, $result)) {
194		// add reverse relation
195		$result[] = $reverse;
196		}
197		}
198		}
199		}
200		}
201		return $result;
202		}
203
204		/**
205		* @param $principalType
206		* @param $principalMult
207		* @param $principalProperty
208		* @param $dependentType
209		* @param $dependentMult
210		* @param $dependentProperty
211		* @return array[]
212		*/
213		private function calculateRoundTripRelationsGenForwardReverse(
214		$principalType,
215		$principalMult,
216		$principalProperty,
217		$dependentType,
218		$dependentMult,
219		$dependentProperty
220		) {
221		assert(
222		in_array($dependentMult, $this->multConstraints[$principalMult]),
223		'Cannot pair multiplicities ' . $dependentMult . ' and ' . $principalMult
224		);
225		assert(
226		in_array($principalMult, $this->multConstraints[$dependentMult]),
227		'Cannot pair multiplicities ' . $principalMult . ' and ' . $dependentMult
228		);
229		$forward = [
230		'principalType' => $principalType,
231		'principalMult' => $dependentMult,
232		'principalProp' => $principalProperty,
233		'dependentType' => $dependentType,
234		'dependentMult' => $principalMult,
235		'dependentProp' => $dependentProperty,
236		'principalRSet' => $principalType,
237		'dependentRSet' => $dependentType
238		];
239		$reverse = [
240		'principalType' => $dependentType,
241		'principalMult' => $principalMult,
242		'principalProp' => $dependentProperty,
243		'dependentType' => $principalType,
244		'dependentMult' => $dependentMult,
245		'dependentProp' => $principalProperty,
246		'principalRSet' => $dependentType,
247		'dependentRSet' => $principalType
248		];
249		return [$forward, $reverse];
250		}
251
252		/**
253		* @param $className
254		*/
255		protected function checkClassExists($className)
256		{
257		if (!array_key_exists($className, $this->relations)) {
258		$msg = $className . ' does not exist in holder';
259		throw new \InvalidArgumentException($msg);
260		}
261		}
262		}
263

Algo-Web / POData-Laravel

Pull Request — master (#107)

MetadataRelationHolder::getRelationsByKey() D

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like