Row::setData() - Code Metrics - Inspection of "fixed relate with non-saved rows" - oscarotero/simple-crud - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3de593...6b16d4 )

by Oscar

created 2019-11-07 19:50 UTC

Row::setData() A

↳ Parent: Row

Complexity

Conditions	1
Paths	1

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	1
nc	1
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(bool $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;
    }

    /**
     * Returns the id of the row.
     * If it does not exist (because it is not saved in the database yet),
     * execute a save() first
     */
    public function id(): int
    {
        if (empty($this->id)) {
            $this->save();
        }

        return $this->id;
    }

    /**
     * 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->toArray())->run();
            } elseif (empty($this->changes)) {
                return $this;
            } 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)) {
                if (empty($row->id)) {
                    $row->save();
                }
                if (empty($this->id)) {
                    $this->save();
                }
                $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(bool $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			* Returns the id of the row.
227			* If it does not exist (because it is not saved in the database yet),
228			* execute a save() first
229			*/
230			public function id(): int
231			{
232			if (empty($this->id)) {
233			$this->save();
234			}
235
236			return $this->id;
237			}
238
239			/**
240			* Insert/update the row in the database
241			*/
242			public function save(): self
243			{
244			if (!empty($this->changes)) {
245			$eventDispatcher = $this->table->getEventDispatcher();
246
247			if ($eventDispatcher) {
248			$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...
249			}
250
251			if (empty($this->id)) {
252			$this->id = $this->table->insert($this->toArray())->run();
253			} elseif (empty($this->changes)) {
254			return $this;
255			} else {
256			$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...
257			->where('id = ', $this->id)
258			->run();
259			}
260
261			$this->values = $this->toArray();
262			$this->changes = [];
263			$this->table->cache($this);
264			}
265
266			return $this;
267			}
268
269			/**
270			* Delete the row in the database
271			*/
272			public function delete(): self
273			{
274			$id = $this->id;
275
276			if (!empty($id)) {
277			$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...
278			->where('id = ', $id)
279			->run();
280
281			$this->values['id'] = null;
282			}
283
284			return $this;
285			}
286
287			/**
288			* Relate this row with other rows
289			*/
290			public function relate(Row ...$rows): self
291			{
292			$table1 = $this->table;
293
294			foreach ($rows as $row) {
295			$table2 = $row->getTable();
296
297			//Has one
298			if ($field = $table1->getJoinField($table2)) {
299			$this->{$field->getName()} = $row->id();
300			continue;
301			}
302
303			//Has many
304			if ($field = $table2->getJoinField($table1)) {
305			$row->{$field->getName()} = $this->id();
306			$row->save();
307			continue;
308			}
309
310			//Has many to many
311			if ($joinTable = $table1->getJoinTable($table2)) {
312			if (empty($row->id)) {
313			$row->save();
314			}
315			if (empty($this->id)) {
316			$this->save();
317			}
318			$joinTable->insert([
319			$joinTable->getJoinField($table1)->getName() => $this->id(),
320			$joinTable->getJoinField($table2)->getName() => $row->id(),
321			])
322			->run();
323
324			continue;
325			}
326
327			throw new RuntimeException(
328			sprintf('The tables %s and %s are not related', $table1, $table2)
329			);
330			}
331
332			return $this->save();
333			}
334
335			/**
336			* Unrelate this row with other rows
337			*/
338			public function unrelate(Row ...$rows): self
339			{
340			$table1 = $this->table;
341
342			foreach ($rows as $row) {
343			$table2 = $row->getTable();
344
345			//Has one
346			if ($field = $table1->getJoinField($table2)) {
347			$this->{$field->getName()} = null;
348			continue;
349			}
350
351			//Has many
352			if ($field = $table2->getJoinField($table1)) {
353			$row->{$field->getName()} = null;
354			$row->save();
355			continue;
356			}
357
358			//Has many to many
359			if ($joinTable = $table1->getJoinTable($table2)) {
360			$joinTable->delete()
361			->where("{$joinTable->getJoinField($table1)} = ", $this->id)
362			->where("{$joinTable->getJoinField($table2)} = ", $row->id)
363			->run();
364
365			continue;
366			}
367
368			throw new RuntimeException(
369			sprintf('The tables %s and %s are not related', $table1, $table2)
370			);
371			}
372
373			return $this->save();
374			}
375
376			/**
377			* Unrelate this row with all rows of other tables
378			*/
379			public function unrelateAll(Table ...$tables): self
380			{
381			$table1 = $this->table;
382
383			foreach ($tables as $table2) {
384			//Has one
385			if ($field = $table1->getJoinField($table2)) {
386			$this->{$field->getName()} = null;
387			continue;
388			}
389
390			//Has many
391			if ($field = $table2->getJoinField($table1)) {
392			$table2->update([
393			$field->getName() => null,
394			])
395			->relatedWith($table1)
396			->run();
397			continue;
398			}
399
400			//Has many to many
401			if ($joinTable = $table1->getJoinTable($table2)) {
402			$joinTable->delete()
403			->where("{$joinTable->getJoinField($table1)} = ", $this->id)
404			->where("{$joinTable->getJoinField($table2)} IS NOT NULL")
405			->run();
406
407			continue;
408			}
409
410			throw new RuntimeException(
411			sprintf('The tables %s and %s are not related', $table1, $table2)
412			);
413			}
414
415			return $this->save();
416			}
417
418			/**
419			* Creates a select query of a table related with this row
420			*/
421			public function select(Table $table): Select
422			{
423			//Has one
424			if ($this->table->getJoinField($table)) {
425			return $table->select()->one()->relatedWith($this);
426			}
427
428			return $table->select()->relatedWith($this);
429			}
430
431			/**
432			* Return the real field name
433			*/
434			private function getValueName(string $name): ?string
435			{
436			if (array_key_exists($name, $this->values)) {
437			return $name;
438			}
439
440			//It's a localizable field
441			$language = $this->table->getDatabase()->getConfig(Database::CONFIG_LOCALE);
442
443			if (!is_null($language)) {
444			$name .= "_{$language}";
445
446			if (array_key_exists($name, $this->values)) {
447			return $name;
448			}
449			}
450
451			return null;
452			}
453
454			private function getValue(string $name)
455			{
456			return array_key_exists($name, $this->changes) ? $this->changes[$name] : $this->values[$name];
457			}
458			}
459

oscarotero / simple-crud

Push — master ( 3de593...6b16d4 )

Row::setData() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like