Row::__isset() - Code Metrics - Inspection of "New method ->reload()" - oscarotero/simple-crud - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( fe423d...ab6445 )

by Oscar

created 2019-08-23 17:45 UTC

Row::__isset() A

↳ Parent: Row

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	6
rs	10
c	0
b	0
f	0
cc	3
nc	3
nop	1

<?php
declare(strict_types = 1);

namespace SimpleCrud;

use BadMethodCallException;
use JsonSerializable;
use RuntimeException;
use SimpleCrud\Events\BeforeSaveRow;
use SimpleCrud\Queries\Select;

/**
 * Stores the data of an table row.
 */
class Row implements JsonSerializable
{
    private $table;
    private $values = [];
    private $changes = [];
    private $data = [];

    public function __construct(Table $table, array $values)
    {
        $this->table = $table;

        if (empty($values['id'])) {
            $this->values = $table->getDefaults();
            $this->changes = $table->getDefaults($values);
            unset($this->changes['id']);
        } else {
            $this->values = $table->getDefaults($values);
        }
    }

    public function __debugInfo(): array
    {
        return [
            'table' => (string) $this->table,
            'values' => $this->values,
            'changes' => $this->changes,
            'data' => $this->data,
        ];
    }

    public function __call(string $name, array $arguments): Select
    {
        $db = $this->table->getDatabase();

        //Relations
        if (isset($db->$name)) {
            return $this->select($db->$name);
        }

        throw new BadMethodCallException(
            sprintf('Invalid method call %s', $name)
        );
    }

    public function setData(array $data): self
    {
        $this->data = $data + $this->data;

        return $this;
    }

    /**
     * @param Row|RowCollection|null $row
     */
    public function link(Table $table, $row = null): self
    {
        return $this->setData([$table->getName() => $row]);
    }

    /**
     * @see JsonSerializable
     */
    public function jsonSerialize()
    {
        return $this->toArray();
    }

    /**
     * Magic method to stringify the values.
     */
    public function __toString()
    {
        return json_encode($this, JSON_NUMERIC_CHECK);
    }

    /**
     * Returns the table associated with this row
     */
    public function getTable(): Table
    {
        return $this->table;
    }

    /**
     * Returns the value of:
     * - a value field
     * - a related table
     */
    public function &__get(string $name)
    {
        if ($name === 'id') {
            return $this->values['id'];
        }

        //It's a value
        if ($valueName = $this->getValueName($name)) {
            $value = $this->getValue($valueName);
            return $value;
        }

        //It's custom data
        if (array_key_exists($name, $this->data)) {
            return $this->data[$name];
        }

        $db = $this->table->getDatabase();

        if (isset($db->$name)) {
            $this->setData([
                $name => $this->select($db->$name)->run(),
            ]);

            return $this->data[$name];
        }

        throw new RuntimeException(
            sprintf('Undefined property "%s" in the table %s', $name, $this->table)
        );
    }

    /**
     * Change the value of
     * - a field
     * - a localized field
     * @param mixed $value
     */
    public function __set(string $name, $value)
    {
        if ($name === 'id') {
            if (!is_null($this->values['id']) && !is_null($value)) {
                throw new RuntimeException('The field "id" cannot be overrided');
            }

            $this->values['id'] = $value;

            return $value;
        }

        //It's a value
        if ($valueName = $this->getValueName($name)) {
            if ($this->values[$valueName] === $value) {
                unset($this->changes[$valueName]);
            } else {
                $this->changes[$valueName] = $value;
            }

            return $value;
        }

        throw new RuntimeException(
            sprintf('The field %s does not exists', $name)
        );
    }

    /**
     * Check whether a value is set or not
     */
    public function __isset(string $name): bool
    {
        $valueName = $this->getValueName($name);

        return (isset($valueName) && !is_null($this->getValue($valueName))) || isset($this->data[$name]);
    }

    /**
     * Removes the value of a field
     */
    public function __unset(string $name)
    {
        unset($this->data[$name]);

        $this->__set($name, null);
    }

