Entity::getRelatedModel() - Code Metrics - Inspection of "More improvements" - alkemann/h2l - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — scrutinizer_improvements (f68ca2)

by Alexander

created 2017-08-07 11:27 UTC

Entity::getRelatedModel() A

↳ Parent: Entity

Complexity

Conditions	3
Paths	2

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	5
nc	2
nop	2
dl	0
loc	8
rs	9.4285
c	0
b	0
f	0

<?php

namespace alkemann\h2l;

/**
 * Class Entity
 *
 * @package alkemann\h2l
 */
trait Entity
{

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

    protected $relationships = [];

    /**
     * Entity constructor.
     *
     * @param array $data
     */
    public function __construct(array $data = [])
    {
        $this->data = $data;
    }

    /**
     * @param $name
     * @return mixed
     */
    public function __get(string $name)
    {
        return array_key_exists($name, $this->data) ? $this->data[$name] : null;
    }

    public function __call(string $method, array $args = [])
    {
        $refresh = (bool) array_shift($args);
        return $this->getRelatedModel($method, $refresh);
    }

    private function getRelatedModel(string $name, bool $refresh = false)
    {
        $this->checkIfRelationIsSet($name);
        if ($refresh === false && array_key_exists($name, $this->relationships)) {
            return $this->relationships[$name];
        }
        return $this->populateRelation($name);
    }

    private function checkIfRelationIsSet(string $name): void
    {
        if (isset(static::$relations) === false ||
            array_key_exists($name, static::$relations) === false) {
            $class = get_class($this);
            throw new \Error("Call to undefined method {$class}::{$name}()");
        }
    }

    /**
     * @param string[] ...$relation_names any list of relations to return
     * @return Entity self

     */
    public function with(string ...$relation_names)
    {
        foreach ($relation_names as $name) {
            $this->populateRelation($name);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }
        return $this;
    }

    /**
     * @param string $relation_name
     * @param array|object|null $data
     * @return array|object|null array in case of has_many
     * @throws \Exception
     */
    public function populateRelation(string $relation_name, $data = null)
    {
        if ($data !== null) {
            $this->relationships[$relation_name] = $data;
            return;
        }
        $relationship = $this->describeRelationship($relation_name);
        $relation_class = $relationship['class'];
        $relation_id = $this->{$relationship['local']};
        if ($relationship['type'] === 'belongs_to') {
            $related = $relation_class::get($relation_id);
        } elseif ($relationship['type'] === 'has_one') {
            $related_by = $relationship['foreign'];
            $result = $relation_class::findAsArray([$related_by => $relation_id], ['limit' => 1]);
            $related = $result ? current($result) : null;
        } elseif ($relationship['type'] === 'has_many') { // type must be has_many
            $related_by = $relationship['foreign'];
            $related = $relation_class::findAsArray([$related_by => $relation_id]);
        } else {
            throw new \Exception("Not a valid relationship type [" . $relationship['type'] . ']');
        }
        $this->relationships[$relation_name] = $related;
        return $related;
    }

    /**
     * @param string $name
     * @return array
     * @throws \Error if $name is for an unspecified relation
     */
    public function describeRelationship(string $name): array
    {
        $this->checkIfRelationIsSet($name);
        $settings = static::$relations[$name];
        if (sizeof($settings) === 1) {
            return $this->generateRelationshipFromShorthand($settings);
        }
        if (!array_key_exists('local', $settings)) {
            $settings['local'] = 'id';
        }
        if (!array_key_exists('foreign', $settings)) {
            $settings['foreign'] = 'id';
        }
        if (!array_key_exists('type', $settings)) {
            $settings['type'] = $settings['local'] === 'id' ? 'has_many' : 'belongs_to';
        }

        return $settings;
    }

