InterfaceValidator::collectErrors() - Code Metrics - Inspection of "Fix function name case" - c-harris/ODataMetadata - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — master (#57)

by Alex

created 2020-07-25 14:45 UTC

InterfaceValidator::collectErrors() A

↳ Parent: InterfaceValidator

Complexity

Conditions	3
Paths	3

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	4
nc	3
nop	2
dl	0
loc	8
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);


namespace AlgoWeb\ODataMetadata\Edm\Validation\Internal;

use AlgoWeb\ODataMetadata\Edm\Validation\EdmError;
use AlgoWeb\ODataMetadata\Edm\Validation\EdmErrorCode;
use AlgoWeb\ODataMetadata\Edm\Validation\Internal\InterfaceValidator\VisitorBase;
use AlgoWeb\ODataMetadata\Edm\Validation\Internal\InterfaceValidator\VisitorOfT;
use AlgoWeb\ODataMetadata\Edm\Validation\ObjectLocation;
use AlgoWeb\ODataMetadata\Edm\Validation\ValidationContext;
use AlgoWeb\ODataMetadata\Edm\Validation\ValidationRule;
use AlgoWeb\ODataMetadata\Edm\Validation\ValidationRuleSet;
use AlgoWeb\ODataMetadata\EdmUtil;
use AlgoWeb\ODataMetadata\Exception\InvalidOperationException;
use AlgoWeb\ODataMetadata\Interfaces\Annotations\IDirectValueAnnotation;
use AlgoWeb\ODataMetadata\Interfaces\ICheckable;
use AlgoWeb\ODataMetadata\Interfaces\IEdmElement;
use AlgoWeb\ODataMetadata\Interfaces\IEdmValidCoreModelElement;
use AlgoWeb\ODataMetadata\Interfaces\ILocatable;
use AlgoWeb\ODataMetadata\Interfaces\ILocation;
use AlgoWeb\ODataMetadata\Interfaces\IModel;
use AlgoWeb\ODataMetadata\Interfaces\IPrimitiveType;
use AlgoWeb\ODataMetadata\Interfaces\IPrimitiveTypeReference;
use AlgoWeb\ODataMetadata\Interfaces\ITypeReference;
use AlgoWeb\ODataMetadata\StringConst;

class InterfaceValidator
{
    private static $interfaceVisitors = null;

    private static $concreteTypeInterfaceVisitors = [];

    private static function getInterfaceVisitors(): iterable
    {
        return self::$interfaceVisitors ?? self::$interfaceVisitors = self::createInterfaceVisitorsMap();
    }

    /**
     * @var array
     */
    private $visited = [];
    /**
     * @var array
     */
    private $visitedBad = [];
    /**
     * @var array
     */
    private $danglingReferences = [];
    /**
     * @var array|null
     */
    private $skipVisitation;
    /**
     * @var bool
     */
    private $validateDirectValueAnnotations;
    /**
     * @var IModel|null
     */
    private $model;

    private function __construct(?iterable $skipVisitation, ?IModel $model, bool $validateDirectValueAnnotations)
    {
        $this->skipVisitation                 = iterable_to_array($skipVisitation);
        $this->model                          = $model;
        $this->validateDirectValueAnnotations = $validateDirectValueAnnotations;
    }

