Model::offsetUnset() - Code Metrics - valkyrjaio/valkyrja - Measure and Improve Code Quality continuously with Scrutinizer

Model::offsetUnset() A
last analyzed 2025-08-08 04:54 UTC

↳ Parent: Model

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	2
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1

<?php

declare(strict_types=1);

/*
 * This file is part of the Valkyrja Framework package.
 *
 * (c) Melech Mizrachi <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Valkyrja\Type\Model;

use Closure;
use JsonException;
use Override;
filter:
    dependency_paths: ["lib/*"]
use Valkyrja\Type\BuiltIn\Support\Arr;
use Valkyrja\Type\BuiltIn\Support\StrCase;
use Valkyrja\Type\Model\Contract\Model as Contract;
use Valkyrja\Type\Model\Exception\RuntimeException;

use function array_filter;
use function array_walk;
use function in_array;
use function is_array;
use function is_bool;
use function is_string;
use function json_encode;
use function property_exists;

use const ARRAY_FILTER_USE_BOTH;
use const JSON_THROW_ON_ERROR;

/**
 * Class Model.
 *
 * @author Melech Mizrachi
 *
 * @phpstan-consistent-constructor
 *  Will be overridden if need be
 */
abstract class Model implements Contract
{
    /**
     * Cached list of validation logic for models.
     *
     * @var array<string, string>
     */
    protected static array $cachedValidations = [];

    /**
     * Cached list of property/method exists validation logic for models.
     *
     * @var array<string, bool>
     */
    protected static array $cachedExistsValidations = [];

    /**
     * Whether to set the original properties on creation via static::fromArray().
     *
     * @var bool
     */
    protected static bool $shouldSetOriginalProperties = true;

    /**
     * The original properties.
     *
     * @var array<string, mixed>
     */
    private array $internalOriginalProperties = [];

    /**
     * Whether the original properties have been set.
     *
     * @var bool
     */
    private bool $internalOriginalPropertiesSet = false;

    /**
     * @inheritDoc
     *
     * @see https://psalm.dev/r/309e3a322e
     *
     * @param array<string, mixed> $properties The properties
     *
     * @return static
     */
    #[Override]
    public static function fromArray(array $properties): static
    {
        $model = static::internalGetNew($properties);

        $model->internalSetProperties($properties);

        return $model;
    }

    /**
     * @inheritDoc
     *
     * @throws JsonException
     */
    #[Override]
    public static function fromValue(mixed $value): static
    {
        if ($value instanceof static) {
            return $value;
        }

        if (! is_array($value) && ! is_string($value)) {
            $value = json_encode($value, JSON_THROW_ON_ERROR);
        }

        if (is_string($value)) {
            $value = Arr::fromString($value);
        }

        /** @var array<string, mixed> $value */
        return static::fromArray($value);
    }

    /**
     * Get a new static instance.
     *
     * @param array<string, mixed> $properties The properties
     *
     * @return static
     */
    protected static function internalGetNew(array $properties): static
    {
        return new static();
    }

