Inheritance diagram for ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder:

Collaboration diagram for ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder:

Public Member Functions
	create (string $fqdn)

	defaultValueFor (object $object, string $method)
	Derives the value a mocked method returns when nothing was stubbed. More...

	create (string $fqdn)

Protected Member Functions
	loadGeneratedCode (string $code, string $generated_class)

Private Member Functions
	createLazyShell (string $type)

	createNormal (string $type)

	generate (string $type, string $generated_class)

	shouldOverride (ReflectionMethod $method)

	buildMethod (ReflectionMethod $method, array &$return_map)

	buildMethodAttributes (ReflectionMethod $method)

	needsReturnTypeWillChange (ReflectionMethod $method)

	buildMethodBody (string $method_name, ?ReflectionType $return_type)

	buildStaticMethodBody (string $method_name)
	Static methods have no instance to record the call on, they are only declared to satisfy the signature of the mocked type. More...

	buildParameterList (ReflectionMethod $method)

	buildParameter (ReflectionParameter $parameter)

	renderType (?ReflectionType $type)

	normalizeType (?ReflectionType $type)

	defaultByMeta (object $object, array $meta)

	generatedClassName (string $type)

	exportValue (mixed $value)

Detailed Description

Definition at line 35 of file AbstractLightMockBuilder.php.

Member Function Documentation

◆ buildMethod()

ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder::buildMethod	(	ReflectionMethod	$method,
		array &	$return_map
	)

private

Parameters

array<string,mixed> $return_map

Definition at line 220 of file AbstractLightMockBuilder.php.

                                                                              : string
    {
        $visibility = $method->isPublic() ? 'public' : 'protected';
        $static = $method->isStatic() ? ' static' : '';
        $name = $method->getName();
        $params = $this->buildParameterList($method);
        $return_type = $this->renderType($method->getReturnType());
 
        $return_map[$name] = $this->normalizeType($method->getReturnType());
 
        $body = $method->isStatic()
            ? $this->buildStaticMethodBody($name)
            : $this->buildMethodBody($name, $method->getReturnType());
        $attribute = $this->buildMethodAttributes($method);
 
        return trim(
            $attribute .
            sprintf(
                '%s%s function %s(%s)%s %s',
                $visibility,
                $static,
                $name,
                $params,
                $return_type !== '' ? ': ' . $return_type : '',
                $body
            )
        );
    }

References $body, ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\buildMethodAttributes(), ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\buildMethodBody(), ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\buildParameterList(), ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\buildStaticMethodBody(), ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\normalizeType(), and ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\renderType().

Referenced by ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\generate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildMethodAttributes()

ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder::buildMethodAttributes ( ReflectionMethod $method )

private

Definition at line 249 of file AbstractLightMockBuilder.php.

                                                                    : string
    {
        if ($this->needsReturnTypeWillChange($method)) {
            return "#[\\ReturnTypeWillChange]\n";
        }
 
        return '';
    }

References ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\needsReturnTypeWillChange().

Referenced by ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\buildMethod().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildMethodBody()

ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder::buildMethodBody	(	string	$method_name,
		?ReflectionType	$return_type
	)

private

Definition at line 285 of file AbstractLightMockBuilder.php.

                                                                                       : string
    {
        $normalized = $this->normalizeType($return_type);
 
        if ($normalized['kind'] === 'never') {
            return <<<PHP
{
    throw new \\LogicException('Mocked never-returning method called: {$method_name}');
}
PHP;
        }
 
        if ($normalized['kind'] === 'void') {
            return <<<PHP
{
    \$this->__mockInvoke('{$method_name}', func_get_args());
    return;
}
PHP;
        }
 
        return <<<PHP
{
    return \$this->__mockInvoke('{$method_name}', func_get_args());
}
PHP;
    }

References ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\normalizeType().

Referenced by ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\buildMethod().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildParameter()

ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder::buildParameter ( ReflectionParameter $parameter )

private

