/** * {@inheritdoc} */ public function normalize(stdClass $schema, Context $context, Walker $walker) { $context->enterNode('type'); if (is_string($schema->type)) { if (!Types::isPrimitive($schema->type)) { throw new NotPrimitiveTypeException($context); } } elseif (is_array($schema->type)) { foreach ($schema->type as $index => $type) { $context->enterNode($index); if (!is_string($type)) { throw new InvalidTypeException($context, Types::TYPE_STRING); } if (!Types::isPrimitive($type)) { throw new NotPrimitiveTypeException($context); } $context->leaveNode(); } if (count(array_unique($schema->type)) !== count($schema->type)) { throw new NotUniqueException($context); } } else { throw new InvalidTypeException($context, [Types::TYPE_STRING, Types::TYPE_ARRAY]); } $context->leaveNode(); }
/** * {@inheritdoc} */ public function normalize(stdClass $schema, Context $context, Walker $walker) { $context->enterNode('dependencies'); if (!is_object($schema->dependencies)) { throw new InvalidTypeException($context, Types::TYPE_OBJECT); } foreach ($schema->dependencies as $property => $value) { $context->enterNode($property); if (is_object($value)) { $walker->parseSchema($value, $context); } elseif (is_array($value)) { if (0 === ($propertyCount = count($value))) { throw new EmptyArrayException($context); } foreach ($value as $index => $subProperty) { if (!is_string($subProperty)) { $context->enterNode($index); throw new InvalidTypeException($context, Types::TYPE_STRING); } } if (count(array_unique($value)) !== $propertyCount) { throw new NotUniqueException($context); } } else { throw new InvalidTypeException($context, [Types::TYPE_OBJECT, Types::TYPE_ARRAY]); } $context->leaveNode(); } $context->leaveNode(); }
/** * {@inheritdoc} */ public function apply($instance, stdClass $schema, Context $context, Walker $walker) { if (is_object($schema->items)) { // 8.2.3.1. If items is a schema, then the child instance must be // valid against this schema, regardless of its index, and // regardless of the value of "additionalItems". foreach ($instance as $index => $item) { $context->enterNode($index); $walker->applyConstraints($item, $schema->items, $context); $context->leaveNode(); } } else { // "items" is an array $itemSize = count($schema->items); foreach ($instance as $index => $item) { $context->enterNode($index); // 8.2.3.2. If the index is less than, or equal to, the size of // "items", the child instance must be valid against the // corresponding schema in the "items" array; otherwise, it must // be valid against the schema defined by "additionalItems". // // NOTE: this is adapted for 0-based indexation. if ($index < $itemSize) { $walker->applyConstraints($item, $schema->items[$index], $context); } elseif ($schema->additionalItems === false) { $context->addViolation('additional items are not allowed'); } else { $walker->applyConstraints($item, $schema->additionalItems, $context); } $context->leaveNode(); } } }
/** * {@inheritdoc} */ public function normalize(stdClass $schema, Context $context, Walker $walker) { if (!is_bool($schema->uniqueItems)) { $context->enterNode('uniqueItems'); throw new InvalidTypeException($context, Types::TYPE_BOOLEAN); } }
/** * {@inheritdoc} */ public function normalize(stdClass $schema, Context $context, Walker $walker) { if (!is_string($schema->format)) { $context->enterNode('format'); throw new InvalidTypeException($context, Types::TYPE_STRING); } // TODO: add option to treat unknown format as a schema error }
/** * {@inheritdoc} */ public function normalize(stdClass $schema, Context $context, Walker $walker) { $context->enterNode('not'); if (!is_object($schema->not)) { throw new InvalidTypeException($context, Types::TYPE_OBJECT); } $walker->parseSchema($schema->not, $context); $context->leaveNode(); }
/** * {@inheritdoc} */ public function normalize(stdClass $schema, Context $context, Walker $walker) { $property = $this->keywords()[0]; $secondaryProperty = $this->keywords()[1]; if (!property_exists($schema, $property)) { throw new MissingKeywordException($context, $property); } if (!property_exists($schema, $secondaryProperty)) { $schema->{$secondaryProperty} = false; } if (!Types::isA($schema->{$property}, Types::TYPE_NUMBER)) { $context->enterNode($property); throw new InvalidTypeException($context, Types::TYPE_NUMBER); } if (!is_bool($schema->{$secondaryProperty})) { $context->enterNode($secondaryProperty); throw new InvalidTypeException($context, Types::TYPE_BOOLEAN); } }
/** * {@inheritdoc} */ public function normalize(stdClass $schema, Context $context, Walker $walker) { $context->enterNode('required'); if (!is_array($schema->required)) { throw new InvalidTypeException($context, Types::TYPE_ARRAY); } if (0 === ($requiredCount = count($schema->required))) { throw new EmptyArrayException($context); } foreach ($schema->required as $index => $property) { if (!is_string($property)) { $context->enterNode($index); throw new InvalidTypeException($context, Types::TYPE_STRING); } } if ($requiredCount !== count(array_unique($schema->required))) { throw new NotUniqueException($context); } $context->leaveNode(); }
/** * {@inheritdoc} */ public function normalize(stdClass $schema, Context $context, Walker $walker) { $context->enterNode('pattern'); if (!is_string($schema->pattern)) { throw new InvalidTypeException($context, Types::TYPE_STRING); } if (!Utils::isValidRegex($schema->pattern)) { throw new InvalidRegexException($context); } $context->leaveNode(); }
/** * {@inheritdoc} */ public function normalize(stdClass $schema, Context $context, Walker $walker) { $context->enterNode('multipleOf'); if (!Types::isA($schema->multipleOf, Types::TYPE_NUMBER)) { throw new InvalidTypeException($context, Types::TYPE_NUMBER); } if ($schema->multipleOf <= 0) { throw new NotStrictlyPositiveException($context); } $context->leaveNode(); }
/** * {@inheritdoc} */ public function normalize(stdClass $schema, Context $context, Walker $walker) { $keyword = $this->keywords()[0]; $context->enterNode($keyword); if (!is_array($schema->{$keyword})) { throw new InvalidTypeException($context, Types::TYPE_ARRAY); } if (count($schema->{$keyword}) === 0) { throw new EmptyArrayException($context); } foreach ($schema->{$keyword} as $index => $subSchema) { $context->enterNode($index); if (!is_object($subSchema)) { throw new InvalidTypeException($context, Types::TYPE_OBJECT); } $walker->parseSchema($subSchema, $context); $context->leaveNode(); } $context->leaveNode(); }
/** * {@inheritdoc} */ public function normalize(stdClass $schema, Context $context, Walker $walker) { $keyword = $this->keywords()[0]; $context->enterNode($keyword); if (!is_int($schema->{$keyword})) { throw new InvalidTypeException($context, Types::TYPE_INTEGER); } if ($schema->{$keyword} < 0) { throw new LessThanZeroException($context); } $context->leaveNode(); }
/** * {@inheritdoc} */ public function normalize(stdClass $schema, Context $context, Walker $walker) { $context->enterNode('enum'); if (!is_array($schema->enum)) { throw new InvalidTypeException($context, Types::TYPE_ARRAY); } if (count($schema->enum) === 0) { throw new EmptyArrayException($context); } foreach ($schema->enum as $i => $aItem) { foreach ($schema->enum as $j => $bItem) { if ($i !== $j && Utils::areEqual($aItem, $bItem)) { throw new NotUniqueException($context); } } } $context->leaveNode(); }
private function parsePatternPropertiesProperty(stdClass $schema, Context $context, Walker $walker) { if (!is_object($schema->patternProperties)) { throw new InvalidTypeException($context, Types::TYPE_OBJECT); } foreach ($schema->patternProperties as $regex => $value) { $context->enterNode($regex); if (!Utils::isValidRegex($regex)) { throw new InvalidRegexException($context); } if (!is_object($value)) { throw new InvalidTypeException($context, Types::TYPE_OBJECT); } $walker->parseSchema($value, $context); $context->leaveNode(); } }