ICanBoogie\Prototyped

Complexity

Total Complexity

9

Size/Duplication

Total Lines	194
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
B	from()	0	30	8
	assign()	0	11	?
A	get_class_reflection()	0	6	1
A	hp$0 ➔ __sleep()	0	7	1
	to_array()	0	10	?
A	hp$0 ➔ get_object_vars()	0	16	2
A	hp$0 ➔ assign()	0	11	3
	to_json()	0	7	?
A	hp$0 ➔ to_json()	0	7	1
A	assignable()	0	3	1
A	hp$0 ➔ to_array()	0	10	2
	__sleep()	0	7	?
	get_object_vars()	0	16	?

<?php

/*
 * This file is part of the ICanBoogie package.
 *
 * (c) Olivier Laviale <olivier.laviale@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace ICanBoogie;

use AllowDynamicProperties;

The type AllowDynamicProperties was not found. Maybe you did not declare it correctly or list all dependencies?

use Closure;
use ICanBoogie\Accessor\AccessorReflection;
use ICanBoogie\Accessor\SerializableTrait;
use ICanBoogie\Prototype\UnableToInstantiate;
use ReflectionClass;
use ReflectionException;
use Throwable;

use function array_fill_keys;
use function array_intersect_key;
use function array_keys;
use function get_called_class;
use function get_object_vars;
use function is_callable;
use function is_string;
use function json_encode;

/**
 * Together with the {@link Prototype} class the {@link Prototyped} class provides means to
 * define getters and setters, as well as define getters, setters, and method at runtime.
 *
 * The class also provides a method to create instances in the same fashion PDO creates instances
 * with the `FETCH_CLASS` mode, that is the properties of the instance are set *before* its
 * constructor is invoked.
 */
#[AllowDynamicProperties]
class Prototyped implements ToArrayRecursive
{
    use ToArrayRecursiveTrait;
    use PrototypeTrait;
    use SerializableTrait;

The trait ICanBoogie\Accessor\SerializableTrait requires the property $class which is not provided by ICanBoogie\Prototyped.

    public const ASSIGN_SAFE = false;
    public const ASSIGN_UNSAFE = true;

    /**
     * Creates a new instance of the class using the supplied properties.
     *
     * The method tries to create the instance in the same fashion as
     * [PDO](http://www.php.net/manual/en/book.pdo.php) with the `FETCH_CLASS` mode, that is the
     * properties of the instance are set *before* its constructor is invoked.
     *
     * @param array<string, mixed> $properties Properties to be set before the constructor is invoked.
     * @param mixed[] $construct_args Arguments passed to the constructor.
     * @param class-string|null $class_name The name of the instance class. If empty, the name of the

The doc comment class-string|null at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string|null.

     * called class is used.
     *
     * @return object The new instance.
     *
     * @throws UnableToInstantiate
     */
    public static function from(array $properties = [], array $construct_args = [], string $class_name = null): object
    {
        if (!$class_name) {
            $class_name = get_called_class();
        }

        try {
            $class_reflection = self::get_class_reflection($class_name);

            if (!$properties) {

The expression $properties of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

                return $class_reflection->newInstanceArgs($construct_args);
            }

            $instance = $class_reflection->newInstanceWithoutConstructor();

            if ($instance instanceof self) {
                $instance->assign($properties, self::ASSIGN_UNSAFE);
            } else {
                foreach ($properties as $property => $value) {
                    $instance->$property = $value;
                }
            }

            if ($class_reflection->hasMethod('__construct') && is_callable([ $instance, '__construct' ])) {
                $instance->__construct(...$construct_args);
            }

            return $instance;
        } catch (Throwable $e) {
            throw new UnableToInstantiate("Unable to instantiate `$class_name`.", 0, $e);
        }
    }

    /**
     * Returns assignable properties.
     *
     * @return string[]
     */
    public static function assignable(): array
    {
        return [];
    }

    /**
     * @var array<class-string, ReflectionClass<object>>

The doc comment array<class-string, ReflectionClass<object>> at position 2 could not be parsed: Unknown type name 'class-string' at position 2 in array<class-string, ReflectionClass<object>>.

     */
    private static $class_reflection_cache = [];

    /**
     * Returns cached class reflection.
     *
     * @template T of object
     *
     * @param class-string<T> $class_name

The doc comment class-string<T> at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string<T>.

     *
     * @throws ReflectionException
     *
     * @return ReflectionClass<T>
     */
    private static function get_class_reflection(string $class_name): ReflectionClass
    {
        $reflection = &self::$class_reflection_cache[$class_name];

        /** @phpstan-ignore-next-line */
        return $reflection ?? $reflection = new ReflectionClass($class_name);
    }

    /**
     * Returns the public properties of an instance.
     *
     * @return array<string, mixed>
     */
    private static function get_object_vars(object $object): array
    {
        static $get_object_vars;

        if (!$get_object_vars) {
            $get_object_vars = Closure::bind(function (object $object) {
                return get_object_vars($object);
            },
                null,
                get_class(
                    new class {
                    }
                )); // Because `stdClass` is a no-no in PHP7
        }

        return $get_object_vars($object);
    }

    /**
     * The method returns an array of key/key pairs.
     *
     * Properties for which a lazy getter is defined are discarded. For instance, if the property
     * `next` is defined and the class of the instance defines the getter `lazy_get_next()`, the
     * property is discarded.
     *
     * Note that façade properties are also included.
     *
     * Warning: The code used to export private properties seams to produce frameless exception on
     * session close. If you encounter this problem you might want to override the method. Don't
     * forget to remove the prototype property!
     *
     * @return array<string, mixed>
     *
     * @throws ReflectionException
     */
    public function __sleep()
    {
        $keys = $this->accessor_sleep();

        unset($keys['prototype']);

        return $keys;
    }

    /**
     * Assigns properties to an object.
     *
     * @param array<string, mixed> $properties The properties to assign.
     * @param bool $unsafe The properties are not filtered if `true`.
     *
     * @return $this

The doc comment $this at position 0 could not be parsed: '$this' is only available from within classes.

     */
    public function assign(array $properties, bool $unsafe = self::ASSIGN_SAFE): object
    {
        if (!$unsafe) {
            $properties = array_intersect_key($properties, array_fill_keys(static::assignable(), null));
        }

        foreach ($properties as $property => $value) {
            $this->$property = $value;
        }

        return $this;
    }

    /**
     * Converts the object into an array.
     *
     * Only public properties and façade properties are included.
     *
     * @return array<string, mixed>
     *
     * @throws ReflectionException
     */
    public function to_array(): array
    {
        $array = self::get_object_vars($this);

        /** @phpstan-ignore-next-line */
        foreach (array_keys(AccessorReflection::resolve_facade_properties($this)) as $name) {
            $array[$name] = $this->$name;
        }

        return $array;
    }

    /**
     * Converts the object into a JSON string.
     */
    public function to_json(): string
    {
        $json = json_encode($this->to_array_recursive());

        assert(is_string($json));

        return $json;
    }
}