Humbug\PhpScoper\Symbol\EnrichedReflector

Complexity

Total Complexity

41

Size/Duplication

Total Lines	149
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	isFunctionInternal()	0	3	1
A	isExposedClass()	0	10	5
A	isExcludedNamespace()	0	5	1
A	belongsToExcludedNamespace()	0	5	1
A	belongsToGlobalNamespace()	0	5	1
A	isFunctionExcluded()	0	4	2
A	belongsToExposedNamespace()	0	5	1
A	isExposedFunction()	0	10	5
A	_isExposedClassFromGlobalNamespace()	0	4	2
A	isConstantInternal()	0	3	1
A	_isExposedFunctionFromGlobalNamespace()	0	4	2
A	isConstantExcluded()	0	6	2
A	isExposedClassFromGlobalNamespace()	0	5	3
A	isClassInternal()	0	3	1
A	isClassExcluded()	0	4	2
A	isExposedFunctionFromGlobalNamespace()	0	5	3
A	__construct()	0	6	1
A	isExposedConstant()	0	14	5
A	isExposedConstantFromGlobalNamespace()	0	4	2

<?php

declare(strict_types=1);

/*
 * This file is part of the humbug/php-scoper package.
 *
 * Copyright (c) 2017 Théo FIDRY <theo.fidry@gmail.com>,
 *                    Pádraic Brady <padraic.brady@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Humbug\PhpScoper\Symbol;

use Humbug\PhpScoper\Configuration\SymbolsConfiguration;
use function ltrim;
use function str_contains;
use function strpos;

/**
 * Combines the API or the "traditional" reflector which is about to tell
 * if a symbol is internal or not with the more PHP-Scoper specific exposed
 * API.
 */
final class EnrichedReflector
{
    private Reflector $reflector;
    private SymbolsConfiguration $symbolsConfiguration;

    public function __construct(
        Reflector $reflector,
        SymbolsConfiguration $symbolsConfiguration
    ) {
        $this->reflector = $reflector;
        $this->symbolsConfiguration = $symbolsConfiguration;
    }

    public function belongsToExcludedNamespace(string $name): bool
    {
        return $this->symbolsConfiguration
            ->getExcludedNamespaces()
            ->belongsToRegisteredNamespace($name);
    }

    private function belongsToExposedNamespace(string $name): bool
    {
        return $this->symbolsConfiguration
            ->getExposedNamespaces()
            ->belongsToRegisteredNamespace($name);
    }

    public function isFunctionInternal(string $name): bool
    {
        return $this->reflector->isFunctionInternal($name);
    }

    public function isFunctionExcluded(string $name): bool
    {
        return $this->reflector->isFunctionInternal($name)
            || $this->belongsToExcludedNamespace($name);
    }

    public function isClassInternal(string $name): bool
    {
        return $this->reflector->isClassInternal($name);
    }

    public function isClassExcluded(string $name): bool
    {
        return $this->reflector->isClassInternal($name)
            || $this->belongsToExcludedNamespace($name);
    }

    public function isConstantInternal(string $name): bool
    {
        return $this->reflector->isConstantInternal($name);
    }

    public function isConstantExcluded(string $name): bool
    {
        // TODO: double check not sure that internal should mean excluded for constants
        // TODO: review as not used at the moment
        return $this->reflector->isConstantInternal($name)
            || $this->belongsToExcludedNamespace($name);
    }

    public function isExposedFunction(string $resolvedName): bool
    {
        return !$this->belongsToExcludedNamespace($resolvedName)
            && !$this->reflector->isFunctionInternal($resolvedName)
            && (
                $this->_isExposedFunctionFromGlobalNamespace($resolvedName)
                || $this->symbolsConfiguration
                    ->getExposedFunctions()
                    ->matches($resolvedName)
                || $this->belongsToExposedNamespace($resolvedName)
            );
    }

    public function isExposedFunctionFromGlobalNamespace(string $resolvedName): bool
    {
        return !$this->belongsToExcludedNamespace($resolvedName)
            && !$this->reflector->isFunctionInternal($resolvedName)
            && $this->_isExposedFunctionFromGlobalNamespace($resolvedName);
    }

    public function isExposedClass(string $resolvedName): bool
    {
        return !$this->belongsToExcludedNamespace($resolvedName)
            && !$this->reflector->isClassInternal($resolvedName)
            && (
                $this->_isExposedClassFromGlobalNamespace($resolvedName)
                || $this->symbolsConfiguration
                    ->getExposedClasses()
                    ->matches($resolvedName)
                || $this->belongsToExposedNamespace($resolvedName)
            );
    }

    public function isExposedClassFromGlobalNamespace(string $resolvedName): bool
    {
        return !$this->belongsToExcludedNamespace($resolvedName)
            && !$this->reflector->isClassInternal($resolvedName)
            && $this->_isExposedClassFromGlobalNamespace($resolvedName);
    }

    public function isExposedConstant(string $name): bool
    {
        // Special case: internal constants must be treated as exposed symbols.
        //
        // Example: when declaring a new internal constant for compatibility
        // reasons, it must remain un-prefixed.
        return !$this->belongsToExcludedNamespace($name)
            && (
                $this->reflector->isConstantInternal($name)
                || $this->isExposedConstantFromGlobalNamespace($name)
                || $this->symbolsConfiguration
                    ->getExposedConstants()
                    ->matches($name)
                || $this->belongsToExposedNamespace($name)
            );
    }

    public function isExposedConstantFromGlobalNamespace(string $constantName): bool
    {
        // TODO: leverage belongsToGlobalNamespace
        return $this->symbolsConfiguration->shouldExposeGlobalConstants() && !strpos($constantName, '\\');
    }

    public function isExcludedNamespace(string $name): bool
    {
        return $this->symbolsConfiguration
            ->getExcludedNamespaces()
            ->isRegisteredNamespace($name);
    }

    private function _isExposedFunctionFromGlobalNamespace(string $functionName): bool
    {
        // TODO: leverage belongsToGlobalNamespace
        return $this->symbolsConfiguration->shouldExposeGlobalFunctions() && !strpos($functionName, '\\');
    }

    public function _isExposedClassFromGlobalNamespace(string $className): bool
    {
        // TODO: leverage belongsToGlobalNamespace
        return $this->symbolsConfiguration->shouldExposeGlobalClasses() && !strpos($className, '\\');
    }

    public function belongsToGlobalNamespace(string $symbolName): bool
    {
        return !str_contains(
            ltrim($symbolName, '\\'),
            '\\',
        );
    }
}