class SchemaConstraint

The SchemaConstraint Constraints, validates an element against a given schema

@author Robert Schönthal <seroscho@googlemail.com> @author Bruno Prieto Reis <bruno.p.reis@gmail.com>

Hierarchy

Expanded class hierarchy of SchemaConstraint

File

vendor/justinrainbow/json-schema/src/JsonSchema/Constraints/SchemaConstraint.php, line 24

Namespace

JsonSchema\Constraints
View source 
class SchemaConstraint extends Constraint {
    const DEFAULT_SCHEMA_SPEC = 'http://json-schema.org/draft-04/schema#';
    
    /**
     * {@inheritdoc}
     */
    public function check(&$element, $schema = null, ?JsonPointer $path = null, $i = null) {
        if ($schema !== null) {
            // passed schema
            $validationSchema = $schema;
        }
        elseif ($this->getTypeCheck()
            ->propertyExists($element, $this->inlineSchemaProperty)) {
            // inline schema
            $validationSchema = $this->getTypeCheck()
                ->propertyGet($element, $this->inlineSchemaProperty);
        }
        else {
            throw new InvalidArgumentException('no schema found to verify against');
        }
        // cast array schemas to object
        if (is_array($validationSchema)) {
            $validationSchema = BaseConstraint::arrayToObjectRecursive($validationSchema);
        }
        // validate schema against whatever is defined in $validationSchema->$schema. If no
        // schema is defined, assume self::DEFAULT_SCHEMA_SPEC (currently draft-04).
        if ($this->factory
            ->getConfig(self::CHECK_MODE_VALIDATE_SCHEMA)) {
            if (!$this->getTypeCheck()
                ->isObject($validationSchema)) {
                throw new RuntimeException('Cannot validate the schema of a non-object');
            }
            if ($this->getTypeCheck()
                ->propertyExists($validationSchema, '$schema')) {
                $schemaSpec = $this->getTypeCheck()
                    ->propertyGet($validationSchema, '$schema');
            }
            else {
                $schemaSpec = self::DEFAULT_SCHEMA_SPEC;
            }
            // get the spec schema
            $schemaStorage = $this->factory
                ->getSchemaStorage();
            if (!$this->getTypeCheck()
                ->isObject($schemaSpec)) {
                $schemaSpec = $schemaStorage->getSchema($schemaSpec);
            }
            // save error count, config & subtract CHECK_MODE_VALIDATE_SCHEMA
            $initialErrorCount = $this->numErrors();
            $initialConfig = $this->factory
                ->getConfig();
            $initialContext = $this->factory
                ->getErrorContext();
            $this->factory
                ->removeConfig(self::CHECK_MODE_VALIDATE_SCHEMA | self::CHECK_MODE_APPLY_DEFAULTS);
            $this->factory
                ->addConfig(self::CHECK_MODE_TYPE_CAST);
            $this->factory
                ->setErrorContext(Validator::ERROR_SCHEMA_VALIDATION);
            // validate schema
            try {
                $this->check($validationSchema, $schemaSpec);
            } catch (\Exception $e) {
                if ($this->factory
                    ->getConfig(self::CHECK_MODE_EXCEPTIONS)) {
                    throw new InvalidSchemaException('Schema did not pass validation', 0, $e);
                }
            }
            if ($this->numErrors() > $initialErrorCount) {
                $this->addError($path, 'Schema is not valid', 'schema');
            }
            // restore the initial config
            $this->factory
                ->setConfig($initialConfig);
            $this->factory
                ->setErrorContext($initialContext);
        }
        // validate element against $validationSchema
        $this->checkUndefined($element, $validationSchema, $path, $i);
    }

}

Members

Title Modifiers Object type Summary Overriden Title
BaseConstraint::$errorMask protected property
BaseConstraint::$errors protected property
BaseConstraint::$factory protected property
BaseConstraint::addError public function
BaseConstraint::addErrors public function
BaseConstraint::arrayToObjectRecursive public static function Recursively cast an associative array to an object
BaseConstraint::getErrorMask public function Get the error mask
BaseConstraint::getErrors public function
BaseConstraint::isValid public function
BaseConstraint::numErrors public function
BaseConstraint::reset public function Clears any reported errors. Should be used between
multiple validation checks.
BaseConstraint::__construct public function
Constraint::$inlineSchemaProperty protected property
Constraint::checkArray protected function Validates an array
Constraint::checkEnum protected function Checks a enum element
Constraint::checkFormat protected function Checks format of an element
Constraint::checkNumber protected function Checks a number element
Constraint::checkObject protected function Validates an object
Constraint::checkString protected function Checks a string element
Constraint::checkType protected function Validates the type of a property
Constraint::checkUndefined protected function Checks a undefined element
Constraint::CHECK_MODE_APPLY_DEFAULTS constant
Constraint::CHECK_MODE_COERCE_TYPES constant
Constraint::CHECK_MODE_DISABLE_FORMAT constant
Constraint::CHECK_MODE_EXCEPTIONS constant
Constraint::CHECK_MODE_NONE constant
Constraint::CHECK_MODE_NORMAL constant
Constraint::CHECK_MODE_ONLY_REQUIRED_DEFAULTS constant
Constraint::CHECK_MODE_TYPE_CAST constant
Constraint::CHECK_MODE_VALIDATE_SCHEMA constant
Constraint::convertJsonPointerIntoPropertyPath protected function
Constraint::getTypeCheck protected function Get the type check based on the set check mode.
Constraint::incrementPath protected function Bubble down the path
SchemaConstraint::check public function invokes the validation of an element Overrides ConstraintInterface::check
SchemaConstraint::DEFAULT_SCHEMA_SPEC constant