VocabularyAnnotationInaccessibleTarget::findTarget()

Complexity

Conditions	15
Paths	13

Size

Total Lines	86
Code Lines	62

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

<?php
    protected function findTarget(
        ValidationContext $context,
        \AlgoWeb\ODataMetadata\Interfaces\IVocabularyAnnotatable $target
    ): bool {
        $foundTarget = false;
        $entityContainer = $target;
        if ($entityContainer instanceof IEntityContainer) {
            $foundTarget = ($context->getModel()->findEntityContainer($entityContainer->FullName()) != null);
            return $foundTarget;
        }
        $entitySet = $target;
        if ($entitySet instanceof IEntitySet) {
            $container = $entitySet->getContainer();
            if ($container != null && $container instanceof IEntityContainer) {
                $foundTarget = ($container->findEntitySet($entitySet->getName()) != null);

It seems like $entitySet->getName() can also be of type null; however, parameter $setName of AlgoWeb\ODataMetadata\Interfaces\IEntityContainer::findEntitySet() does only seem to accept string, maybe add an additional type check?

                return $foundTarget;
            }
            return false;
        }
        $schemaType = $target;
        if ($schemaType instanceof ISchemaType) {
            $foundTarget = ($context->getModel()->FindType($schemaType->FullName()) != null);
            return $foundTarget;
        }
        $term = $target;
        if ($term instanceof ITerm) {
            $foundTarget = ($context->getModel()->FindValueTerm($term->FullName()) != null);
            return $foundTarget;
        }
        $function = $target;
        if ($function instanceof IFunction) {
            $foundTarget = count($context->getModel()->FindFunctions($function->FullName())) > 0;
            return $foundTarget;
        }
        $functionImport = $target;
        EdmUtil::checkArgumentNull($functionImport->getName(), 'functionImport->getName');

The method getName() does not exist on AlgoWeb\ODataMetadata\Interfaces\IVocabularyAnnotatable. It seems like you code against a sub-type of said class. However, the method does not exist in AlgoWeb\ODataMetadata\Library\Internal\Bad\BadElement or AlgoWeb\ODataMetadata\Library\Internal\Bad\BadType or AlgoWeb\ODataMetadata\Library\Internal\Bad\BadPrimitiveValue or AlgoWeb\ODataMetadata\Library\Internal\Bad\BadEntityReferenceType or AlgoWeb\ODataMetadata\Library\Internal\Bad\BadCollectionType or AlgoWeb\ODataMetadata\Library\Internal\Bad\BadStructuredType or AlgoWeb\ODataMetadata\Library\Internal\Bad\BadRowType. Are you sure you never get one of those?

        if ($functionImport instanceof IFunctionImport) {
            $funcName = $functionImport->getName();
            $foundTarget = count($functionImport->getContainer()->findFunctionImports($funcName)) > 0;
            return $foundTarget;
        }
        $typeProperty = $target;
        if ($typeProperty instanceof IProperty) {
            $declaringType = $typeProperty->getDeclaringType();
            assert($declaringType instanceof ISchemaType);
            $declaringTypeFullName = EdmUtil::FullyQualifiedName($declaringType);
            EdmUtil::checkArgumentNull($declaringTypeFullName, 'declaringTypeFullName');
            EdmUtil::checkArgumentNull($typeProperty->getName(), 'typeProperty->getName');
            $modelType = $context->getModel()->FindType($declaringTypeFullName);
            if ($modelType !== null && $modelType instanceof IStructuredType) {
                // If we can find a structured type with this name in the model check if it
                // has a property with this name
                $foundTarget = ($modelType->findProperty($typeProperty->getName()) != null);
                return $foundTarget;
            }
            return false;
        }
        $functionParameter = $target;
        if ($functionParameter instanceof IFunctionParameter) {
            $paramName = $functionParameter->getName();
            $declaringFunction = $functionParameter->getDeclaringFunction();
            switch (true) {
                case $declaringFunction instanceof IFunction:
                    $functions = $context->getModel()->FindFunctions($declaringFunction->FullName());
                    break;
                case $declaringFunction instanceof IFunctionImport:
                    $container = $declaringFunction->getContainer();
                    assert($container instanceof IEntityContainer);
                    $functions = $container->findFunctionImports($declaringFunction->getName());

It seems like $declaringFunction->getName() can also be of type null; however, parameter $functionName of AlgoWeb\ODataMetadata\Interfaces\IEntityContainer::findFunctionImports() does only seem to accept string, maybe add an additional type check?

                    break;
                default:
                    return false;
            }

            // For all functions with this name declared in the model check if it has
            // a parameter with this name
            return 0 < count(array_filter($functions, function (IFunctionBase $func) use ($paramName) {
                return null !== $func->findParameter($paramName);

It seems like $paramName can also be of type null; however, parameter $name of AlgoWeb\ODataMetadata\Interfaces\IFunctionBase::findParameter() does only seem to accept string, maybe add an additional type check?

            }));
        } else {
            // Only validate annotations targeting elements that can be found via the
            // model API.
            // E.g. annotations targeting annotations will not be valid without this branch.
            $foundTarget = true;
        }
        return $foundTarget;
    }