    /**
     * @param  IModel               $model
     * @param  ValidationRuleSet    $semanticRuleSet
     * @throws \ReflectionException
     * @return iterable|EdmError[]
     */
    public static function validateModelStructureAndSemantics(IModel $model, ValidationRuleSet $semanticRuleSet): iterable
    {
        $modelValidator = new InterfaceValidator(null, $model, true);

        // Perform structural validation of the root object.
        $errors = iterable_to_array($modelValidator->validateStructure($model));

        // Then check references for structural integrity using separate validator (in order to avoid adding referenced objects to the this.visited).
        $referencesValidator              = new InterfaceValidator($modelValidator->visited, $model, false);
        $referencesToStructurallyValidate = $modelValidator->danglingReferences;
        while (count($referencesToStructurallyValidate) !== 0) {
            foreach ($referencesToStructurallyValidate as $reference) {
                $errors = array_merge(iterable_to_array($errors), $referencesValidator->validateStructure($reference));
            }

            $referencesToStructurallyValidate = $referencesValidator->danglingReferences;
        }
        $critical = array_filter($errors, [ValidationHelper::class, 'isInterfaceCritical']);
        // If there are any critical structural errors detected, then it is not safe to traverse the root object, so return the errors without further processing.
        if (count($critical) > 0) {
            return $errors;
        }

        // If the root object is structurally sound, apply validation rules to the visited objects that are not known to be bad.
        $semanticValidationContext = new ValidationContext(
            $model,
            function (IEdmElement $item) use ($modelValidator, $referencesValidator): bool {
                return in_array($item, $modelValidator->visitedBad) || in_array($item, $referencesValidator->visitedBad);
            }
        );
        $concreteTypeSemanticInterfaceVisitors = [];
        foreach ($modelValidator->visited as $item) {
            if (!in_array($item, $modelValidator->visitedBad)) {
                /** * @var ValidationRule $rule */
                foreach (self::getSemanticInterfaceVisitorsForObject(
                    get_class($item),
                    $semanticRuleSet,
                    $concreteTypeSemanticInterfaceVisitors
                ) as $rule) {
                    $rule($semanticValidationContext, $item);
                }
            }
        }

        $errors = array_merge($errors, $semanticValidationContext->getErrors());
        return $errors;
    }

    /**
     * @param  IEdmElement         $item
     * @return iterable|EdmError[]
     */
    public static function getStructuralErrors(IEdmElement $item): iterable
    {
        $model               = $item instanceof IModel ? $item : null;
        $structuralValidator = new InterfaceValidator(null, $model, $model !== null);
        return $structuralValidator->validateStructure($item);
    }

    /**
     * @return iterable|array<string, VisitorBase>
     */
    private static function createInterfaceVisitorsMap(): iterable
    {
        $map    = [];
        $handle = opendir('.');
        if (false !== $handle) {
            while (false !== ($entry = readdir($handle))) {
                /** @var string $name */
                $name = substr($entry, 0, -4);
                $ext  = substr($entry, -4);
                if ($entry === '.' || $entry === '..' || is_dir($entry) || $ext !== '.php' || empty($ext)) {
                    continue;
                }
                if ($name === 'VisitorBase' || $name === 'VisitorOfT') {
                    continue;
                }
                $class = __CLASS__ . '\\' . $name;
                /** @var VisitorOfT $instance */
                $instance                  = new $class();
                $map[$instance->forType()] = $instance;
            }
        }
        return $map;
    }

    /**
     * @param  string                 $objectType
     * @return iterable|VisitorBase[]
     */
    private static function computeInterfaceVisitorsForObject(string $objectType): iterable
    {
        $visitors = [];
        foreach (class_implements($objectType) as $type) {
            $visitor = null;
            if (isset(self::getInterfaceVisitors()[$type])) {
                $visitor    = self::getInterfaceVisitors()[$type];
                $visitors[] = $visitor;
            }
        }

        return $visitors;
    }

    private function getInterfaceVisitorsForObject(string $objectType): iterable
    {
        $visitors = [];
        if (!isset(self::$concreteTypeInterfaceVisitors[$objectType])) {
            $visitors                                         = self::computeInterfaceVisitorsForObject($objectType);
            self::$concreteTypeInterfaceVisitors[$objectType] = $visitors;
        }

        return $visitors;
    }

    public static function createPropertyMustNotBeNullError($item, string $propertyName): EdmError
    {
        return new EdmError(
            self::getLocation($item),
            EdmErrorCode::InterfaceCriticalPropertyValueMustNotBeNull(),
            StringConst::EdmModel_Validator_Syntactic_PropertyMustNotBeNull(get_class($item), $propertyName)
        );
    }