    /**
     * Reload the data from the database
     */
    public function reload($keepChanges = false): self
    {
        $select = $this->table->select()->where('id = ', $this->id);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        $values = $select()->fetch(\PDO::FETCH_ASSOC);
        $this->values = $this->table->format($values);

        if (!$keepChanges) {
            $this->changes = [];
        }

        return $this;
    }

    /**
     * Returns an array with all fields of the row
     */
    public function toArray(): array
    {
        return $this->changes + $this->values;
    }

    /**
     * Edit the values using an array
     */
    public function edit(array $values): self
    {
        foreach ($values as $name => $value) {
            $this->__set($name, $value);
        }

        return $this;
    }

    /**
     * Insert/update the row in the database
     */
    public function save(): self
    {
        if (!empty($this->changes)) {
            $eventDispatcher = $this->table->getEventDispatcher();

            if ($eventDispatcher) {
                $eventDispatcher->dispatch(new BeforeSaveRow($this));
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

            if (empty($this->id)) {
                $this->id = $this->table->insert($this->changes)->run();
            } else {
                $this->table->update($this->changes)
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                    ->where('id = ', $this->id)
                    ->run();
            }

            $this->values = $this->toArray();
            $this->changes = [];
            $this->table->cache($this);
        }

        return $this;
    }

    /**
     * Delete the row in the database
     */
    public function delete(): self
    {
        $id = $this->id;

        if (!empty($id)) {
            $this->table->delete()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                ->where('id = ', $id)
                ->run();

            $this->values['id'] = null;
        }

        return $this;
    }

    /**
     * Relate this row with other rows
     */
    public function relate(Row ...$rows): self
    {
        $table1 = $this->table;

        foreach ($rows as $row) {
            $table2 = $row->getTable();

            //Has one
            if ($field = $table1->getJoinField($table2)) {
                $this->{$field->getName()} = $row->id;
                continue;
            }

            //Has many
            if ($field = $table2->getJoinField($table1)) {
                $row->{$field->getName()} = $this->id;
                $row->save();
                continue;
            }

            //Has many to many
            if ($joinTable = $table1->getJoinTable($table2)) {
                $joinTable->insert([
                    $joinTable->getJoinField($table1)->getName() => $this->id,
                    $joinTable->getJoinField($table2)->getName() => $row->id,
                ])
                ->run();

                continue;
            }

            throw new RuntimeException(
                sprintf('The tables %s and %s are not related', $table1, $table2)
            );
        }

        return $this->save();
    }

    /**
     * Unrelate this row with other rows
     */
    public function unrelate(Row ...$rows): self
    {
        $table1 = $this->table;

        foreach ($rows as $row) {
            $table2 = $row->getTable();

            //Has one
            if ($field = $table1->getJoinField($table2)) {
                $this->{$field->getName()} = null;
                continue;
            }

            //Has many
            if ($field = $table2->getJoinField($table1)) {
                $row->{$field->getName()} = null;
                $row->save();
                continue;
            }

            //Has many to many
            if ($joinTable = $table1->getJoinTable($table2)) {
                $joinTable->delete()
                    ->where("{$joinTable->getJoinField($table1)} = ", $this->id)
                    ->where("{$joinTable->getJoinField($table2)} = ", $row->id)
                    ->run();

                continue;
            }

            throw new RuntimeException(
                sprintf('The tables %s and %s are not related', $table1, $table2)
            );
        }

        return $this->save();
    }

    /**
     * Unrelate this row with all rows of other tables
     */
    public function unrelateAll(Table ...$tables): self
    {
        $table1 = $this->table;

        foreach ($tables as $table2) {
            //Has one
            if ($field = $table1->getJoinField($table2)) {
                $this->{$field->getName()} = null;
                continue;
            }

            //Has many
            if ($field = $table2->getJoinField($table1)) {
                $table2->update([
                    $field->getName() => null,
                ])
                ->relatedWith($table1)
                ->run();
                continue;
            }

            //Has many to many
            if ($joinTable = $table1->getJoinTable($table2)) {
                $joinTable->delete()
                    ->where("{$joinTable->getJoinField($table1)} = ", $this->id)
                    ->where("{$joinTable->getJoinField($table2)} IS NOT NULL")
                    ->run();

                continue;
            }

            throw new RuntimeException(
                sprintf('The tables %s and %s are not related', $table1, $table2)
            );
        }

        return $this->save();
    }

    /**
     * Creates a select query of a table related with this row
     */
    public function select(Table $table): Select
    {
        //Has one
        if ($this->table->getJoinField($table)) {
            return $table->select()->one()->relatedWith($this);
        }

        return $table->select()->relatedWith($this);
    }

    /**
     * Return the real field name
     */
    private function getValueName(string $name): ?string
    {
        if (array_key_exists($name, $this->values)) {
            return $name;
        }

        //It's a localizable field
        $language = $this->table->getDatabase()->getConfig(Database::CONFIG_LOCALE);

        if (!is_null($language)) {
            $name .= "_{$language}";

            if (array_key_exists($name, $this->values)) {
                return $name;
            }
        }

        return null;
    }

    private function getValue(string $name)
    {
        return array_key_exists($name, $this->changes) ? $this->changes[$name] : $this->values[$name];
    }
}


1			<?php
2			declare(strict_types = 1);
3
4			namespace SimpleCrud;
5
6			use BadMethodCallException;
7			use JsonSerializable;
8			use RuntimeException;
9			use SimpleCrud\Events\BeforeSaveRow;
10			use SimpleCrud\Queries\Select;
11
12			/**
13			* Stores the data of an table row.
14			*/
15			class Row implements JsonSerializable
16			{
17			private $table;
18			private $values = [];
19			private $changes = [];
20			private $data = [];
21
22			public function __construct(Table $table, array $values)
23			{
24			$this->table = $table;
25
26			if (empty($values['id'])) {
27			$this->values = $table->getDefaults();
28			$this->changes = $table->getDefaults($values);
29			unset($this->changes['id']);
30			} else {
31			$this->values = $table->getDefaults($values);
32			}
33			}
34
35			public function __debugInfo(): array
36			{
37			return [
38			'table' => (string) $this->table,
39			'values' => $this->values,
40			'changes' => $this->changes,
41			'data' => $this->data,
42			];
43			}
44
45			public function __call(string $name, array $arguments): Select
46			{
47			$db = $this->table->getDatabase();
48
49			//Relations
50			if (isset($db->$name)) {
51			return $this->select($db->$name);
52			}
53
54			throw new BadMethodCallException(
55			sprintf('Invalid method call %s', $name)
56			);
57			}
58
59			public function setData(array $data): self
60			{
61			$this->data = $data + $this->data;
62
63			return $this;
64			}
65
66			/**
67			* @param Row\|RowCollection\|null $row
68			*/
69			public function link(Table $table, $row = null): self
70			{
71			return $this->setData([$table->getName() => $row]);
72			}
73
74			/**
75			* @see JsonSerializable
76			*/
77			public function jsonSerialize()
78			{
79			return $this->toArray();
80			}
81
82			/**
83			* Magic method to stringify the values.
84			*/
85			public function __toString()
86			{
87			return json_encode($this, JSON_NUMERIC_CHECK);
88			}
89
90			/**
91			* Returns the table associated with this row
92			*/
93			public function getTable(): Table
94			{
95			return $this->table;
96			}
97
98			/**
99			* Returns the value of:
100			* - a value field
101			* - a related table
102			*/
103			public function &__get(string $name)
104			{
105			if ($name === 'id') {
106			return $this->values['id'];
107			}
108
109			//It's a value
110			if ($valueName = $this->getValueName($name)) {
111			$value = $this->getValue($valueName);
112			return $value;
113			}
114
115			//It's custom data
116			if (array_key_exists($name, $this->data)) {
117			return $this->data[$name];
118			}
119
120			$db = $this->table->getDatabase();
121
122			if (isset($db->$name)) {
123			$this->setData([
124			$name => $this->select($db->$name)->run(),
125			]);
126
127			return $this->data[$name];
128			}
129
130			throw new RuntimeException(
131			sprintf('Undefined property "%s" in the table %s', $name, $this->table)
132			);
133			}
134
135			/**
136			* Change the value of
137			* - a field
138			* - a localized field
139			* @param mixed $value
140			*/
141			public function __set(string $name, $value)
142			{
143			if ($name === 'id') {
144			if (!is_null($this->values['id']) && !is_null($value)) {
145			throw new RuntimeException('The field "id" cannot be overrided');
146			}
147
148			$this->values['id'] = $value;
149
150			return $value;
151			}
152
153			//It's a value
154			if ($valueName = $this->getValueName($name)) {
155			if ($this->values[$valueName] === $value) {
156			unset($this->changes[$valueName]);
157			} else {
158			$this->changes[$valueName] = $value;
159			}
160
161			return $value;
162			}
163
164			throw new RuntimeException(
165			sprintf('The field %s does not exists', $name)
166			);
167			}
168
169			/**
170			* Check whether a value is set or not
171			*/
172			public function __isset(string $name): bool
173			{
174			$valueName = $this->getValueName($name);
175
176			return (isset($valueName) && !is_null($this->getValue($valueName))) \|\| isset($this->data[$name]);
177			}
178
179			/**
180			* Removes the value of a field
181			*/
182			public function __unset(string $name)
183			{
184			unset($this->data[$name]);
185
186			$this->__set($name, null);
187			}
188
189			/**
190			* Reload the data from the database
191			*/
192			public function reload($keepChanges = false): self
193			{
194			$select = $this->table->select()->where('id = ', $this->id);
			0 ignored issues – show Documentation Bug introduced 2019-08-23 17:46 UTC by Report Bug Copy Issue Report The method `where` does not exist on `object<SimpleCrud\Queries\Select>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
195			$values = $select()->fetch(\PDO::FETCH_ASSOC);
196			$this->values = $this->table->format($values);
197
198			if (!$keepChanges) {
199			$this->changes = [];
200			}
201
202			return $this;
203			}
204
205			/**
206			* Returns an array with all fields of the row
207			*/
208			public function toArray(): array
209			{
210			return $this->changes + $this->values;
211			}
212
213			/**
214			* Edit the values using an array
215			*/
216			public function edit(array $values): self
217			{
218			foreach ($values as $name => $value) {
219			$this->__set($name, $value);
220			}
221
222			return $this;
223			}
224
225			/**
226			* Insert/update the row in the database
227			*/
228			public function save(): self
229			{
230			if (!empty($this->changes)) {
231			$eventDispatcher = $this->table->getEventDispatcher();
232
233			if ($eventDispatcher) {
234			$eventDispatcher->dispatch(new BeforeSaveRow($this));
			0 ignored issues – show Documentation introduced 2019-03-30 00:32 UTC by Report Bug Copy Issue Report `new \SimpleCrud\Events\BeforeSaveRow($this)` is of type `object<SimpleCrud\Events\BeforeSaveRow>`, but the function expects a `object<Psr\EventDispatcher\object>`. 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...
235			}
236
237			if (empty($this->id)) {
238			$this->id = $this->table->insert($this->changes)->run();
239			} else {
240			$this->table->update($this->changes)
			0 ignored issues – show Documentation Bug introduced 2019-04-02 23:16 UTC by Report Bug Copy Issue Report The method `where` does not exist on `object<SimpleCrud\Queries\Update>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
241			->where('id = ', $this->id)
242			->run();
243			}
244
245			$this->values = $this->toArray();
246			$this->changes = [];
247			$this->table->cache($this);
248			}
249
250			return $this;
251			}
252
253			/**
254			* Delete the row in the database
255			*/
256			public function delete(): self
257			{
258			$id = $this->id;
259
260			if (!empty($id)) {
261			$this->table->delete()
			0 ignored issues – show Documentation Bug introduced 2019-04-02 23:16 UTC by Report Bug Copy Issue Report The method `where` does not exist on `object<SimpleCrud\Queries\Delete>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
262			->where('id = ', $id)
263			->run();
264
265			$this->values['id'] = null;
266			}
267
268			return $this;
269			}
270
271			/**
272			* Relate this row with other rows
273			*/
274			public function relate(Row ...$rows): self
275			{
276			$table1 = $this->table;
277
278			foreach ($rows as $row) {
279			$table2 = $row->getTable();
280
281			//Has one
282			if ($field = $table1->getJoinField($table2)) {
283			$this->{$field->getName()} = $row->id;
284			continue;
285			}
286
287			//Has many
288			if ($field = $table2->getJoinField($table1)) {
289			$row->{$field->getName()} = $this->id;
290			$row->save();
291			continue;
292			}
293
294			//Has many to many
295			if ($joinTable = $table1->getJoinTable($table2)) {
296			$joinTable->insert([
297			$joinTable->getJoinField($table1)->getName() => $this->id,
298			$joinTable->getJoinField($table2)->getName() => $row->id,
299			])
300			->run();
301
302			continue;
303			}
304
305			throw new RuntimeException(
306			sprintf('The tables %s and %s are not related', $table1, $table2)
307			);
308			}
309
310			return $this->save();
311			}
312
313			/**
314			* Unrelate this row with other rows
315			*/
316			public function unrelate(Row ...$rows): self
317			{
318			$table1 = $this->table;
319
320			foreach ($rows as $row) {
321			$table2 = $row->getTable();
322
323			//Has one
324			if ($field = $table1->getJoinField($table2)) {
325			$this->{$field->getName()} = null;
326			continue;
327			}
328
329			//Has many
330			if ($field = $table2->getJoinField($table1)) {
331			$row->{$field->getName()} = null;
332			$row->save();
333			continue;
334			}
335
336			//Has many to many
337			if ($joinTable = $table1->getJoinTable($table2)) {
338			$joinTable->delete()
339			->where("{$joinTable->getJoinField($table1)} = ", $this->id)
340			->where("{$joinTable->getJoinField($table2)} = ", $row->id)
341			->run();
342
343			continue;
344			}
345
346			throw new RuntimeException(
347			sprintf('The tables %s and %s are not related', $table1, $table2)
348			);
349			}
350
351			return $this->save();
352			}
353
354			/**
355			* Unrelate this row with all rows of other tables
356			*/
357			public function unrelateAll(Table ...$tables): self
358			{
359			$table1 = $this->table;
360
361			foreach ($tables as $table2) {
362			//Has one
363			if ($field = $table1->getJoinField($table2)) {
364			$this->{$field->getName()} = null;
365			continue;
366			}
367
368			//Has many
369			if ($field = $table2->getJoinField($table1)) {
370			$table2->update([
371			$field->getName() => null,
372			])
373			->relatedWith($table1)
374			->run();
375			continue;
376			}
377
378			//Has many to many
379			if ($joinTable = $table1->getJoinTable($table2)) {
380			$joinTable->delete()
381			->where("{$joinTable->getJoinField($table1)} = ", $this->id)
382			->where("{$joinTable->getJoinField($table2)} IS NOT NULL")
383			->run();
384
385			continue;
386			}
387
388			throw new RuntimeException(
389			sprintf('The tables %s and %s are not related', $table1, $table2)
390			);
391			}
392
393			return $this->save();
394			}
395
396			/**
397			* Creates a select query of a table related with this row
398			*/
399			public function select(Table $table): Select
400			{
401			//Has one
402			if ($this->table->getJoinField($table)) {
403			return $table->select()->one()->relatedWith($this);
404			}
405
406			return $table->select()->relatedWith($this);
407			}
408
409			/**
410			* Return the real field name
411			*/
412			private function getValueName(string $name): ?string
413			{
414			if (array_key_exists($name, $this->values)) {
415			return $name;
416			}
417
418			//It's a localizable field
419			$language = $this->table->getDatabase()->getConfig(Database::CONFIG_LOCALE);
420
421			if (!is_null($language)) {
422			$name .= "_{$language}";
423
424			if (array_key_exists($name, $this->values)) {
425			return $name;
426			}
427			}
428
429			return null;
430			}
431
432			private function getValue(string $name)
433			{
434			return array_key_exists($name, $this->changes) ? $this->changes[$name] : $this->values[$name];
435			}
436			}
437

oscarotero / simple-crud

Push — master ( fe423d...ab6445 )

Row::__isset() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like