Sulu\Bundle\ValidationBundle\JsonSchema\CachedSchemaStorage

Complexity

Total Complexity

13

Size/Duplication

Total Lines	129
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

97.62%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	1
A	initializeCache()	0	17	3
A	getSchemaByRoute()	0	6	1
A	processSchema()	0	21	4
A	processReferencesInSchema()	0	12	4

<?php

namespace Sulu\Bundle\ValidationBundle\JsonSchema;

use InvalidArgumentException;
use JsonSchema\Entity\JsonPointer;
use JsonSchema\Iterator\ObjectIterator;
use JsonSchema\SchemaStorage;
use Sulu\Bundle\ValidationBundle\Exceptions\MalFormedJsonException;
use Symfony\Component\Config\ConfigCache;
use Symfony\Component\Config\Exception\FileLocatorFileNotFoundException;
use Symfony\Component\Config\FileLocatorInterface;
use Symfony\Component\Config\Resource\FileResource;

class CachedSchemaStorage extends SchemaStorage
{
    const FILE_PREFIX = 'file://';

    /**
     * @var FileLocatorInterface
     */
    private $fileLocator;

    /**
     * @var array
     */
    private $configuredSchemas;

    /**
     * @var bool
     */
    private $debugMode;

    /**
     * @var string
     */
    private $cacheFilePath;

    /**
     * @param array                $configuredSchemas array containing all file paths to configured schemas
     * @param FileLocatorInterface $fileLocator
     * @param string               $cacheFilePath
     * @param string               $environment
     */
    public function __construct(
        array $configuredSchemas,
        FileLocatorInterface $fileLocator,
        $cacheFilePath,
        $environment
    ) {
        parent::__construct();

        $this->fileLocator = $fileLocator;
        $this->configuredSchemas = $configuredSchemas;
        $this->debugMode = $environment !== 'prod';
        $this->cacheFilePath = $cacheFilePath;
    }

    public function initializeCache()
    {
        $schemaCache = new ConfigCache($this->cacheFilePath, $this->debugMode);

        if (!$schemaCache->isFresh()) {
            $resources = [];
            $processedSchemas = [];

            foreach ($this->configuredSchemas as $schemaPath) {
                $this->processSchema($schemaPath, $processedSchemas, $resources);
            }

            $schemaCache->write(serialize($processedSchemas), $resources);
        }

        $this->schemas = unserialize(file_get_contents($schemaCache->getPath()));
    }

    /**
     * @param string $routeId
     *
     * @return object
     * @throws InvalidArgumentException
     */
    public function getSchemaByRoute($routeId)
    {
        $schemaFilePath = self::FILE_PREFIX . $this->fileLocator->locate($this->configuredSchemas[$routeId]);

        return $this->getSchema($schemaFilePath);
    }

    /**
     * @param string $schemaPath
     * @param array  $serializedSchemas
     * @param array  $resources
     *
     * @throws MalFormedJsonException
     * @throws InvalidArgumentException
     * @throws FileLocatorFileNotFoundException
     */
    protected function processSchema($schemaPath, array &$serializedSchemas, array &$resources)
    {
        if (array_key_exists($schemaPath, $serializedSchemas)) {
            return;
        }

        $absoluteSchemaPath = $this->fileLocator->locate($schemaPath);
        $schema = json_decode(file_get_contents($absoluteSchemaPath));

        if (json_last_error() !== JSON_ERROR_NONE) {
            throw new MalFormedJsonException('Malformed json encountered in ' . $schemaPath);
        }

        if (strpos($absoluteSchemaPath, self::FILE_PREFIX) !== 0) {
            $absoluteSchemaPath = self::FILE_PREFIX . $absoluteSchemaPath;
        }

        $serializedSchemas[$absoluteSchemaPath] = $schema;
        $resources[] = new FileResource($absoluteSchemaPath);

It seems like $absoluteSchemaPath defined by $this->fileLocator->locate($schemaPath) on line 105 can also be of type array; however, Symfony\Component\Config\Resource\FileResource::__construct() does only seem to accept string, maybe add an additional type check?

        $this->processReferencesInSchema($schema, $absoluteSchemaPath, $serializedSchemas, $resources);

It seems like $absoluteSchemaPath defined by $this->fileLocator->locate($schemaPath) on line 105 can also be of type array; however, Sulu\Bundle\ValidationBundle\JsonSchema\CachedSchemaStorage::processReferencesInSchema() does only seem to accept string, maybe add an additional type check?

    }

    /**
     * @param mixed  $schema
     * @param string $schemaFilePath
     * @param array  $serializedSchemas
     * @param array  $resources
     *
     * @throws MalFormedJsonException
     * @throws InvalidArgumentException
     * @throws FileLocatorFileNotFoundException
     */
    protected function processReferencesInSchema($schema, $schemaFilePath, array &$serializedSchemas, array &$resources)
    {
        $objectIterator = new ObjectIterator($schema);
        foreach ($objectIterator as $toResolveSchema) {
            if (property_exists($toResolveSchema, '$ref') && is_string($toResolveSchema->{'$ref'})) {
                $uri = $this->uriResolver->resolve($toResolveSchema->{'$ref'}, $schemaFilePath);
                $jsonPointer = new JsonPointer($uri);
                $toResolveSchema->{'$ref'} = (string)$jsonPointer;
                $this->processSchema($jsonPointer->getFilename(), $serializedSchemas, $resources);
            }
        }
    }
}