JVal\Walker

Complexity

Total Complexity

33

Size/Duplication

Total Lines	220
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	0	Features	2

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
C	resolveReferences()	0	42	12
B	parseSchema()	0	17	5
A	applyConstraints()	0	7	2
A	isLooping()	0	10	2
A	getConstraints()	0	8	2
D	getConstraintsForInstance()	0	37	9

<?php

/*
 * This file is part of the JVal package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace JVal;

use stdClass;

/**
 * Implements the three steps needed to perform a JSON Schema validation,
 * i.e. distinct methods to recursively:.
 *
 * 1) resolve JSON pointer references within schema
 * 2) normalize and validate the syntax of the schema
 * 3) validate a given instance against it
 */
class Walker
{
    /**
     * @var Registry
     */
    private $registry;

    /**
     * @var Resolver
     */
    private $resolver;

    /**
     * @var stdClass[]
     */
    private $parsedSchemas = [];

    /**
     * @var stdClass[]
     */
    private $resolvedSchemas = [];

    /**
     * @var Constraint[][]
     */
    private $constraintsCacheA = [];

    /**
     * @var Constraint[][]
     */
    private $constraintsCacheB = [];

    /**
     * Constructor.
     *
     * @param Registry $registry
     * @param Resolver $resolver
     */
    public function __construct(Registry $registry, Resolver $resolver)
    {
        $this->registry = $registry;
        $this->resolver = $resolver;
    }

    /**
     * Recursively resolve JSON pointer references within a given schema.
     *
     * @param stdClass $schema The schema to resolve
     * @param Uri      $uri    The URI of the schema
     *
     * @return stdClass
     */
    public function resolveReferences(stdClass $schema, Uri $uri)
    {
        if ($this->isLooping($schema, $this->resolvedSchemas)) {
            return $schema;
        }

        if (!$this->resolver->hasBaseSchema()) {
            $this->resolver->setBaseSchema($schema, $uri);
        }

        $inScope = false;

        if (property_exists($schema, 'id') && is_string($schema->id)) {
            $this->resolver->enter(new Uri($schema->id));
            $inScope = true;
        }

        if (property_exists($schema, '$ref')) {
            $resolved = $this->resolver->resolve($schema);
            $this->resolver->enter($resolved[0], $resolved[1]);
            $schema = $this->resolveReferences($resolved[1], $resolved[0]);
            $this->resolver->leave();
        } else {
            foreach ($schema as $property => $value) {
                if (is_object($value)) {
                    $schema->{$property} = $this->resolveReferences($value, $uri);
                } elseif (is_array($value)) {
                    foreach ($value as $index => $element) {
                        if (is_object($element)) {
                            $schema->{$property}[$index] = $this->resolveReferences($element, $uri);
                        }
                    }
                }
            }
        }

        if ($inScope) {
            $this->resolver->leave();
        }

        return $schema;
    }

    /**
     * Recursively normalizes a given schema and validates its syntax.
     *
     * @param stdClass $schema
     * @param Context  $context
     *
     * @return stdClass
     */
    public function parseSchema(stdClass $schema, Context $context)
    {
        if ($this->isLooping($schema, $this->parsedSchemas)) {
            return $schema;
        }

        foreach ($this->getConstraints($schema, $context) as $constraint) {
            foreach ($constraint->keywords() as $keyword) {
                if (property_exists($schema, $keyword)) {
                    $constraint->normalize($schema, $context, $this);
                    break;
                }
            }
        }

        return $schema;
    }

    /**
     * Validates an instance against a given schema, populating a context
     * with encountered violations.
     *
     * @param mixed    $instance
     * @param stdClass $schema
     * @param Context  $context
     */
    public function applyConstraints($instance, stdClass $schema, Context $context)
    {
        $constraints = $this->getConstraintsForInstance($schema, $context, $instance);
        foreach ($constraints as $constraint) {
            $constraint->apply($instance, $schema, $context, $this);
        }
    }

    /**
     * Checks if given schema has been already visited.
     *
     * @param stdClass $schema
     * @param array    $stack
     *
     * @return bool
     */
    private function isLooping(stdClass $schema, array &$stack)
    {
        $schemaHash = spl_object_hash($schema);
        if (isset($stack[$schemaHash])) {
            return true;
        }

        $stack[$schemaHash] = true;
        return false;
    }

    /**
     * Returns constraints for current schema version.
     *
     * @param stdClass $schema
     * @param Context  $context
     *
     * @return Constraint[]
     */
    private function getConstraints(stdClass $schema, Context $context)
    {
        if (isset($schema->{'$schema'})) {
            $context->setVersion($schema->{'$schema'});
        }

        return $this->registry->getConstraints($context->getVersion());
    }

    /**
     * Returns constraints which should be applied to given instance.
     *
     * @param stdClass $schema
     * @param Context  $context
     * @param mixed    $instance
     *
     * @return Constraint[]
     */
    private function getConstraintsForInstance(stdClass $schema, Context $context, $instance)
    {
        if (isset($schema->{'$schema'})) {
            $context->setVersion($schema->{'$schema'});
        }

        $instanceType = gettype($instance);
        $schemaHash = spl_object_hash($schema);
        $constraintsA = & $this->constraintsCacheA[$schemaHash.$instanceType];

        if ($constraintsA === null) {
            $version = $context->getVersion();
            $constraintsB = & $this->constraintsCacheB[$version.$instanceType];

            if ($constraintsB === null) {
                $instanceType = Types::getPrimitiveTypeOf($instance);
                $constraintsB = [];
                foreach ($this->registry->getConstraints($version) as $constraint) {
                    if ($constraint->supports($instanceType)) {
                        $constraintsB[] = $constraint;
                    }
                }
            }

            $constraintsA = [];
            foreach ($constraintsB as $constraint) {
                foreach ($constraint->keywords() as $keyword) {
                    if (property_exists($schema, $keyword)) {
                        $constraintsA[] = $constraint;
                        break;
                    }
                }
            }
        }

        return $constraintsA;
    }
}