Psalm\PluginRegistrationSocket

Complexity

Total Complexity

26

Size/Duplication

Total Lines	121
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	15

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	addStubFile()	0	4	1
F	registerHooksFromClass()	0	94	24

<?php
namespace Psalm;

use Psalm\Plugin\Hook;
use Psalm\Plugin\RegistrationInterface;
use function class_exists;
use function is_subclass_of;

class PluginRegistrationSocket implements RegistrationInterface
{
    /** @var Config */
    private $config;

    /** @var Codebase */
    private $codebase;

    /**
     * @internal
     */
    public function __construct(Config $config, Codebase $codebase)
    {
        $this->config = $config;
        $this->codebase = $codebase;
    }

    /** @return void */
    public function addStubFile(string $file_name)
    {
        $this->config->addStubFile($file_name);
    }

    /**
     * @return void
     */
    public function registerHooksFromClass(string $handler)
    {
        if (!class_exists($handler, false)) {
            throw new \InvalidArgumentException('Plugins must be loaded before registration');
        }

        if (is_subclass_of($handler, Hook\AfterMethodCallAnalysisInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\AfterMethodCallAnalysisInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->config->after_method_checks[$handler] = $handler;
        }

        if (is_subclass_of($handler, Hook\AfterFunctionCallAnalysisInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\AfterFunctionCallAnalysisInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->config->after_function_checks[$handler] = $handler;
        }

        if (is_subclass_of($handler, Hook\AfterEveryFunctionCallAnalysisInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\AfterEveryFunctionCallAnalysisInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->config->after_every_function_checks[$handler] = $handler;
        }

        if (is_subclass_of($handler, Hook\AfterExpressionAnalysisInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\AfterExpressionAnalysisInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->config->after_expression_checks[$handler] = $handler;
        }

        if (is_subclass_of($handler, Hook\AfterStatementAnalysisInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\AfterStatementAnalysisInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->config->after_statement_checks[$handler] = $handler;
        }

        if (is_subclass_of($handler, Hook\AfterClassLikeExistenceCheckInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\AfterClassLikeExistenceCheckInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->config->after_classlike_exists_checks[$handler] = $handler;
        }

        if (is_subclass_of($handler, Hook\AfterClassLikeAnalysisInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\AfterClassLikeAnalysisInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->config->after_classlike_checks[$handler] = $handler;
        }

        if (is_subclass_of($handler, Hook\AfterClassLikeVisitInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\AfterClassLikeVisitInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->config->after_visit_classlikes[$handler] = $handler;
        }

        if (is_subclass_of($handler, Hook\AfterCodebasePopulatedInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\AfterCodebasePopulatedInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->config->after_codebase_populated[$handler] = $handler;
        }

        if (is_subclass_of($handler, Hook\PropertyExistenceProviderInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\PropertyExistenceProviderInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->codebase->properties->property_existence_provider->registerClass($handler);
        }

        if (is_subclass_of($handler, Hook\PropertyVisibilityProviderInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\PropertyVisibilityProviderInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->codebase->properties->property_visibility_provider->registerClass($handler);
        }

        if (is_subclass_of($handler, Hook\PropertyTypeProviderInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\PropertyTypeProviderInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->codebase->properties->property_type_provider->registerClass($handler);
        }

        if (is_subclass_of($handler, Hook\MethodExistenceProviderInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\MethodExistenceProviderInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->codebase->methods->existence_provider->registerClass($handler);
        }

        if (is_subclass_of($handler, Hook\MethodVisibilityProviderInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\MethodVisibilityProviderInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->codebase->methods->visibility_provider->registerClass($handler);
        }

        if (is_subclass_of($handler, Hook\MethodReturnTypeProviderInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\MethodReturnTypeProviderInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->codebase->methods->return_type_provider->registerClass($handler);
        }

        if (is_subclass_of($handler, Hook\MethodParamsProviderInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\MethodParamsProviderInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->codebase->methods->params_provider->registerClass($handler);
        }

        if (is_subclass_of($handler, Hook\FunctionExistenceProviderInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\FunctionExistenceProviderInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->codebase->functions->existence_provider->registerClass($handler);
        }

        if (is_subclass_of($handler, Hook\FunctionParamsProviderInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\FunctionParamsProviderInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->codebase->functions->params_provider->registerClass($handler);
        }

        if (is_subclass_of($handler, Hook\FunctionReturnTypeProviderInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\FunctionReturnTypeProviderInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->codebase->functions->return_type_provider->registerClass($handler);
        }

        if (is_subclass_of($handler, Hook\AfterAnalysisInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\AfterAnalysisInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->config->after_analysis[$handler] = $handler;
        }

        if (is_subclass_of($handler, Hook\StringInterpreterInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\StringInterpreterInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->config->string_interpreters[$handler] = $handler;
        }

        if (is_subclass_of($handler, Hook\AfterFunctionLikeAnalysisInterface::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Psalm\Plugin\Hook\AfterFunctionLikeAnalysisInterface::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $this->config->after_functionlike_checks[$handler] = $handler;
        }
    }
}