    public static function createEnumPropertyOutOfRangeError($item, $enumValue, string $propertyName): EdmError
    {
        return new EdmError(
            self::getLocation($item),
            EdmErrorCode::InterfaceCriticalEnumPropertyValueOutOfRange(),
            StringConst::EdmModel_Validator_Syntactic_EnumPropertyValueOutOfRange(get_class($item), $propertyName, get_class($enumValue), $enumValue)
        );
    }

    public static function checkForInterfaceKindValueMismatchError($item, $kind, string $propertyName, string $interface): ?EdmError
    {
        // If object implements an expected interface, return no error.
        if (in_array($interface, class_implements($item))) {
            return null;
        }

        return new EdmError(
            self::getLocation($item),
            EdmErrorCode::InterfaceCriticalKindValueMismatch(),
            StringConst::EdmModel_Validator_Syntactic_InterfaceKindValueMismatch($kind, get_class($item), $propertyName, $interface)
        );
    }

    public static function createInterfaceKindValueUnexpectedError($item, $kind, string $propertyName): EdmError
    {
        return new EdmError(
            self::getLocation($item),
            EdmErrorCode::InterfaceCriticalKindValueUnexpected(),
            StringConst::EdmModel_Validator_Syntactic_InterfaceKindValueUnexpected($kind, get_class($item), $propertyName)
        );
    }

    public static function createTypeRefInterfaceTypeKindValueMismatchError(ITypeReference $item): EdmError
    {
        EdmUtil::checkArgumentNull($item->getDefinition(), 'item.Definition');
        return new EdmError(
            self::getLocation($item),
            EdmErrorCode::InterfaceCriticalKindValueMismatch(),
            StringConst::EdmModel_Validator_Syntactic_TypeRefInterfaceTypeKindValueMismatch(get_class($item), $item->getDefinition()->getTypeKind()->getKey())
        );
    }

    public static function createPrimitiveTypeRefInterfaceTypeKindValueMismatchError(IPrimitiveTypeReference $item): EdmError
    {
        $definition = $item->getDefinition();
        if (!$definition instanceof IPrimitiveType) {
            throw new InvalidOperationException('item.Definition is IEdmPrimitiveType');
        }
        return new EdmError(
            self::getLocation($item),
            EdmErrorCode::InterfaceCriticalKindValueMismatch(),
            StringConst::EdmModel_Validator_Syntactic_TypeRefInterfaceTypeKindValueMismatch(get_class($item), $definition->getPrimitiveKind()->getKey())
        );
    }

    public static function processEnumerable($item, ?iterable $enumerable, string $propertyName, array &$targetList, array &$errors): void
    {
        if (null === $enumerable) {
            self::collectErrors(self::createPropertyMustNotBeNullError($item, $propertyName), $errors);
        } else {
            foreach ($enumerable as $enumMember) {
                if (null !== $enumMember) {
                    $targetList[] = $enumMember;
                } else {
                    self::collectErrors(
                        new EdmError(
                            self::getLocation($item),
                            EdmErrorCode::InterfaceCriticalEnumerableMustNotHaveNullElements(),
                            StringConst::EdmModel_Validator_Syntactic_EnumerableMustNotHaveNullElements(get_class($item), $propertyName)
                        ),
                        $errors
                    );
                    break;
                }
            }
        }
    }

    public static function collectErrors(?EdmError $newError, ?array &$errors): void
    {
        if ($newError != null) {
            if ($errors == null) {
                $errors = [];
            }

            $errors[] = $newError;
        }
    }

    public static function isCheckableBad($element): bool
    {
        return $element instanceof ICheckable && null !== $element->getErrors() && count($element->getErrors()) > 0;
    }

    public static function getLocation($item): ILocation
    {
        return $item instanceof ILocatable && null !== $item->getLocation() ? $item->getLocation() : new ObjectLocation($item);
    }

