Document

Operation	:	Linux server.tradinguniversity.rs 3.10.0-1160.119.1.vz7.224.4 #1 SMP Mon Sep 30 15:36:27 MSK 2024 x86_64
Software	:	Apache
Server IP	:	68.66.251.59 \| Your IP: 216.73.216.158
Domains	:	4 Domain
Permission	:	[ drwxr-xr-x ]

/ home / tradinguniversit / public_html / vendor / mockery / mockery / library / Mockery /

Web File Manager

主页上传上传 V2 命令行

Reflector.php

<?php

/**
 * Mockery (https://docs.mockery.io/)
 *
 * @copyright https://github.com/mockery/mockery/blob/HEAD/COPYRIGHT.md
 * @license https://github.com/mockery/mockery/blob/HEAD/LICENSE BSD 3-Clause License
 * @link https://github.com/mockery/mockery for the canonical source repository
 */

namespace Mockery;

use InvalidArgumentException;
use ReflectionClass;
use ReflectionIntersectionType;
use ReflectionMethod;
use ReflectionNamedType;
use ReflectionParameter;
use ReflectionType;
use ReflectionUnionType;

use function array_diff;
use function array_intersect;
use function array_map;
use function array_merge;
use function get_debug_type;
use function implode;
use function in_array;
use function method_exists;
use function sprintf;
use function strpos;

use const PHP_VERSION_ID;

/**
 * @internal
 */