Definition at line 337 of file AbstractLightMockBuilder.php.

                                                                   : string
    {
        $code = '';
 
        $type = $this->renderType($parameter->getType());
        if ($type !== '') {
            $code .= $type . ' ';
        }
 
        if ($parameter->isPassedByReference()) {
            $code .= '&';
        }
 
        if ($parameter->isVariadic()) {
            $code .= '...';
        }
 
        $code .= '$' . $parameter->getName();
 
        if (!$parameter->isVariadic() && $parameter->isDefaultValueAvailable()) {
            if ($parameter->isDefaultValueConstant()) {
                $code .= ' = ' . $parameter->getDefaultValueConstantName();
            } else {
                $code .= ' = ' . $this->exportValue($parameter->getDefaultValue());
            }
        }
 
        return $code;
    }

References ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\exportValue(), and ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\renderType().

Referenced by ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\buildParameterList().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildParameterList()

ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder::buildParameterList ( ReflectionMethod $method )

private

Definition at line 326 of file AbstractLightMockBuilder.php.

                                                                 : string
    {
        $parts = [];
 
        foreach ($method->getParameters() as $parameter) {
            $parts[] = $this->buildParameter($parameter);
        }
 
        return implode(', ', $parts);
    }

References ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\buildParameter().

Referenced by ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\buildMethod().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildStaticMethodBody()

ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder::buildStaticMethodBody ( string $method_name )

private

Static methods have no instance to record the call on, they are only declared to satisfy the signature of the mocked type.

Definition at line 317 of file AbstractLightMockBuilder.php.

                                                               : string
    {
        return <<<PHP
{
    throw new \\LogicException('Static methods of mocks cannot be called: {$method_name}');
}
PHP;
    }

Referenced by ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\buildMethod().

Here is the caller graph for this function:

◆ create()

ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder::create ( string $fqdn )

Parameters

string $type FQDN of interface, class, ...

Returns: object Mock of this type

Implements ILIAS\Component\Dependencies\Mocks\MockBuilder.

Definition at line 76 of file AbstractLightMockBuilder.php.

                                        : object
    {
        if (interface_exists($fqdn)) {
            return $this->createNormal($fqdn);
        }
 
        try {
            return $this->createLazyShell($fqdn);
        } catch (LogicException | \ReflectionException) {
            return $this->createNormal($fqdn);
        }
    }

References ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\createLazyShell(), and ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\createNormal().

Here is the call graph for this function:

◆ createLazyShell()

ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder::createLazyShell ( string $type )

private

Definition at line 37 of file AbstractLightMockBuilder.php.

                                                  : object
    {
        if (!class_exists($type)) {
            throw new LogicException(
                "Lazy-shell mocks only support concrete or abstract classes, not interfaces/unknown types: {$type}"
            );
        }
 
        $ref = new ReflectionClass($type);
 
        if ($ref->isInterface()) {
            throw new LogicException("Lazy-shell mocks do not support interfaces: {$type}");
        }
 
        if ($ref->isTrait()) {
            throw new LogicException("Traits cannot be mocked directly: {$type}");
        }
 
        if ($ref->isEnum()) {
            throw new LogicException("Enums cannot be mocked: {$type}");
        }
 
        if ($ref->isFinal()) {
            throw new LogicException("Final classes cannot be mocked without extensions/code rewriting: {$type}");
        }
 
        if ($ref->isAbstract()) {
            throw new LogicException("Abstract classes cannot be instantiated as a lazy shell: {$type}");
        }
 
        return $ref->newLazyGhost(
            static function (object $object): void {
                // Intentionally left blank.
                // This variant is only meant to provide a typed shell object.
            },
            ReflectionClass::SKIP_INITIALIZATION_ON_SERIALIZE
        );
    }

Referenced by ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\create().

Here is the caller graph for this function:

◆ createNormal()

ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder::createNormal ( string $type )

private