    /**
     * @param  string                    $objectType
     * @param  ValidationRuleSet         $ruleSet
     * @param  array                     $concreteTypeSemanticInterfaceVisitors
     * @return iterable|ValidationRule[]
     */
    private static function getSemanticInterfaceVisitorsForObject(string $objectType, ValidationRuleSet $ruleSet, array &$concreteTypeSemanticInterfaceVisitors): iterable
    {
        $visitors = null;
        if (!isset($concreteTypeSemanticInterfaceVisitors[$objectType])) {
            $visitors = [];
            foreach (class_implements($objectType) as $type) {
                $visitors = array_merge($visitors, $ruleSet->getRules($type));
            }

            $concreteTypeSemanticInterfaceVisitors[$objectType] = $visitors;
        }

        return $visitors;
    }

    /**
     * @param  mixed               $item
     * @return iterable|EdmError[]
     */
    private function validateStructure($item): iterable
    {
        if ($item instanceof IEdmValidCoreModelElement || in_array($item, $this->visited) || ($this->skipVisitation != null && in_array($item, $this->skipVisitation))) {
            // If we already visited this object, then errors (if any) have already been reported.
            return [];
        }

        $this->visited[] = $item;
        if (in_array($item, $this->danglingReferences)) {
            // If this edm element is visited, then it is no longer a dangling reference.
            $index = array_search($item, $this->danglingReferences);
            unset($this->danglingReferences[$index]);
        }

        //// First pass: collect immediate errors for each interface and collect followup objects for the second pass.

        $immediateErrors = null;
        $followup        = [];
        $references      = [];
        $visitors        = null;

        $visitors        = $this->getInterfaceVisitorsForObject(get_class($item));
        /** @var VisitorBase $visitor */
        foreach ($visitors as $visitor) {
            $errors = $visitor->visit($item, $followup, $references);

            // For performance reasons some visitors may return null errors enumerator.
            if ($errors != null) {
                /** @var EdmError $error */
                foreach ($errors as $error) {
                    if ($immediateErrors == null) {
                        $immediateErrors = [];
                    }

                    $immediateErrors[] = $error;
                }
            }
        }

        // End of the first pass: if there are immediate errors, return them without doing the second pass.
        if ($immediateErrors !== null) {
            $this->visitedBad[] = $item;
            return $immediateErrors;
        }

        //// Second pass: collect errors from followup objects.

        $followupErrors = [];

        // An element's direct value annotations are available only through a model,
        // and so are not found in a normal traversal.
        if ($this->validateDirectValueAnnotations) {
            if ($item instanceof IEdmElement) {
                $element = $item;
                EdmUtil::checkArgumentNull($this->model, 'this->model');
                foreach ($this->model->getDirectValueAnnotationsManager()->getDirectValueAnnotations($element) as $annotation) {
                    assert($annotation instanceof IDirectValueAnnotation);
                    $followupErrors = array_merge(
                        iterable_to_array($followupErrors),
                        iterable_to_array($this->validateStructure($annotation))
                    );
                }
            }
        }

        foreach ($followup as $followupItem) {
            $followupErrors = array_merge($followupErrors, $this->validateStructure($followupItem));
        }

        foreach ($references as $referencedItem) {
            $this->collectReference($referencedItem);
        }

        return $followupErrors;
    }