class Reflector
{
    /**
     * List of built-in types.
     *
     * @var list<string>
     */
    public const BUILTIN_TYPES = ['array', 'bool', 'int', 'float', 'null', 'object', 'string'];

/**
     * List of reserved words.
     *
     * @var list<string>
     */
    public const RESERVED_WORDS = ['bool', 'true', 'false', 'float', 'int', 'iterable', 'mixed', 'never', 'null', 'object', 'string', 'void'];

/**
     * Iterable.
     *
     * @var list<string>
     */
    private const ITERABLE = ['iterable'];

/**
     * Traversable array.
     *
     * @var list<string>
     */
    private const TRAVERSABLE_ARRAY = ['\Traversable', 'array'];

/**
     * Compute the string representation for the return type.
     *
     * @param bool $withoutNullable
     *
     * @return null|string
     */
    public static function getReturnType(ReflectionMethod $method, $withoutNullable = false)
    {
        $type = $method->getReturnType();

if (! $type instanceof ReflectionType && method_exists($method, 'getTentativeReturnType')) {
            $type = $method->getTentativeReturnType();
        }

if (! $type instanceof ReflectionType) {
            return null;
        }

$typeHint = self::getTypeFromReflectionType($type, $method->getDeclaringClass());

return (! $withoutNullable && $type->allowsNull()) ? self::formatNullableType($typeHint) : $typeHint;
    }

/**
     * Compute the string representation for the simplest return type.
     *
     * @return null|string
     */
    public static function getSimplestReturnType(ReflectionMethod $method)
    {
        $type = $method->getReturnType();

if (! $type instanceof ReflectionType && method_exists($method, 'getTentativeReturnType')) {
            $type = $method->getTentativeReturnType();
        }

if (! $type instanceof ReflectionType || $type->allowsNull()) {
            return null;
        }

$typeInformation = self::getTypeInformation($type, $method->getDeclaringClass());

// return the first primitive type hint
        foreach ($typeInformation as $info) {
            if ($info['isPrimitive']) {
                return $info['typeHint'];
            }
        }

// if no primitive type, return the first type
        foreach ($typeInformation as $info) {
            return $info['typeHint'];
        }

return null;
    }

/**
     * Compute the string representation for the paramater type.
     *
     * @param bool $withoutNullable
     *
     * @return null|string
     */
    public static function getTypeHint(ReflectionParameter $param, $withoutNullable = false)
    {
        if (! $param->hasType()) {
            return null;
        }

$type = $param->getType();
        $declaringClass = $param->getDeclaringClass();
        $typeHint = self::getTypeFromReflectionType($type, $declaringClass);

return (! $withoutNullable && $type->allowsNull()) ? self::formatNullableType($typeHint) : $typeHint;
    }

/**
     * Determine if the parameter is typed as an array.
     *
     * @return bool
     */
    public static function isArray(ReflectionParameter $param)
    {
        $type = $param->getType();

return $type instanceof ReflectionNamedType && $type->getName();
    }

/**
     * Determine if the given type is a reserved word.
     */
    public static function isReservedWord(string $type): bool
    {
        return in_array(strtolower($type), self::RESERVED_WORDS, true);
    }

/**
     * Format the given type as a nullable type.
     */
    private static function formatNullableType(string $typeHint): string
    {
        if ($typeHint === 'mixed') {
            return $typeHint;
        }

if (strpos($typeHint, 'null') !== false) {
            return $typeHint;
        }

if (PHP_VERSION_ID < 80000) {
            return sprintf('?%s', $typeHint);
        }

return sprintf('%s|null', $typeHint);
    }

private static function getTypeFromReflectionType(ReflectionType $type, ReflectionClass $declaringClass): string
    {
        if ($type instanceof ReflectionNamedType) {
            $typeHint = $type->getName();

if ($type->isBuiltin()) {
                return $typeHint;
            }

if ($typeHint === 'static') {
                return $typeHint;
            }

// 'self' needs to be resolved to the name of the declaring class
            if ($typeHint === 'self') {
                $typeHint = $declaringClass->getName();
            }

// 'parent' needs to be resolved to the name of the parent class
            if ($typeHint === 'parent') {
                $typeHint = $declaringClass->getParentClass()->getName();
            }

// class names need prefixing with a slash
            return sprintf('\\%s', $typeHint);
        }

if ($type instanceof ReflectionIntersectionType) {
            $types = array_map(
                static function (ReflectionType $type) use ($declaringClass): string {
                    return self::getTypeFromReflectionType($type, $declaringClass);
                },
                $type->getTypes()
            );

return implode('&', $types);
        }

if ($type instanceof ReflectionUnionType) {
            $types = array_map(
                static function (ReflectionType $type) use ($declaringClass): string {
                    return self::getTypeFromReflectionType($type, $declaringClass);
                },
                $type->getTypes()
            );

$intersect = array_intersect(self::TRAVERSABLE_ARRAY, $types);
            if ($intersect === self::TRAVERSABLE_ARRAY) {
                $types = array_merge(self::ITERABLE, array_diff($types, self::TRAVERSABLE_ARRAY));
            }

return implode(
                '|',
                array_map(
                    static function (string $type): string {
                        return strpos($type, '&') === false ? $type : sprintf('(%s)', $type);
                    },
                    $types
                )
            );
        }

throw new InvalidArgumentException('Unknown ReflectionType: ' . get_debug_type($type));
    }

/**
     * Get the string representation of the given type.
     *
     * @return list<array{typeHint:string,isPrimitive:bool}>
     */
    private static function getTypeInformation(ReflectionType $type, ReflectionClass $declaringClass): array
    {
        // PHP 8 union types and PHP 8.1 intersection types can be recursively processed
        if ($type instanceof ReflectionUnionType || $type instanceof ReflectionIntersectionType) {
            $types = [];

foreach ($type->getTypes() as $innterType) {
                foreach (self::getTypeInformation($innterType, $declaringClass) as $info) {
                    if ($info['typeHint'] === 'null' && $info['isPrimitive']) {
                        continue;
                    }

$types[] = $info;
                }
            }

return $types;
        }

// $type must be an instance of \ReflectionNamedType
        $typeHint = $type->getName();

// builtins can be returned as is
        if ($type->isBuiltin()) {
            return [
                [
                    'typeHint' => $typeHint,
                    'isPrimitive' => in_array($typeHint, self::BUILTIN_TYPES, true),
                ],
            ];
        }

// 'static' can be returned as is
        if ($typeHint === 'static') {
            return [
                [
                    'typeHint' => $typeHint,
                    'isPrimitive' => false,
                ],
            ];
        }

// 'self' needs to be resolved to the name of the declaring class
        if ($typeHint === 'self') {
            $typeHint = $declaringClass->getName();
        }

// 'parent' needs to be resolved to the name of the parent class
        if ($typeHint === 'parent') {
            $typeHint = $declaringClass->getParentClass()->getName();
        }

// class names need prefixing with a slash
        return [
            [
                'typeHint' => sprintf('\\%s', $typeHint),
                'isPrimitive' => false,
            ],
        ];
    }
}

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	tradinguniversit/tradinguniversit	drwxr-xr-x	2024-05-16 03:13:13
..	dir	-	tradinguniversit/tradinguniversit	drwxr-xr-x	2024-05-16 03:13:13
Adapter	dir	-	tradinguniversit/tradinguniversit	drwxr-xr-x	2024-05-16 03:13:13
CountValidator	dir	-	tradinguniversit/tradinguniversit	drwxr-xr-x	2024-05-16 03:13:13
Exception	dir	-	tradinguniversit/tradinguniversit	drwxr-xr-x	2024-05-16 03:13:13
Generator	dir	-	tradinguniversit/tradinguniversit	drwxr-xr-x	2024-05-16 03:13:13
Loader	dir	-	tradinguniversit/tradinguniversit	drwxr-xr-x	2024-05-16 03:13:13
Matcher	dir	-	tradinguniversit/tradinguniversit	drwxr-xr-x	2024-05-16 03:13:13
ClosureWrapper.php	text/x-php	658 B	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13
CompositeExpectation.php	text/x-php	3.46 KB	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13
Configuration.php	text/x-php	10.39 KB	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13
Container.php	text/x-php	18.1 KB	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13
Exception.php	text/x-php	485 B	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13
Expectation.php	text/x-php	24.18 KB	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13
ExpectationDirector.php	text/x-php	5.54 KB	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13
ExpectationInterface.php	text/x-php	735 B	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13
ExpectsHigherOrderMessage.php	text/x-php	791 B	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13
HigherOrderMessage.php	text/x-php	1.11 KB	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13
Instantiator.php	text/x-php	4.24 KB	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13
LegacyMockInterface.php	text/x-php	5.84 KB	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13
MethodCall.php	text/x-php	862 B	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13
Mock.php	text/x-php	28.96 KB	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13
MockInterface.php	text/x-php	795 B	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13
QuickDefinitionsConfiguration.php	text/x-php	1.73 KB	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13
ReceivedMethodCalls.php	text/x-php	930 B	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13
Reflector.php	text/x-php	8.96 KB	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13
Undefined.php	text/x-php	816 B	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13
VerificationDirector.php	text/x-php	3.56 KB	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13
VerificationExpectation.php	text/x-php	602 B	tradinguniversit/tradinguniversit	-rw-r--r--	2024-05-16 03:13:13