    /**
     * Whether to set the original properties array.
     *
     * @return bool
     */
    protected static function shouldSetOriginalProperties(): bool
    {
        return static::$shouldSetOriginalProperties;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function __get(string $name)
    {
        $methodName = $this->internalGetPropertyTypeMethodName($name, 'get');

        if ($this->internalDoesPropertyTypeMethodExist($methodName)) {
            return $this->$methodName();
        }

        return $this->{$name} ?? null;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function __set(string $name, mixed $value): void
    {
        $methodName = $this->internalGetPropertyTypeMethodName($name, 'set');

        $this->internalSetOriginalProperty($name, $value);

        if ($this->internalDoesPropertyTypeMethodExist($methodName)) {
            $this->$methodName($value);

            return;
        }

        $this->{$name} = $value;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function __isset(string $name): bool
    {
        $methodName = $this->internalGetPropertyTypeMethodName($name, 'isset');

        if ($this->internalDoesPropertyTypeMethodExist($methodName)) {
            $isset = $this->$methodName();

            if (! is_bool($isset)) {
                throw new RuntimeException("$methodName must return a boolean");
            }

            return $isset;
        }

        return isset($this->$name);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function offsetExists($offset): bool
    {
        /** @var string $offset */
        return isset($this->{$offset});
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function offsetGet($offset): mixed
    {
        /** @var string $offset */
        return $this->__get($offset);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function offsetSet($offset, $value): void
    {
        /** @var string $offset */
        $this->__set($offset, $value);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function offsetUnset(mixed $offset): void
    {
        unset($this->{$offset});
    }

    /**
     * Determine whether the model has a property.
     *
     * @param string $property The property
     *
     * @return bool
     */
    #[Override]
    public function hasProperty(string $property): bool
    {
        return self::$cachedExistsValidations[static::class . $property] ??= property_exists($this, $property);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function updateProperties(array $properties): void
    {
        $this->internalSetProperties($properties);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withProperties(array $properties): static
    {
        $model = clone $this;

        $model->internalSetProperties($properties);

        return $model;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function modify(callable $closure): static
    {
        $new = clone $this;

        return $closure($new);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function asValue(): static
    {
        return $this;
    }

    /**
     * @inheritDoc
     *
     * @throws JsonException
     */
    #[Override]
    public function asFlatValue(): string
    {
        return $this->__toString();
    }

    /**
     * @inheritDoc
     *
     * @param string ...$properties [optional] An array of properties to return
     *
     * @return array<string, mixed>
     */
    #[Override]
    public function asArray(string ...$properties): array
    {
        // Get the public properties
        $allProperties = $this->internalGetAllProperties();

        $this->internalRemoveInternalProperties($allProperties);

        $allProperties = $this->internalCheckOnlyProperties($allProperties, $properties);

        return $this->internalSetPropertyValues($allProperties, [$this, '__get']);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function asChangedArray(): array
    {
        return $this->internalGetChangedProperties($this->asArray());
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getOriginalPropertyValue(string $name): mixed
    {
        return $this->internalOriginalProperties[$name] ?? null;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function asOriginalArray(): array
    {
        return $this->internalOriginalProperties;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function jsonSerialize(): array
    {
        $allProperties = $this->internalGetAllProperties();

        $this->internalRemoveInternalProperties($allProperties);

        return $this->internalSetPropertyValues($allProperties, [$this, 'internalGetJsonPropertyValue']);
    }

    /**
     * @inheritDoc
     *
     * @throws JsonException
     */
    public function __toString(): string
    {
        return Arr::toString($this->jsonSerialize());
    }

    /**
     * Clone model.
     */
    public function __clone()
    {
        $this->internalSetOriginalPropertiesSetProperty();
    }

    /**
     * Set properties from an array of properties.
     *
     * @param array<string, mixed>               $properties  The properties to set
     * @param Closure(string, mixed): mixed|null $modifyValue [optional] The closure to modify the value before setting
     *
     * @return void
     */
    protected function internalSetProperties(array $properties, Closure|null $modifyValue = null): void
    {
        array_walk(
            $properties,
            function (mixed $value, string $property) use ($modifyValue): void {
                $this->internalSetIfPropertyExists(
                    $property,
                    $modifyValue !== null
                        ? $modifyValue($property, $value)
                        : $value
                );
            }
        );

        $this->internalSetOriginalPropertiesSetProperty();
    }

    /**
     * Set a property if it exists.
     *
     * @param string $property The property
     * @param mixed  $value    The value
     *
     * @return void
     */
    protected function internalSetIfPropertyExists(string $property, mixed $value): void
    {
        if ($this->hasProperty($property)) {
            // Set the property
            $this->__set($property, $value);
        }
    }

    /**
     * Set that original properties have been set.
     *
     * @return void
     */
    protected function internalSetOriginalPropertiesSetProperty(): void
    {
        $this->internalOriginalPropertiesSet = true;
    }

    /**
     * Get a property's isset method name.
     *
     * @param string $property The property
     * @param string $type     The type (get|set|isset)
     *
     * @return string
     */
    protected function internalGetPropertyTypeMethodName(string $property, string $type): string
    {
        return self::$cachedValidations[static::class . "$type$property"]
            ??= $type . StrCase::toStudlyCase($property);
    }

    /**
     * Determine if a property type method exists.
     *
     * @param string $methodName The method name
     *
     * @return bool
     */
    protected function internalDoesPropertyTypeMethodExist(string $methodName): bool
    {
        return self::$cachedExistsValidations[static::class . "exists$methodName"]
            ??= method_exists($this, $methodName);
    }

    /**
     * Set an original property.
     *
     * @param string $name  The property name
     * @param mixed  $value The value
     *
     * @return void
     */
    protected function internalSetOriginalProperty(string $name, mixed $value): void
    {
        if (! $this->internalOriginalPropertiesSet && static::shouldSetOriginalProperties()) {
            $this->internalOriginalProperties[$name] ??= $value;
        }
    }

    /**
     * Get all properties.
     *
     * @return array<string, mixed>
     */
    protected function internalGetAllProperties(): array
    {
        /** @var array<string, mixed> */
        return get_object_vars($this);
    }

    /**
     * Remove internal model properties from an array of properties.
     *
     * @param array<string, mixed> $properties The properties
     *
     * @return void
     */
    protected function internalRemoveInternalProperties(array &$properties): void
    {
        unset($properties['internalOriginalProperties'], $properties['internalOriginalPropertiesSet']);
    }

    /**
     * Check if an array of all properties should be filtered by another list of properties.
     *
     * @param array<string, mixed> $properties     The properties
     * @param string[]             $onlyProperties A list of properties to return
     *
     * @return array<string, mixed>
     */
    protected function internalCheckOnlyProperties(array $properties, array $onlyProperties): array
    {
        if (! empty($onlyProperties)) {
            return $this->internalOnlyProperties($properties, $onlyProperties);
        }

        return $properties;
    }

    /**
     * Get an array subset of properties to return from a given list out of the returnable properties.
     *
     * @param array<string, mixed> $allProperties All the properties returnable
     * @param string[]             $properties    The properties we wish to return
     *
     * @return array<string, mixed>
     */
    protected function internalOnlyProperties(array $allProperties, array $properties): array
    {
        return array_filter(
            $allProperties,
            static fn (mixed $value, string $property) => in_array($property, $properties, true),
            ARRAY_FILTER_USE_BOTH
        );
    }

    /**
     * Get the changed properties given an array of properties.
     *
     * @param array<string, mixed> $properties The properties to check the original properties against
     *
     * @return array<string, mixed>
     */
    protected function internalGetChangedProperties(array $properties): array
    {
        return array_filter(
            $properties,
            function (mixed $value, string $property) {
                /** @var mixed $originalProperty */
                $originalProperty = $this->internalOriginalProperties[$property] ?? null;

                return $originalProperty !== $value;
            },
            ARRAY_FILTER_USE_BOTH
        );
    }

    /**
     * Set property values.
     *
     * @param array<string, mixed> $properties The properties
     * @param callable             $callable   The callable
     *
     * @return array<string, mixed>
     */
    protected function internalSetPropertyValues(array $properties, callable $callable): array
    {
        array_walk($properties, static fn (mixed &$value, string $property): mixed => /** @var mixed $value */ $value = $callable($property));

        /** @var array<string, mixed> $properties */
        return $properties;
    }

    /**
     * Get a property's value for jsonSerialize.
     *
     * @param string $property The property
     *
     * @return mixed
     */
    protected function internalGetJsonPropertyValue(string $property): mixed
    {
        return $this->__get($property);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the Valkyrja Framework package.
7			*
8			* (c) Melech Mizrachi <[email protected]>
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace Valkyrja\Type\Model;
15
16			use Closure;
17			use JsonException;
18			use Override;
			0 ignored issues – show Bug introduced 2025-07-10 03:52 UTC by Report Bug Copy Issue Report The type `Override` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
19			use Valkyrja\Type\BuiltIn\Support\Arr;
20			use Valkyrja\Type\BuiltIn\Support\StrCase;
21			use Valkyrja\Type\Model\Contract\Model as Contract;
22			use Valkyrja\Type\Model\Exception\RuntimeException;
23
24			use function array_filter;
25			use function array_walk;
26			use function in_array;
27			use function is_array;
28			use function is_bool;
29			use function is_string;
30			use function json_encode;
31			use function property_exists;
32
33			use const ARRAY_FILTER_USE_BOTH;
34			use const JSON_THROW_ON_ERROR;
35
36			/**
37			* Class Model.
38			*
39			* @author Melech Mizrachi
40			*
41			* @phpstan-consistent-constructor
42			* Will be overridden if need be
43			*/
44			abstract class Model implements Contract
45			{
46			/**
47			* Cached list of validation logic for models.
48			*
49			* @var array<string, string>
50			*/
51			protected static array $cachedValidations = [];
52
53			/**
54			* Cached list of property/method exists validation logic for models.
55			*
56			* @var array<string, bool>
57			*/
58			protected static array $cachedExistsValidations = [];
59
60			/**
61			* Whether to set the original properties on creation via static::fromArray().
62			*
63			* @var bool
64			*/
65			protected static bool $shouldSetOriginalProperties = true;
66
67			/**
68			* The original properties.
69			*
70			* @var array<string, mixed>
71			*/
72			private array $internalOriginalProperties = [];
73
74			/**
75			* Whether the original properties have been set.
76			*
77			* @var bool
78			*/
79			private bool $internalOriginalPropertiesSet = false;
80
81			/**
82			* @inheritDoc
83			*
84			* @see https://psalm.dev/r/309e3a322e
85			*
86			* @param array<string, mixed> $properties The properties
87			*
88			* @return static
89			*/
90			#[Override]
91			public static function fromArray(array $properties): static
92			{
93			$model = static::internalGetNew($properties);
94
95			$model->internalSetProperties($properties);
96
97			return $model;
98			}
99
100			/**
101			* @inheritDoc
102			*
103			* @throws JsonException
104			*/
105			#[Override]
106			public static function fromValue(mixed $value): static
107			{
108			if ($value instanceof static) {
109			return $value;
110			}
111
112			if (! is_array($value) && ! is_string($value)) {
113			$value = json_encode($value, JSON_THROW_ON_ERROR);
114			}
115
116			if (is_string($value)) {
117			$value = Arr::fromString($value);
118			}
119
120			/** @var array<string, mixed> $value */
121			return static::fromArray($value);
122			}
123
124			/**
125			* Get a new static instance.
126			*
127			* @param array<string, mixed> $properties The properties
128			*
129			* @return static
130			*/
131			protected static function internalGetNew(array $properties): static
132			{
133			return new static();
134			}
135
136			/**
137			* Whether to set the original properties array.
138			*
139			* @return bool
140			*/
141			protected static function shouldSetOriginalProperties(): bool
142			{
143			return static::$shouldSetOriginalProperties;
144			}
145
146			/**
147			* @inheritDoc
148			*/
149			#[Override]
150			public function __get(string $name)
151			{
152			$methodName = $this->internalGetPropertyTypeMethodName($name, 'get');
153
154			if ($this->internalDoesPropertyTypeMethodExist($methodName)) {
155			return $this->$methodName();
156			}
157
158			return $this->{$name} ?? null;
159			}
160
161			/**
162			* @inheritDoc
163			*/
164			#[Override]
165			public function __set(string $name, mixed $value): void
166			{
167			$methodName = $this->internalGetPropertyTypeMethodName($name, 'set');
168
169			$this->internalSetOriginalProperty($name, $value);
170
171			if ($this->internalDoesPropertyTypeMethodExist($methodName)) {
172			$this->$methodName($value);
173
174			return;
175			}
176
177			$this->{$name} = $value;
178			}
179
180			/**
181			* @inheritDoc
182			*/
183			#[Override]
184			public function __isset(string $name): bool
185			{
186			$methodName = $this->internalGetPropertyTypeMethodName($name, 'isset');
187
188			if ($this->internalDoesPropertyTypeMethodExist($methodName)) {
189			$isset = $this->$methodName();
190
191			if (! is_bool($isset)) {
192			throw new RuntimeException("$methodName must return a boolean");
193			}
194
195			return $isset;
196			}
197
198			return isset($this->$name);
199			}
200
201			/**
202			* @inheritDoc
203			*/
204			#[Override]
205			public function offsetExists($offset): bool
206			{
207			/** @var string $offset */
208			return isset($this->{$offset});
209			}
210
211			/**
212			* @inheritDoc
213			*/
214			#[Override]
215			public function offsetGet($offset): mixed
216			{
217			/** @var string $offset */
218			return $this->__get($offset);
219			}
220
221			/**
222			* @inheritDoc
223			*/
224			#[Override]
225			public function offsetSet($offset, $value): void
226			{
227			/** @var string $offset */
228			$this->__set($offset, $value);
229			}
230
231			/**
232			* @inheritDoc
233			*/
234			#[Override]
235			public function offsetUnset(mixed $offset): void
236			{
237			unset($this->{$offset});
238			}
239
240			/**
241			* Determine whether the model has a property.
242			*
243			* @param string $property The property
244			*
245			* @return bool
246			*/
247			#[Override]
248			public function hasProperty(string $property): bool
249			{
250			return self::$cachedExistsValidations[static::class . $property] ??= property_exists($this, $property);
251			}
252
253			/**
254			* @inheritDoc
255			*/
256			#[Override]
257			public function updateProperties(array $properties): void
258			{
259			$this->internalSetProperties($properties);
260			}
261
262			/**
263			* @inheritDoc
264			*/
265			#[Override]
266			public function withProperties(array $properties): static
267			{
268			$model = clone $this;
269
270			$model->internalSetProperties($properties);
271
272			return $model;
273			}
274
275			/**
276			* @inheritDoc
277			*/
278			#[Override]
279			public function modify(callable $closure): static
280			{
281			$new = clone $this;
282
283			return $closure($new);
284			}
285
286			/**
287			* @inheritDoc
288			*/
289			#[Override]
290			public function asValue(): static
291			{
292			return $this;
293			}
294
295			/**
296			* @inheritDoc
297			*
298			* @throws JsonException
299			*/
300			#[Override]
301			public function asFlatValue(): string
302			{
303			return $this->__toString();
304			}
305
306			/**
307			* @inheritDoc
308			*
309			* @param string ...$properties [optional] An array of properties to return
310			*
311			* @return array<string, mixed>
312			*/
313			#[Override]
314			public function asArray(string ...$properties): array
315			{
316			// Get the public properties
317			$allProperties = $this->internalGetAllProperties();
318
319			$this->internalRemoveInternalProperties($allProperties);
320
321			$allProperties = $this->internalCheckOnlyProperties($allProperties, $properties);
322
323			return $this->internalSetPropertyValues($allProperties, [$this, '__get']);
324			}
325
326			/**
327			* @inheritDoc
328			*/
329			#[Override]
330			public function asChangedArray(): array
331			{
332			return $this->internalGetChangedProperties($this->asArray());
333			}
334
335			/**
336			* @inheritDoc
337			*/
338			#[Override]
339			public function getOriginalPropertyValue(string $name): mixed
340			{
341			return $this->internalOriginalProperties[$name] ?? null;
342			}
343
344			/**
345			* @inheritDoc
346			*/
347			#[Override]
348			public function asOriginalArray(): array
349			{
350			return $this->internalOriginalProperties;
351			}
352
353			/**
354			* @inheritDoc
355			*/
356			#[Override]
357			public function jsonSerialize(): array
358			{
359			$allProperties = $this->internalGetAllProperties();
360
361			$this->internalRemoveInternalProperties($allProperties);
362
363			return $this->internalSetPropertyValues($allProperties, [$this, 'internalGetJsonPropertyValue']);
364			}
365
366			/**
367			* @inheritDoc
368			*
369			* @throws JsonException
370			*/
371			public function __toString(): string
372			{
373			return Arr::toString($this->jsonSerialize());
374			}
375
376			/**
377			* Clone model.
378			*/
379			public function __clone()
380			{
381			$this->internalSetOriginalPropertiesSetProperty();
382			}
383
384			/**
385			* Set properties from an array of properties.
386			*
387			* @param array<string, mixed> $properties The properties to set
388			* @param Closure(string, mixed): mixed\|null $modifyValue [optional] The closure to modify the value before setting
389			*
390			* @return void
391			*/
392			protected function internalSetProperties(array $properties, Closure\|null $modifyValue = null): void
393			{
394			array_walk(
395			$properties,
396			function (mixed $value, string $property) use ($modifyValue): void {
397			$this->internalSetIfPropertyExists(
398			$property,
399			$modifyValue !== null
400			? $modifyValue($property, $value)
401			: $value
402			);
403			}
404			);
405
406			$this->internalSetOriginalPropertiesSetProperty();
407			}
408
409			/**
410			* Set a property if it exists.
411			*
412			* @param string $property The property
413			* @param mixed $value The value
414			*
415			* @return void
416			*/
417			protected function internalSetIfPropertyExists(string $property, mixed $value): void
418			{
419			if ($this->hasProperty($property)) {
420			// Set the property
421			$this->__set($property, $value);
422			}
423			}
424
425			/**
426			* Set that original properties have been set.
427			*
428			* @return void
429			*/
430			protected function internalSetOriginalPropertiesSetProperty(): void
431			{
432			$this->internalOriginalPropertiesSet = true;
433			}
434
435			/**
436			* Get a property's isset method name.
437			*
438			* @param string $property The property
439			* @param string $type The type (get\|set\|isset)
440			*
441			* @return string
442			*/
443			protected function internalGetPropertyTypeMethodName(string $property, string $type): string
444			{
445			return self::$cachedValidations[static::class . "$type$property"]
446			??= $type . StrCase::toStudlyCase($property);
447			}
448
449			/**
450			* Determine if a property type method exists.
451			*
452			* @param string $methodName The method name
453			*
454			* @return bool
455			*/
456			protected function internalDoesPropertyTypeMethodExist(string $methodName): bool
457			{
458			return self::$cachedExistsValidations[static::class . "exists$methodName"]
459			??= method_exists($this, $methodName);
460			}
461
462			/**
463			* Set an original property.
464			*
465			* @param string $name The property name
466			* @param mixed $value The value
467			*
468			* @return void
469			*/
470			protected function internalSetOriginalProperty(string $name, mixed $value): void
471			{
472			if (! $this->internalOriginalPropertiesSet && static::shouldSetOriginalProperties()) {
473			$this->internalOriginalProperties[$name] ??= $value;
474			}
475			}
476
477			/**
478			* Get all properties.
479			*
480			* @return array<string, mixed>
481			*/
482			protected function internalGetAllProperties(): array
483			{
484			/** @var array<string, mixed> */
485			return get_object_vars($this);
486			}
487
488			/**
489			* Remove internal model properties from an array of properties.
490			*
491			* @param array<string, mixed> $properties The properties
492			*
493			* @return void
494			*/
495			protected function internalRemoveInternalProperties(array &$properties): void
496			{
497			unset($properties['internalOriginalProperties'], $properties['internalOriginalPropertiesSet']);
498			}
499
500			/**
501			* Check if an array of all properties should be filtered by another list of properties.
502			*
503			* @param array<string, mixed> $properties The properties
504			* @param string[] $onlyProperties A list of properties to return
505			*
506			* @return array<string, mixed>
507			*/
508			protected function internalCheckOnlyProperties(array $properties, array $onlyProperties): array
509			{
510			if (! empty($onlyProperties)) {
511			return $this->internalOnlyProperties($properties, $onlyProperties);
512			}
513
514			return $properties;
515			}
516
517			/**
518			* Get an array subset of properties to return from a given list out of the returnable properties.
519			*
520			* @param array<string, mixed> $allProperties All the properties returnable
521			* @param string[] $properties The properties we wish to return
522			*
523			* @return array<string, mixed>
524			*/
525			protected function internalOnlyProperties(array $allProperties, array $properties): array
526			{
527			return array_filter(
528			$allProperties,
529			static fn (mixed $value, string $property) => in_array($property, $properties, true),
530			ARRAY_FILTER_USE_BOTH
531			);
532			}
533
534			/**
535			* Get the changed properties given an array of properties.
536			*
537			* @param array<string, mixed> $properties The properties to check the original properties against
538			*
539			* @return array<string, mixed>
540			*/
541			protected function internalGetChangedProperties(array $properties): array
542			{
543			return array_filter(
544			$properties,
545			function (mixed $value, string $property) {
546			/** @var mixed $originalProperty */
547			$originalProperty = $this->internalOriginalProperties[$property] ?? null;
548
549			return $originalProperty !== $value;
550			},
551			ARRAY_FILTER_USE_BOTH
552			);
553			}
554
555			/**
556			* Set property values.
557			*
558			* @param array<string, mixed> $properties The properties
559			* @param callable $callable The callable
560			*
561			* @return array<string, mixed>
562			*/
563			protected function internalSetPropertyValues(array $properties, callable $callable): array
564			{
565			array_walk($properties, static fn (mixed &$value, string $property): mixed => /** @var mixed $value */ $value = $callable($property));
566
567			/** @var array<string, mixed> $properties */
568			return $properties;
569			}
570
571			/**
572			* Get a property's value for jsonSerialize.
573			*
574			* @param string $property The property
575			*
576			* @return mixed
577			*/
578			protected function internalGetJsonPropertyValue(string $property): mixed
579			{
580			return $this->__get($property);
581			}
582			}
583

valkyrjaio / valkyrja

Model::offsetUnset() A last analyzed 2025-08-08 04:54 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Model::offsetUnset() A
last analyzed 2025-08-08 04:54 UTC