Definition at line 89 of file AbstractLightMockBuilder.php.

                                               : object
    {
        $generated_class = $this->generatedClassName($type);
        $generated_fqcn = __NAMESPACE__ . '\\' . $generated_class;
 
        if (!GeneratedMockRegistry::isGenerated($generated_fqcn)) {
            GeneratedMockRegistry::register($generated_fqcn, $this->generate($type, $generated_class), $this);
        }
 
        return new $generated_fqcn();
    }

References ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\generate(), ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\generatedClassName(), ILIAS\Component\Dependencies\Mocks\GeneratedMockRegistry\isGenerated(), and ILIAS\Component\Dependencies\Mocks\GeneratedMockRegistry\register().

Referenced by ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\create(), and ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\defaultByMeta().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ defaultByMeta()

ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder::defaultByMeta	(	object	$object,
		array	$meta
	)

private

Parameters

array<string,mixed> $meta

Definition at line 475 of file AbstractLightMockBuilder.php.

                                                               : mixed
    {
        $kind = $meta['kind'] ?? 'none';
 
        if ($kind === 'none') {
            return null;
        }
 
        if ($kind === 'void') {
            return null;
        }
 
        if ($kind === 'never') {
            throw new LogicException('Cannot produce a default value for return type never');
        }
 
        if ($kind === 'intersection') {
            throw new LogicException('Intersection return types need explicit stubbing');
        }
 
        if ($kind === 'union') {
            foreach ($meta['types'] as $sub_type) {
                if (($sub_type['kind'] ?? null) === 'named' && ($sub_type['name'] ?? null) === 'null') {
                    return null;
                }
            }
 
            foreach ($meta['types'] as $sub_type) {
                if (($sub_type['kind'] ?? null) === 'named' && ($sub_type['name'] ?? null) !== 'null') {
                    return $this->defaultByMeta($object, $sub_type);
                }
            }
 
            return null;
        }
 
        $name = $meta['name'] ?? null;
        $nullable = (bool) ($meta['nullable'] ?? false);
 
        if ($nullable) {
            return null;
        }
 
        return match ($name) {
            'void' => null,
            'never' => throw new LogicException('Cannot return from a never-returning method'),
            'null' => null,
            'mixed' => null,
            'bool', 'false' => false,
            'true' => true,
            'int' => 0,
            'float' => 0.0,
            'string' => '',
            'array' => [],
            'iterable' => [],
            'callable' => static fn(): null => null,
            'object' => new \stdClass(),
            'self', 'static' => $object,
            'parent' => $this->createNormal((string) get_parent_class($object)),
            default => $this->createNormal($name),
        };
    }

References ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\createNormal(), and ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\defaultByMeta().

Referenced by ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\defaultByMeta(), and ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\defaultValueFor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ defaultValueFor()

ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder::defaultValueFor	(	object	$object,
		string	$method
	)

Derives the value a mocked method returns when nothing was stubbed.

Called through {

See also: GeneratedMockRegistry::defaultValueFor()}.

Definition at line 460 of file AbstractLightMockBuilder.php.

                                                                   : mixed
    {
        $meta = GeneratedMockRegistry::returnTypeFor($object::class, $method);
 
        if ($meta === null) {
            // a method this builder never saw
            return null;
        }
 
        return $this->defaultByMeta($object, $meta);
    }

References ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\defaultByMeta(), and ILIAS\Component\Dependencies\Mocks\GeneratedMockRegistry\returnTypeFor().

Here is the call graph for this function:

◆ exportValue()

ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder::exportValue ( mixed $value )

private

Definition at line 543 of file AbstractLightMockBuilder.php.

                                              : string
    {
        return var_export($value, true);
    }

Referenced by ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\buildParameter().

Here is the caller graph for this function:

◆ generate()

ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder::generate	(	string	$type,
		string	$generated_class
	)

private

Returns: array<string, array<string, mixed>> method name => normalized return type