    private function generateRelationshipFromShorthand(array $settings): array
    {
        $field = current($settings);
        $field_is_local = in_array($field, static::$fields); // @TODO hack to use Model data?
        if ($field_is_local) {
            return [
                'class' => key($settings),
                'type' => 'belongs_to',
                'local' => $field,
                'foreign' => 'id'
            ];
        } else {
            return [
                'class' => key($settings),
                'type' => 'has_many',
                'local' => 'id',
                'foreign' => $field
            ];
        }
    }

    /**
     * @param string $name
     * @param mixed $value
     */
    public function __set(string $name, $value): void
    {
        $this->data[$name] = $value;
    }

    /**
     * @param $name
     * @return bool
     */
    public function __isset(string $name): bool
    {
        return isset($this->data[$name]);
    }

    /**
     * @param array|null $data
     * @return array
     */
    public function data(array $data = null): array
    {
        if (is_null($data)) {
            return $this->data;
        }
        foreach ($data as $key => $value) {
            $this->data[$key] = $value;
        }
        return $this->data;
    }

    /**
     * Reset object by removing all data
     */
    public function reset(): void
    {
        $this->data = [];
    }

    /**
     * Cast the data array to $type and return this
     *
     * @param $type 'json', 'array'
     * @return mixed
     * @throws \InvalidArgumentException on unsupported type
     */
    public function to(string $type)
    {
        switch ($type) {
            case 'array':
                return $this->data;
            case 'json':
                return json_encode($this->data);
            default:
                throw new \InvalidArgumentException("Unkown type $type");
        }
    }

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


1			<?php
2
3			namespace alkemann\h2l;
4
5			/**
6			* Class Entity
7			*
8			* @package alkemann\h2l
9			*/
10			trait Entity
11			{
12
13			/**
14			* @var array
15			*/
16			protected $data = [];
17
18			protected $relationships = [];
19
20			/**
21			* Entity constructor.
22			*
23			* @param array $data
24			*/
25			public function __construct(array $data = [])
26			{
27			$this->data = $data;
28			}
29
30			/**
31			* @param $name
32			* @return mixed
33			*/
34			public function __get(string $name)
35			{
36			return array_key_exists($name, $this->data) ? $this->data[$name] : null;
37			}
38
39			public function __call(string $method, array $args = [])
40			{
41			$refresh = (bool) array_shift($args);
42			return $this->getRelatedModel($method, $refresh);
43			}
44
45			private function getRelatedModel(string $name, bool $refresh = false)
46			{
47			$this->checkIfRelationIsSet($name);
48			if ($refresh === false && array_key_exists($name, $this->relationships)) {
49			return $this->relationships[$name];
50			}
51			return $this->populateRelation($name);
52			}
53
54			private function checkIfRelationIsSet(string $name): void
55			{
56			if (isset(static::$relations) === false \|\|
57			array_key_exists($name, static::$relations) === false) {
58			$class = get_class($this);
59			throw new \Error("Call to undefined method {$class}::{$name}()");
60			}
61			}
62
63			/**
64			* @param string[] ...$relation_names any list of relations to return
65			* @return Entity self
			0 ignored issues – show Comprehensibility Bug introduced 2017-08-07 11:29 UTC by Report Bug Copy Issue Report The return type `Entity` is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting? In PHP traits cannot be used for type-hinting as they do not define a well-defined structure. This is because any class that uses a trait can rename that trait’s methods. If you would like to return an object that has a guaranteed set of methods, you could create a companion interface that lists these methods explicitly. Loading history...
66			*/
67			public function with(string ...$relation_names)
68			{
69			foreach ($relation_names as $name) {
70			$this->populateRelation($name);
			1 ignored issue – show Documentation introduced 2017-08-06 12:48 UTC by Report Bug Copy Issue Report `$name` is of type `array<integer,string>`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
71			}
72			return $this;
73			}
74
75			/**
76			* @param string $relation_name
77			* @param array\|object\|null $data
78			* @return array\|object\|null array in case of has_many
79			* @throws \Exception
80			*/
81			public function populateRelation(string $relation_name, $data = null)
82			{
83			if ($data !== null) {
84			$this->relationships[$relation_name] = $data;
85			return;
86			}
87			$relationship = $this->describeRelationship($relation_name);
88			$relation_class = $relationship['class'];
89			$relation_id = $this->{$relationship['local']};
90			if ($relationship['type'] === 'belongs_to') {
91			$related = $relation_class::get($relation_id);
92			} elseif ($relationship['type'] === 'has_one') {
93			$related_by = $relationship['foreign'];
94			$result = $relation_class::findAsArray([$related_by => $relation_id], ['limit' => 1]);
95			$related = $result ? current($result) : null;
96			} elseif ($relationship['type'] === 'has_many') { // type must be has_many
97			$related_by = $relationship['foreign'];
98			$related = $relation_class::findAsArray([$related_by => $relation_id]);
99			} else {
100			throw new \Exception("Not a valid relationship type [" . $relationship['type'] . ']');
101			}
102			$this->relationships[$relation_name] = $related;
103			return $related;
104			}
105
106			/**
107			* @param string $name
108			* @return array
109			* @throws \Error if $name is for an unspecified relation
110			*/
111			public function describeRelationship(string $name): array
112			{
113			$this->checkIfRelationIsSet($name);
114			$settings = static::$relations[$name];
115			if (sizeof($settings) === 1) {
116			return $this->generateRelationshipFromShorthand($settings);
117			}
118			if (!array_key_exists('local', $settings)) {
119			$settings['local'] = 'id';
120			}
121			if (!array_key_exists('foreign', $settings)) {
122			$settings['foreign'] = 'id';
123			}
124			if (!array_key_exists('type', $settings)) {
125			$settings['type'] = $settings['local'] === 'id' ? 'has_many' : 'belongs_to';
126			}
127
128			return $settings;
129			}
130
131			private function generateRelationshipFromShorthand(array $settings): array
132			{
133			$field = current($settings);
134			$field_is_local = in_array($field, static::$fields); // @TODO hack to use Model data?
135			if ($field_is_local) {
136			return [
137			'class' => key($settings),
138			'type' => 'belongs_to',
139			'local' => $field,
140			'foreign' => 'id'
141			];
142			} else {
143			return [
144			'class' => key($settings),
145			'type' => 'has_many',
146			'local' => 'id',
147			'foreign' => $field
148			];
149			}
150			}
151
152			/**
153			* @param string $name
154			* @param mixed $value
155			*/
156			public function __set(string $name, $value): void
157			{
158			$this->data[$name] = $value;
159			}
160
161			/**
162			* @param $name
163			* @return bool
164			*/
165			public function __isset(string $name): bool
166			{
167			return isset($this->data[$name]);
168			}
169
170			/**
171			* @param array\|null $data
172			* @return array
173			*/
174			public function data(array $data = null): array
175			{
176			if (is_null($data)) {
177			return $this->data;
178			}
179			foreach ($data as $key => $value) {
180			$this->data[$key] = $value;
181			}
182			return $this->data;
183			}
184
185			/**
186			* Reset object by removing all data
187			*/
188			public function reset(): void
189			{
190			$this->data = [];
191			}
192
193			/**
194			* Cast the data array to $type and return this
195			*
196			* @param $type 'json', 'array'
197			* @return mixed
198			* @throws \InvalidArgumentException on unsupported type
199			*/
200			public function to(string $type)
201			{
202			switch ($type) {
203			case 'array':
204			return $this->data;
205			case 'json':
206			return json_encode($this->data);
207			default:
208			throw new \InvalidArgumentException("Unkown type $type");
209			}
210			}
211
212			/**
213			* @return array
214			*/
215			public function jsonSerialize(): array
216			{
217			return $this->data;
218			}
219			}
220

alkemann / h2l

Branch — scrutinizer_improvements (f68ca2)

Entity::getRelatedModel() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like