Merge pull request #38 from systopia/handling-of-referenced-data-with-ingored-error

dontub · web-flow · commit cfd10bb7ae88 · 2025-04-07T16:17:10.000+02:00
Fix handling of referenced data with ignored error
diff --git a/README.md b/README.md
@@ -41,10 +41,8 @@ The structure of the `$limitValidation` keyword is:
       "keyword": JSON Schema,
       "keywordValue": JSON Schema,
       "value": JSON Schema,
-      "propertyName": JSON Schema,
-      "propertyPath": JSON Schema,
-      "itemIndex": JSON Schema,
-      "validate": bool
+      "calculatedValueUsedViolatedData": boolean|null,
+      "validate": boolean
     }
   ],
   "schema": JSON Schema
@@ -56,11 +54,13 @@ The structure of the `$limitValidation` keyword is:
 If the schema at `condition` is matched, limited validation is performed. It is
 applied on the keywords at the same depth and the keywords below. If it's not
 set, the result of the condition evaluation on a higher level is used. If the
-`$limitValidation` keyword is not used at a higher level, `true` is used as
+`$limitValidation` keyword is not used at a higher level, `false` is used as
 fallback.
 
-Apart from `validate` all properties of a rule have the default value `true`.
-The default of `validate` is `false`.
+The properties of a rule have the following defaults:
+* `keyword`, `keywordValue`, `value`: `true`
+* `calculatedValueUsedViolatedData`: `null`
+* `validate`: `false`
 
 To the entries in `rules` the [default rules](#default-rules) are always
 appended. To prevent the execution of the default rules a rule with just the
@@ -80,7 +80,12 @@ The rule matching is done like this:
 * The value of the violated keyword is matched against the schema in `keywordValue`.
 * The invalid value is matched against the schema in `value`.
 
-If all schemas are matched, the rule is matched.
+All schemas must be matched for a rule to be matched. If
+`calculatedValueUsedViolatedData` is not `null`, the value has to be calculated
+(with the `$calculate` keyword) and must or must not have used violated data
+depending on the actual value of `calculatedValueUsedViolatedData`. Violated
+data is used, if the calculation references a value that has a validation error
+(including ignored ones).
 
 The keyword `schema` allows to specify a schema that is validated additionally,
 if the condition is matched. This allows for example to require some properties
@@ -150,6 +155,9 @@ The default rules are:
       ]
     }
   },
+  {
+    "calculatedValueUsedViolatedData": true
+  },
   {
     "validate": true
   }
@@ -162,7 +170,8 @@ The rules mean:
 2. No violation error, if the violated keyword is not `type` and the validated value is `false` or `""` (empty string).
 3. No violation error, if the validated keyword is one of:
    `minLength`, `minItems`, `minContains`, `minProperties`, `required`, `dependentRequired`
-4. Every other validation without limitation.
+4. No violation error, if value is calculated and calculation used data with violations (including ignored ones).
+5. Every other validation without limitation.
 
 ## Empty array to object conversion
 
diff --git a/src/Errors/ErrorCollectorUtil.php b/src/Errors/ErrorCollectorUtil.php
@@ -37,4 +37,25 @@ public static function setErrorCollector(ValidationContext $context, ErrorCollec
     {
         $context->setGlobals(['errorCollector' => $errorCollector]);
     }
+
+    /**
+     * Returns an error collector for ignored errors when using the
+     * "$limitValidation" keyword.
+     */
+    public static function getIgnoredErrorCollector(ValidationContext $context): ErrorCollectorInterface
+    {
+        if (!isset($context->globals()['ignoredErrorCollector'])) {
+            self::setIgnoredErrorCollector($context, new ErrorCollector());
+        }
+
+        return $context->globals()['ignoredErrorCollector'];
+    }
+
+    /**
+     * Sets the error collector for ignored errors when using the "$limitValidation" keyword.
+     */
+    public static function setIgnoredErrorCollector(ValidationContext $context, ErrorCollectorInterface $errorCollector): void
+    {
+        $context->setGlobals(['ignoredErrorCollector' => $errorCollector]);
+    }
 }