Definition at line 104 of file AbstractLightMockBuilder.php.

                                                                    : array
    {
        if (!class_exists($type) && !interface_exists($type)) {
            throw new LogicException("Unknown class or interface: {$type}");
        }
 
        $ref = new ReflectionClass($type);
 
        if ($ref->isEnum()) {
            throw new LogicException("Enums cannot be mocked: {$type}");
        }
 
        if ($ref->isTrait()) {
            throw new LogicException("Traits cannot be mocked directly: {$type}");
        }
 
        if ($ref->isFinal()) {
            throw new LogicException("Final classes cannot be mocked without extensions/code rewriting: {$type}");
        }
 
        $method_code = [];
        $return_map = [];
 
        if ($ref->isInterface()) {
            foreach ($ref->getMethods() as $method) {
                if ($method->returnsReference()) {
                    throw new LogicException(
                        "Methods returning by reference are not supported by this lightweight mock builder: "
                        . $ref->getName() . "::" . $method->getName()
                    );
                }
 
                $method_code[] = $this->buildMethod($method, $return_map);
            }
 
            $header = "class {$generated_class} implements \\" . ltrim($type, '\\');
        } else {
            // only add an empty constructor if the parent constructor is not final
            $constructor = $ref->getConstructor();
            if ($constructor === null || !$constructor->isFinal()) {
                $method_code[] = "public function __construct(...\$__args) {}";
            }
 
            foreach ($ref->getMethods() as $method) {
                if (!$this->shouldOverride($method)) {
                    continue;
                }
 
                if ($method->returnsReference()) {
                    throw new LogicException(
                        "Methods returning by reference are not supported by this lightweight mock builder: "
                        . $ref->getName() . "::" . $method->getName()
                    );
                }
 
                $method_code[] = $this->buildMethod($method, $return_map);
            }
 
            $header = "class {$generated_class} extends \\" . ltrim($type, '\\');
        }
 
        $code = <<<PHP
namespace ILIAS\Component\Dependencies\Mocks;
 
{$header}
{
    use MockObjectBehavior;
 
    %s
}
PHP;
 
        $code = sprintf($code, implode("\n\n", $method_code));
 
        $this->loadGeneratedCode($code, $generated_class);
 
        return $return_map;
    }

References ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\buildMethod(), ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\loadGeneratedCode(), ILIAS\Component\Dependencies\Mocks\MockObjectBehavior, and ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\shouldOverride().

Referenced by ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\createNormal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generatedClassName()

ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder::generatedClassName ( string $type )

private

Definition at line 538 of file AbstractLightMockBuilder.php.

                                                     : string
    {
        return 'Mock_' . md5($type);
    }

Referenced by ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\createNormal().

Here is the caller graph for this function:

◆ loadGeneratedCode()

ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder::loadGeneratedCode	(	string	$code,
		string	$generated_class
	)

abstractprotected

Reimplemented in ILIAS\Component\Dependencies\Mocks\EvalLightMockBuilder.

Referenced by ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\generate().

Here is the caller graph for this function:

◆ needsReturnTypeWillChange()

ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder::needsReturnTypeWillChange ( ReflectionMethod $method )

private

Definition at line 258 of file AbstractLightMockBuilder.php.

                                                                        : bool
    {
        if ($method->hasReturnType()) {
            return false;
        }
 
        if (method_exists($method, 'hasTentativeReturnType') && $method->hasTentativeReturnType()) {
            return true;
        }
 
        try {
            $prototype = $method->getPrototype();
 
            if ($prototype->hasReturnType()) {
                return false;
            }
 
            if (method_exists($prototype, 'hasTentativeReturnType') && $prototype->hasTentativeReturnType()) {
                return true;
            }
        } catch (\ReflectionException) {
            // No prototype available.
        }
 
        return false;
    }

Referenced by ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\buildMethodAttributes().

Here is the caller graph for this function:

◆ normalizeType()

ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder::normalizeType ( ?ReflectionType $type )

private

Returns: array<string, mixed>