    private function collectReference($reference): void
    {
        if (!($reference instanceof IEdmValidCoreModelElement) &&
            !in_array($reference, $this->visited) &&
            ($this->skipVisitation == null || !in_array($reference, $this->skipVisitation))) {
            $this->danglingReferences[] = $reference;
        }
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5
6			namespace AlgoWeb\ODataMetadata\Edm\Validation\Internal;
7
8			use AlgoWeb\ODataMetadata\Edm\Validation\EdmError;
9			use AlgoWeb\ODataMetadata\Edm\Validation\EdmErrorCode;
10			use AlgoWeb\ODataMetadata\Edm\Validation\Internal\InterfaceValidator\VisitorBase;
11			use AlgoWeb\ODataMetadata\Edm\Validation\Internal\InterfaceValidator\VisitorOfT;
12			use AlgoWeb\ODataMetadata\Edm\Validation\ObjectLocation;
13			use AlgoWeb\ODataMetadata\Edm\Validation\ValidationContext;
14			use AlgoWeb\ODataMetadata\Edm\Validation\ValidationRule;
15			use AlgoWeb\ODataMetadata\Edm\Validation\ValidationRuleSet;
16			use AlgoWeb\ODataMetadata\EdmUtil;
17			use AlgoWeb\ODataMetadata\Exception\InvalidOperationException;
18			use AlgoWeb\ODataMetadata\Interfaces\Annotations\IDirectValueAnnotation;
19			use AlgoWeb\ODataMetadata\Interfaces\ICheckable;
20			use AlgoWeb\ODataMetadata\Interfaces\IEdmElement;
21			use AlgoWeb\ODataMetadata\Interfaces\IEdmValidCoreModelElement;
22			use AlgoWeb\ODataMetadata\Interfaces\ILocatable;
23			use AlgoWeb\ODataMetadata\Interfaces\ILocation;
24			use AlgoWeb\ODataMetadata\Interfaces\IModel;
25			use AlgoWeb\ODataMetadata\Interfaces\IPrimitiveType;
26			use AlgoWeb\ODataMetadata\Interfaces\IPrimitiveTypeReference;
27			use AlgoWeb\ODataMetadata\Interfaces\ITypeReference;
28			use AlgoWeb\ODataMetadata\StringConst;
29
30			class InterfaceValidator
31			{
32			private static $interfaceVisitors = null;
33
34			private static $concreteTypeInterfaceVisitors = [];
35
36			private static function getInterfaceVisitors(): iterable
37			{
38			return self::$interfaceVisitors ?? self::$interfaceVisitors = self::createInterfaceVisitorsMap();
39			}
40
41			/**
42			* @var array
43			*/
44			private $visited = [];
45			/**
46			* @var array
47			*/
48			private $visitedBad = [];
49			/**
50			* @var array
51			*/
52			private $danglingReferences = [];
53			/**
54			* @var array\|null
55			*/
56			private $skipVisitation;
57			/**
58			* @var bool
59			*/
60			private $validateDirectValueAnnotations;
61			/**
62			* @var IModel\|null
63			*/
64			private $model;
65
66			private function __construct(?iterable $skipVisitation, ?IModel $model, bool $validateDirectValueAnnotations)
67			{
68			$this->skipVisitation = iterable_to_array($skipVisitation);
69			$this->model = $model;
70			$this->validateDirectValueAnnotations = $validateDirectValueAnnotations;
71			}
72
73			/**
74			* @param IModel $model
75			* @param ValidationRuleSet $semanticRuleSet
76			* @throws \ReflectionException
77			* @return iterable\|EdmError[]
78			*/
79			public static function validateModelStructureAndSemantics(IModel $model, ValidationRuleSet $semanticRuleSet): iterable
80			{
81			$modelValidator = new InterfaceValidator(null, $model, true);
82
83			// Perform structural validation of the root object.
84			$errors = iterable_to_array($modelValidator->validateStructure($model));
85
86			// Then check references for structural integrity using separate validator (in order to avoid adding referenced objects to the this.visited).
87			$referencesValidator = new InterfaceValidator($modelValidator->visited, $model, false);
88			$referencesToStructurallyValidate = $modelValidator->danglingReferences;
89			while (count($referencesToStructurallyValidate) !== 0) {
90			foreach ($referencesToStructurallyValidate as $reference) {
91			$errors = array_merge(iterable_to_array($errors), $referencesValidator->validateStructure($reference));
92			}
93
94			$referencesToStructurallyValidate = $referencesValidator->danglingReferences;
95			}
96			$critical = array_filter($errors, [ValidationHelper::class, 'isInterfaceCritical']);
97			// If there are any critical structural errors detected, then it is not safe to traverse the root object, so return the errors without further processing.
98			if (count($critical) > 0) {
99			return $errors;
100			}
101
102			// If the root object is structurally sound, apply validation rules to the visited objects that are not known to be bad.
103			$semanticValidationContext = new ValidationContext(
104			$model,
105			function (IEdmElement $item) use ($modelValidator, $referencesValidator): bool {
106			return in_array($item, $modelValidator->visitedBad) \|\| in_array($item, $referencesValidator->visitedBad);
107			}
108			);
109			$concreteTypeSemanticInterfaceVisitors = [];
110			foreach ($modelValidator->visited as $item) {
111			if (!in_array($item, $modelValidator->visitedBad)) {
112			/** * @var ValidationRule $rule */
113			foreach (self::getSemanticInterfaceVisitorsForObject(
114			get_class($item),
115			$semanticRuleSet,
116			$concreteTypeSemanticInterfaceVisitors
117			) as $rule) {
118			$rule($semanticValidationContext, $item);
119			}
120			}
121			}
122
123			$errors = array_merge($errors, $semanticValidationContext->getErrors());
124			return $errors;
125			}
126
127			/**
128			* @param IEdmElement $item
129			* @return iterable\|EdmError[]
130			*/
131			public static function getStructuralErrors(IEdmElement $item): iterable
132			{
133			$model = $item instanceof IModel ? $item : null;
134			$structuralValidator = new InterfaceValidator(null, $model, $model !== null);
135			return $structuralValidator->validateStructure($item);
136			}
137
138			/**
139			* @return iterable\|array<string, VisitorBase>
140			*/
141			private static function createInterfaceVisitorsMap(): iterable
142			{
143			$map = [];
144			$handle = opendir('.');
145			if (false !== $handle) {
146			while (false !== ($entry = readdir($handle))) {
147			/** @var string $name */
148			$name = substr($entry, 0, -4);
149			$ext = substr($entry, -4);
150			if ($entry === '.' \|\| $entry === '..' \|\| is_dir($entry) \|\| $ext !== '.php' \|\| empty($ext)) {
151			continue;
152			}
153			if ($name === 'VisitorBase' \|\| $name === 'VisitorOfT') {
154			continue;
155			}
156			$class = __CLASS__ . '\\' . $name;
157			/** @var VisitorOfT $instance */
158			$instance = new $class();
159			$map[$instance->forType()] = $instance;
160			}
161			}
162			return $map;
163			}
164
165			/**
166			* @param string $objectType
167			* @return iterable\|VisitorBase[]
168			*/
169			private static function computeInterfaceVisitorsForObject(string $objectType): iterable
170			{
171			$visitors = [];
172			foreach (class_implements($objectType) as $type) {
173			$visitor = null;
174			if (isset(self::getInterfaceVisitors()[$type])) {
175			$visitor = self::getInterfaceVisitors()[$type];
176			$visitors[] = $visitor;
177			}
178			}
179
180			return $visitors;
181			}
182
183			private function getInterfaceVisitorsForObject(string $objectType): iterable
184			{
185			$visitors = [];
186			if (!isset(self::$concreteTypeInterfaceVisitors[$objectType])) {
187			$visitors = self::computeInterfaceVisitorsForObject($objectType);
188			self::$concreteTypeInterfaceVisitors[$objectType] = $visitors;
189			}
190
191			return $visitors;
192			}
193
194			public static function createPropertyMustNotBeNullError($item, string $propertyName): EdmError
195			{
196			return new EdmError(
197			self::getLocation($item),
198			EdmErrorCode::InterfaceCriticalPropertyValueMustNotBeNull(),
199			StringConst::EdmModel_Validator_Syntactic_PropertyMustNotBeNull(get_class($item), $propertyName)
200			);
201			}
202
203			public static function createEnumPropertyOutOfRangeError($item, $enumValue, string $propertyName): EdmError
204			{
205			return new EdmError(
206			self::getLocation($item),
207			EdmErrorCode::InterfaceCriticalEnumPropertyValueOutOfRange(),
208			StringConst::EdmModel_Validator_Syntactic_EnumPropertyValueOutOfRange(get_class($item), $propertyName, get_class($enumValue), $enumValue)
209			);
210			}
211
212			public static function checkForInterfaceKindValueMismatchError($item, $kind, string $propertyName, string $interface): ?EdmError
213			{
214			// If object implements an expected interface, return no error.
215			if (in_array($interface, class_implements($item))) {
216			return null;
217			}
218
219			return new EdmError(
220			self::getLocation($item),
221			EdmErrorCode::InterfaceCriticalKindValueMismatch(),
222			StringConst::EdmModel_Validator_Syntactic_InterfaceKindValueMismatch($kind, get_class($item), $propertyName, $interface)
223			);
224			}
225
226			public static function createInterfaceKindValueUnexpectedError($item, $kind, string $propertyName): EdmError
227			{
228			return new EdmError(
229			self::getLocation($item),
230			EdmErrorCode::InterfaceCriticalKindValueUnexpected(),
231			StringConst::EdmModel_Validator_Syntactic_InterfaceKindValueUnexpected($kind, get_class($item), $propertyName)
232			);
233			}
234
235			public static function createTypeRefInterfaceTypeKindValueMismatchError(ITypeReference $item): EdmError
236			{
237			EdmUtil::checkArgumentNull($item->getDefinition(), 'item.Definition');
238			return new EdmError(
239			self::getLocation($item),
240			EdmErrorCode::InterfaceCriticalKindValueMismatch(),
241			StringConst::EdmModel_Validator_Syntactic_TypeRefInterfaceTypeKindValueMismatch(get_class($item), $item->getDefinition()->getTypeKind()->getKey())
242			);
243			}
244
245			public static function createPrimitiveTypeRefInterfaceTypeKindValueMismatchError(IPrimitiveTypeReference $item): EdmError
246			{
247			$definition = $item->getDefinition();
248			if (!$definition instanceof IPrimitiveType) {
249			throw new InvalidOperationException('item.Definition is IEdmPrimitiveType');
250			}
251			return new EdmError(
252			self::getLocation($item),
253			EdmErrorCode::InterfaceCriticalKindValueMismatch(),
254			StringConst::EdmModel_Validator_Syntactic_TypeRefInterfaceTypeKindValueMismatch(get_class($item), $definition->getPrimitiveKind()->getKey())
255			);
256			}
257
258			public static function processEnumerable($item, ?iterable $enumerable, string $propertyName, array &$targetList, array &$errors): void
259			{
260			if (null === $enumerable) {
261			self::collectErrors(self::createPropertyMustNotBeNullError($item, $propertyName), $errors);
262			} else {
263			foreach ($enumerable as $enumMember) {
264			if (null !== $enumMember) {
265			$targetList[] = $enumMember;
266			} else {
267			self::collectErrors(
268			new EdmError(
269			self::getLocation($item),
270			EdmErrorCode::InterfaceCriticalEnumerableMustNotHaveNullElements(),
271			StringConst::EdmModel_Validator_Syntactic_EnumerableMustNotHaveNullElements(get_class($item), $propertyName)
272			),
273			$errors
274			);
275			break;
276			}
277			}
278			}
279			}
280
281			public static function collectErrors(?EdmError $newError, ?array &$errors): void
282			{
283			if ($newError != null) {
284			if ($errors == null) {
285			$errors = [];
286			}
287
288			$errors[] = $newError;
289			}
290			}
291
292			public static function isCheckableBad($element): bool
293			{
294			return $element instanceof ICheckable && null !== $element->getErrors() && count($element->getErrors()) > 0;
295			}
296
297			public static function getLocation($item): ILocation
298			{
299			return $item instanceof ILocatable && null !== $item->getLocation() ? $item->getLocation() : new ObjectLocation($item);
300			}
301
302			/**
303			* @param string $objectType
304			* @param ValidationRuleSet $ruleSet
305			* @param array $concreteTypeSemanticInterfaceVisitors
306			* @return iterable\|ValidationRule[]
307			*/
308			private static function getSemanticInterfaceVisitorsForObject(string $objectType, ValidationRuleSet $ruleSet, array &$concreteTypeSemanticInterfaceVisitors): iterable
309			{
310			$visitors = null;
311			if (!isset($concreteTypeSemanticInterfaceVisitors[$objectType])) {
312			$visitors = [];
313			foreach (class_implements($objectType) as $type) {
314			$visitors = array_merge($visitors, $ruleSet->getRules($type));
315			}
316
317			$concreteTypeSemanticInterfaceVisitors[$objectType] = $visitors;
318			}
319
320			return $visitors;
321			}
322
323			/**
324			* @param mixed $item
325			* @return iterable\|EdmError[]
326			*/
327			private function validateStructure($item): iterable
328			{
329			if ($item instanceof IEdmValidCoreModelElement \|\| in_array($item, $this->visited) \|\| ($this->skipVisitation != null && in_array($item, $this->skipVisitation))) {
330			// If we already visited this object, then errors (if any) have already been reported.
331			return [];
332			}
333
334			$this->visited[] = $item;
335			if (in_array($item, $this->danglingReferences)) {
336			// If this edm element is visited, then it is no longer a dangling reference.
337			$index = array_search($item, $this->danglingReferences);
338			unset($this->danglingReferences[$index]);
339			}
340
341			//// First pass: collect immediate errors for each interface and collect followup objects for the second pass.
342
343			$immediateErrors = null;
344			$followup = [];
345			$references = [];
346			$visitors = null;
			0 ignored issues – show Unused Code introduced 2020-06-30 09:53 UTC by Report Bug Copy Issue Report The assignment to `$visitors` is dead and can be removed. Loading history...
347			$visitors = $this->getInterfaceVisitorsForObject(get_class($item));
348			/** @var VisitorBase $visitor */
349			foreach ($visitors as $visitor) {
350			$errors = $visitor->visit($item, $followup, $references);
351
352			// For performance reasons some visitors may return null errors enumerator.
353			if ($errors != null) {
354			/** @var EdmError $error */
355			foreach ($errors as $error) {
356			if ($immediateErrors == null) {
357			$immediateErrors = [];
358			}
359
360			$immediateErrors[] = $error;
361			}
362			}
363			}
364
365			// End of the first pass: if there are immediate errors, return them without doing the second pass.
366			if ($immediateErrors !== null) {
367			$this->visitedBad[] = $item;
368			return $immediateErrors;
369			}
370
371			//// Second pass: collect errors from followup objects.
372
373			$followupErrors = [];
374
375			// An element's direct value annotations are available only through a model,
376			// and so are not found in a normal traversal.
377			if ($this->validateDirectValueAnnotations) {
378			if ($item instanceof IEdmElement) {
379			$element = $item;
380			EdmUtil::checkArgumentNull($this->model, 'this->model');
381			foreach ($this->model->getDirectValueAnnotationsManager()->getDirectValueAnnotations($element) as $annotation) {
382			assert($annotation instanceof IDirectValueAnnotation);
383			$followupErrors = array_merge(
384			iterable_to_array($followupErrors),
385			iterable_to_array($this->validateStructure($annotation))
386			);
387			}
388			}
389			}
390
391			foreach ($followup as $followupItem) {
392			$followupErrors = array_merge($followupErrors, $this->validateStructure($followupItem));
393			}
394
395			foreach ($references as $referencedItem) {
396			$this->collectReference($referencedItem);
397			}
398
399			return $followupErrors;
400			}
401
402			private function collectReference($reference): void
403			{
404			if (!($reference instanceof IEdmValidCoreModelElement) &&
405			!in_array($reference, $this->visited) &&
406			($this->skipVisitation == null \|\| !in_array($reference, $this->skipVisitation))) {
407			$this->danglingReferences[] = $reference;
408			}
409			}
410			}
411

c-harris / ODataMetadata

Pull Request — master (#57)

InterfaceValidator::collectErrors() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like