diff --git a/src/Expression/Variables/JsonPointerVariable.php b/src/Expression/Variables/JsonPointerVariable.php
@@ -80,7 +80,8 @@ public function getValue(ValidationContext $context, int $flags = 0, ?bool &$vio
         $path = $this->pointer->absolutePath($context->fullDataPath());
         Assertion::notNull($path);
 
-        $hasError = ErrorCollectorUtil::getErrorCollector($context)->hasErrorAt($path);
+        $hasError = ErrorCollectorUtil::getErrorCollector($context)->hasErrorAt($path)
+            || ErrorCollectorUtil::getIgnoredErrorCollector($context)->hasErrorAt($path);
         if (false === $violated) {
             $violated = $hasError;
         }
diff --git a/src/Expression/Variables/Variable.php b/src/Expression/Variables/Variable.php
@@ -60,7 +60,9 @@ public static function create($data, SchemaParser $parser): self
 
     /**
      * @param bool $violated Will be set to true, if false is given and the
-     *                       variable has violated data
+     *                       variable has violated data. Ignored errors (when
+     *                       using "$limitValidation" keyword are regarded,
+     *                       too.)
      *
      * @return null|mixed
      *
diff --git a/src/KeywordValidators/ApplyLimitValidationKeywordValidator.php b/src/KeywordValidators/ApplyLimitValidationKeywordValidator.php
@@ -23,6 +23,7 @@
 use Opis\JsonSchema\Errors\ValidationError;
 use Opis\JsonSchema\KeywordValidators\AbstractKeywordValidator;
 use Opis\JsonSchema\ValidationContext;
+use Systopia\JsonSchema\Errors\ErrorCollectorUtil;
 use Systopia\JsonSchema\LimitValidation\LimitValidationRule;
 
 class ApplyLimitValidationKeywordValidator extends AbstractKeywordValidator
@@ -52,7 +53,13 @@ public function validate(ValidationContext $context): ?ValidationError
     private function handleError(ValidationError $error, ValidationContext $context): ?ValidationError
     {
         if ('' !== $error->keyword()) {
-            return $this->shouldIgnoreError($error, $context) ? null : $error;
+            if ($this->shouldIgnoreError($error, $context)) {
+                ErrorCollectorUtil::getIgnoredErrorCollector($context)->addError($error);
+
+                return null;
+            }
+
+            return $error;
         }
 
         $subErrors = $error->subErrors();
diff --git a/src/KeywordValidators/CalculateKeywordValidator.php b/src/KeywordValidators/CalculateKeywordValidator.php
@@ -22,6 +22,7 @@
 
 use Assert\Assertion;
 use Opis\JsonSchema\Errors\ValidationError;
+use Opis\JsonSchema\JsonPointer;
 use Opis\JsonSchema\Keywords\ErrorTrait;
 use Opis\JsonSchema\KeywordValidators\AbstractKeywordValidator;
 use Opis\JsonSchema\Schema;
@@ -32,6 +33,7 @@
 use Systopia\JsonSchema\Expression\Variables\CalculationVariable;
 use Systopia\JsonSchema\Keywords\SetValueTrait;
 use Systopia\JsonSchema\Translation\ErrorTranslator;
+use Systopia\JsonSchema\Util\CalculateUtil;
 
 final class CalculateKeywordValidator extends AbstractKeywordValidator
 {
@@ -49,27 +51,35 @@ public function validate(ValidationContext $context): ?ValidationError
     {
         $calculationVariable = new CalculationVariable($this->calculation);
 
+        $violatedDataUsed = false;
+
         try {
-            $value = $calculationVariable->getValue($context);
+            $value = $calculationVariable->getValue($context, 0, $violatedDataUsed);
         } catch (ReferencedDataHasViolationException|VariableResolveException $e) {
             $value = null;
         }
 
+        CalculateUtil::setCalculatedValueUsedViolatedData(
+            $context,
+            JsonPointer::pathToString($context->fullDataPath()),
+            $violatedDataUsed
+        );
+
         if (null === $value) {
-            return $this->handleCalculationFailed($context);
+            return $this->handleCalculationFailed($context, $violatedDataUsed);
         }
 
         $this->setValue($context, static fn () => $value);
 
         return null === $this->next ? null : $this->next->validate($context);
     }
 
-    private function handleCalculationFailed(ValidationContext $context): ?ValidationError
+    private function handleCalculationFailed(ValidationContext $context, bool $violatedDataUsed): ?ValidationError
     {
         $schema = $context->schema();
         Assertion::notNull($schema);
         $this->unsetValue($context);
-        if ($this->isRequired($context)) {
+        if ($this->isRequired($context) && !$violatedDataUsed) {
             // "required" is checked before calculation
             return $this->error(
                 $schema,
diff --git a/src/KeywordValidators/LimitValidationKeywordValidator.php b/src/KeywordValidators/LimitValidationKeywordValidator.php
@@ -23,6 +23,7 @@
 use Opis\JsonSchema\Errors\ValidationError;
 use Opis\JsonSchema\Info\DataInfo;
 use Opis\JsonSchema\ValidationContext;
+use Systopia\JsonSchema\Errors\ErrorCollectorUtil;
 use Systopia\JsonSchema\LimitValidation\LimitValidationRule;
 use Systopia\JsonSchema\Util\SchemaUtil;
 
@@ -57,12 +58,20 @@ public function validate(ValidationContext $context): ?ValidationError
 
         try {
             $conditionSchema = SchemaUtil::loadSchema($this->conditionSchema, $context->loader());
-            $this->conditionMatched = null === SchemaUtil::validateWithoutLimit($conditionSchema, $context);
+            $errorCollector = ErrorCollectorUtil::getErrorCollector($context);
+            ErrorCollectorUtil::setErrorCollector($context, clone $errorCollector);
+
+            try {
+                $this->conditionMatched = null === SchemaUtil::validateWithoutLimit($conditionSchema, $context);
+            } finally {
+                ErrorCollectorUtil::setErrorCollector($context, $errorCollector);
+            }
 
             if ($this->conditionMatched) {
+                // First continue with "normal" validation, so $schema might reference calculated data.
+                $error = parent::validate($context);
                 $schema = SchemaUtil::loadSchema($this->schema, $context->loader());
                 $subSchemaError = SchemaUtil::validateWithoutLimit($schema, $context);
-                $error = parent::validate($context);
 
                 if (null !== $subSchemaError) {
                     \assert(null !== $context->schema());
@@ -73,7 +82,7 @@ public function validate(ValidationContext $context): ?ValidationError
                         DataInfo::fromContext($context),
                         'Data must match schema',
                         [],
-                        [$subSchemaError, $error]
+                        [$error, $subSchemaError]
                     );
                 }
 
diff --git a/src/Keywords/NoIntersectKeyword.php b/src/Keywords/NoIntersectKeyword.php
@@ -43,7 +43,9 @@ public function __construct(string $beginPropertyName, string $endPropertyName)
 
     public function validate(ValidationContext $context, Schema $schema): ?ValidationError
     {
-        if (!ErrorCollectorUtil::getErrorCollector($context)->hasErrorAt($context->currentDataPath())) {
+        if (!ErrorCollectorUtil::getErrorCollector($context)->hasErrorAt($context->currentDataPath())
+            && !ErrorCollectorUtil::getIgnoredErrorCollector($context)->hasErrorAt($context->currentDataPath())
+        ) {
             /** @var list<\stdClass> $array */
             $array = $context->currentData();
             usort(
diff --git a/src/Keywords/OrderObjectsKeyword.php b/src/Keywords/OrderObjectsKeyword.php
@@ -46,6 +46,7 @@ public function __construct(array $order)
     public function validate(ValidationContext $context, Schema $schema): ?ValidationError
     {
         if (!ErrorCollectorUtil::getErrorCollector($context)->hasErrorAt($context->currentDataPath())
+            && !ErrorCollectorUtil::getIgnoredErrorCollector($context)->hasErrorAt($context->currentDataPath())
             && 'array' === $context->currentDataType()
         ) {
             $this->setValue($context, function (array $array) {
diff --git a/src/Keywords/OrderSimpleKeyword.php b/src/Keywords/OrderSimpleKeyword.php
@@ -46,6 +46,7 @@ public function __construct(string $direction)
     public function validate(ValidationContext $context, Schema $schema): ?ValidationError
     {
         if (!ErrorCollectorUtil::getErrorCollector($context)->hasErrorAt($context->currentDataPath())
+            && !ErrorCollectorUtil::getIgnoredErrorCollector($context)->hasErrorAt($context->currentDataPath())
             && 'array' === $context->currentDataType()
         ) {
             $this->setValue($context, function (array $array) {
diff --git a/src/LimitValidation/LimitValidationRule.php b/src/LimitValidation/LimitValidationRule.php
@@ -21,8 +21,11 @@
 namespace Systopia\JsonSchema\LimitValidation;
 
 use Opis\JsonSchema\Errors\ValidationError;
+use Opis\JsonSchema\JsonPointer;
 use Opis\JsonSchema\Schema;
 use Opis\JsonSchema\ValidationContext;
+use Systopia\JsonSchema\Errors\ErrorCollectorUtil;
+use Systopia\JsonSchema\Util\CalculateUtil;
 use Systopia\JsonSchema\Util\SchemaUtil;
 
 final class LimitValidationRule
@@ -33,17 +36,20 @@ final class LimitValidationRule
 
     private bool|Schema|\stdClass $valueSchema;
 
+    private ?bool $calculatedValueUsedViolatedData;
     private bool $validate;
 
-    public function __construct(
+    private function __construct(
         bool|\stdClass $keywordSchema,
         bool|\stdClass $keywordValueSchema,
         bool|\stdClass $valueSchema,
+        ?bool $calculatedValueUsedViolatedData,
         bool $validate
     ) {
         $this->keywordSchema = $keywordSchema;
         $this->keywordValueSchema = $keywordValueSchema;
         $this->valueSchema = $valueSchema;
+        $this->calculatedValueUsedViolatedData = $calculatedValueUsedViolatedData;
         $this->validate = $validate;
     }
 
@@ -52,6 +58,7 @@ public function __construct(
      *     keyword?: \stdClass|bool,
      *     keywordValue?: \stdClass|bool,
      *     value?: \stdClass|bool,
+     *     calculatedValueUsedViolatedData?: ?bool,
      *     validate?: bool,
      * } $rule
      */
@@ -61,6 +68,7 @@ public static function create(array $rule): self
             $rule['keyword'] ?? true,
             $rule['keywordValue'] ?? true,
             $rule['value'] ?? true,
+            $rule['calculatedValueUsedViolatedData'] ?? null,
             $rule['validate'] ?? false
         );
     }
@@ -82,16 +90,38 @@ private function isRuleMatched(ValidationError $error, ValidationContext $contex
             $this->valueSchema = SchemaUtil::loadSchema($this->valueSchema, $context->loader());
         }
 
-        return null === SchemaUtil::validateWithoutLimit(
-            $this->keywordSchema,
-            new ValidationContext($error->keyword(), $context->loader())
-        ) && null === SchemaUtil::validateWithoutLimit(
-            $this->keywordValueSchema,
-            // @phpstan-ignore property.dynamicName
-            new ValidationContext($error->schema()->info()->data()->{$error->keyword()}, $context->loader())
-        ) && null === SchemaUtil::validateWithoutLimit(
-            $this->valueSchema,
-            new ValidationContext($error->data()->value(), $context->loader())
+        return null === $this->subValidate($context, $this->keywordSchema, $error->keyword())
+            && null === $this->subValidate(
+                $context,
+                $this->keywordValueSchema,
+                // @phpstan-ignore property.dynamicName
+                $error->schema()->info()->data()->{$error->keyword()}
+            ) && null === $this->subValidate($context, $this->valueSchema, $error->data()->value())
+            && (
+                null === $this->calculatedValueUsedViolatedData
+                || $this->calculatedValueUsedViolatedData === CalculateUtil::wasViolatedDataUsedForCalculatedValue(
+                    $context,
+                    JsonPointer::pathToString($error->data()->fullPath())
+                )
+            );
+    }
+
+    /**
+     * @param mixed $data
+     */
+    private function subValidate(ValidationContext $context, Schema $schema, $data): ?ValidationError
+    {
+        $newContext = new ValidationContext($data, $context->loader());
+        // Use cloned error collectors so it is possible to check if referenced data has violations.
+        ErrorCollectorUtil::setIgnoredErrorCollector(
+            $newContext,
+            clone ErrorCollectorUtil::getIgnoredErrorCollector($context)
+        );
+        ErrorCollectorUtil::setErrorCollector(
+            $newContext,
+            clone ErrorCollectorUtil::getIgnoredErrorCollector($context)
         );
+
+        return SchemaUtil::validateWithoutLimit($schema, $newContext);
     }
 }
diff --git a/src/Parsers/KeywordValidators/LimitValidationKeywordParser.php b/src/Parsers/KeywordValidators/LimitValidationKeywordParser.php
@@ -68,7 +68,7 @@ public function parse(SchemaInfo $info, SchemaParser $parser, object $shared): ?
         } elseif (null !== LimitValidationKeywordValidator::getCurrentInstance()) {
             $condition = LimitValidationKeywordValidator::getCurrentInstance()->isConditionMatched();
         } else {
-            $condition = true;
+            $condition = false;
         }
 
         if (!\is_array($limitValidation->rules ?? [])) {
@@ -123,6 +123,9 @@ private function getStandardRules(SchemaParser $parser): array
                 ],
             ],
         ]);
+        $this->standardRules[] = LimitValidationRule::create([
+            'calculatedValueUsedViolatedData' => true,
+        ]);
         $this->standardRules[] = LimitValidationRule::create(
             ['validate' => true]
         );
diff --git a/src/Util/CalculateUtil.php b/src/Util/CalculateUtil.php
diff --git a/tests/CalculateTest.php b/tests/CalculateTest.php
diff --git a/tests/Errors/ErrorCollectorUtilTest.php b/tests/Errors/ErrorCollectorUtilTest.php
diff --git a/tests/LimitValidationTest.php b/tests/LimitValidationTest.php
diff --git a/tests/Util/CalculateUtilTest.php b/tests/Util/CalculateUtilTest.php

Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,8 @@ public function getValue(ValidationContext $context, int $flags = 0, ?bool &$vio`
`80`	`80`	`$path = $this->pointer->absolutePath($context->fullDataPath());`
`81`	`81`	`Assertion::notNull($path);`
`82`	`82`
`83`		`- $hasError = ErrorCollectorUtil::getErrorCollector($context)->hasErrorAt($path);`
	`83`	`+ $hasError = ErrorCollectorUtil::getErrorCollector($context)->hasErrorAt($path)`
	`84`	`+ \|\| ErrorCollectorUtil::getIgnoredErrorCollector($context)->hasErrorAt($path);`
`84`	`85`	`if (false === $violated) {`
`85`	`86`	`$violated = $hasError;`
`86`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,9 @@ public static function create($data, SchemaParser $parser): self`
`60`	`60`
`61`	`61`	`/**`
`62`	`62`	`* @param bool $violated Will be set to true, if false is given and the`
`63`		`- * variable has violated data`
	`63`	`+ * variable has violated data. Ignored errors (when`
	`64`	`+ * using "$limitValidation" keyword are regarded,`
	`65`	`+ * too.)`
`64`	`66`	`*`
`65`	`67`	`* @return null\|mixed`
`66`	`68`	`*`
Original file line number	Diff line number	Diff line change
`@@ -46,6 +46,7 @@ public function __construct(array $order)`
`46`	`46`	`public function validate(ValidationContext $context, Schema $schema): ?ValidationError`
`47`	`47`	`{`
`48`	`48`	`if (!ErrorCollectorUtil::getErrorCollector($context)->hasErrorAt($context->currentDataPath())`
	`49`	`+ && !ErrorCollectorUtil::getIgnoredErrorCollector($context)->hasErrorAt($context->currentDataPath())`
`49`	`50`	`&& 'array' === $context->currentDataType()`
`50`	`51`	`) {`
`51`	`52`	`$this->setValue($context, function (array $array) {`