Definition at line 408 of file AbstractLightMockBuilder.php.

                                                         : array
    {
        if ($type === null) {
            return ['kind' => 'none'];
        }
 
        if ($type instanceof ReflectionNamedType) {
            $name = $type->getName();
 
            if ($name === 'void') {
                return ['kind' => 'void'];
            }
 
            if ($name === 'never') {
                return ['kind' => 'never'];
            }
 
            return [
                'kind' => 'named',
                'name' => $name,
                'builtin' => $type->isBuiltin(),
                'nullable' => $type->allowsNull(),
            ];
        }
 
        if ($type instanceof ReflectionUnionType) {
            return [
                'kind' => 'union',
                'types' => array_map(
                    $this->normalizeType(...),
                    $type->getTypes()
                ),
            ];
        }
 
        if ($type instanceof ReflectionIntersectionType) {
            return [
                'kind' => 'intersection',
                'types' => array_map(
                    $this->normalizeType(...),
                    $type->getTypes()
                ),
            ];
        }
 
        throw new LogicException('Unsupported reflection type: ' . $type::class);
    }

References ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\normalizeType().

Referenced by ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\buildMethod(), ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\buildMethodBody(), and ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\normalizeType().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ renderType()

ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder::renderType ( ?ReflectionType $type )

private

Definition at line 367 of file AbstractLightMockBuilder.php.

                                                      : string
    {
        if ($type === null) {
            return '';
        }
 
        if ($type instanceof ReflectionNamedType) {
            $name = $type->getName();
            $prefix = !$type->isBuiltin() && $name !== 'self' && $name !== 'parent' && $name !== 'static'
                ? '\\'
                : '';
 
            if ($type->allowsNull() && $name !== 'mixed' && $name !== 'null') {
                return '?' . $prefix . $name;
            }
 
            return $prefix . $name;
        }
 
        if ($type instanceof ReflectionUnionType) {
            $parts = [];
            foreach ($type->getTypes() as $sub_type) {
                $parts[] = $this->renderType($sub_type);
            }
            return implode('|', $parts);
        }
 
        if ($type instanceof ReflectionIntersectionType) {
            $parts = [];
            foreach ($type->getTypes() as $sub_type) {
                $parts[] = $this->renderType($sub_type);
            }
            return implode('&', $parts);
        }
 
        throw new LogicException('Unsupported reflection type: ' . $type::class);
    }

References ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\renderType().

Referenced by ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\buildMethod(), ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\buildParameter(), and ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\renderType().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shouldOverride()

ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder::shouldOverride ( ReflectionMethod $method )

private

Definition at line 185 of file AbstractLightMockBuilder.php.

                                                             : bool
    {
        if ($method->isConstructor()) {
            return false;
        }
 
        if ($method->isDestructor()) {
            return false;
        }
 
        if ($method->isFinal()) {
            return false;
        }
 
        if ($method->isPrivate()) {
            return false;
        }
 
        if ($method->isStatic()) {
            // an abstract static method must be declared, otherwise the class cannot be generated
            return $method->isAbstract();
        }
        // only methods that can visibly be overridden in the target class or its parents
        if ($method->isPublic()) {
            return true;
        }
        if ($method->isProtected()) {
            return true;
        }
        return $method->isAbstract();
    }

Referenced by ILIAS\Component\Dependencies\Mocks\AbstractLightMockBuilder\generate().

Here is the caller graph for this function:

The documentation for this class was generated from the following file:

components/ILIAS/Component/src/Dependencies/Mocks/AbstractLightMockBuilder.php

Public Member Functions

Protected Member Functions

Private Member Functions

Detailed Description

Member Function Documentation

◆ buildMethod()

◆ buildMethodAttributes()

◆ buildMethodBody()

◆ buildParameter()

◆ buildParameterList()

◆ buildStaticMethodBody()

◆ create()

◆ createLazyShell()

◆ createNormal()

◆ defaultByMeta()

◆ defaultValueFor()

◆ exportValue()

◆ generate()

◆ generatedClassName()

◆ loadGeneratedCode()

◆ needsReturnTypeWillChange()

◆ normalizeType()

◆ renderType()

◆ shouldOverride()