Init Server Composer Components

1 files changed, 277 insertions, 0 deletions

diff --git a/server/vendor/justinrainbow/json-schema/src/JsonSchema/RefResolver.php b/server/vendor/justinrainbow/json-schema/src/JsonSchema/RefResolver.php
new file mode 100644
index 0000000..ea0fafd
--- /dev/null
+++ b/server/vendor/justinrainbow/json-schema/src/JsonSchema/RefResolver.php
@@ -0,0 +1,277 @@
+<?php
+
+/*
+ * This file is part of the JsonSchema package.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace JsonSchema;
+
+use JsonSchema\Exception\JsonDecodingException;
+use JsonSchema\Uri\Retrievers\UriRetrieverInterface;
+use JsonSchema\Uri\UriRetriever;
+
+/**
+ * Take in an object that's a JSON schema and take care of all $ref references
+ *
+ * @author Tyler Akins <fidian@rumkin.com>
+ * @see    README.md
+ */
+class RefResolver
+{
+    /**
+     * HACK to prevent too many recursive expansions.
+     * Happens e.g. when you want to validate a schema against the schema
+     * definition.
+     *
+     * @var integer
+     */
+    protected static $depth = 0;
+
+    /**
+     * maximum references depth
+     * @var integer
+     */
+    public static $maxDepth = 7;
+
+    /**
+     * @var UriRetrieverInterface
+     */
+    protected $uriRetriever = null;
+
+    /**
+     * @var object
+     */
+    protected $rootSchema = null;
+
+    /**
+     * @param UriRetriever $retriever
+     */
+    public function __construct($retriever = null)
+    {
+        $this->uriRetriever = $retriever;
+    }
+
+    /**
+     * Retrieves a given schema given a ref and a source URI
+     *
+     * @param  string $ref       Reference from schema
+     * @param  string $sourceUri URI where original schema was located
+     * @return object            Schema
+     */
+    public function fetchRef($ref, $sourceUri)
+    {
+        $retriever  = $this->getUriRetriever();
+        $jsonSchema = $retriever->retrieve($ref, $sourceUri);
+        $this->resolve($jsonSchema);
+
+        return $jsonSchema;
+    }
+
+    /**
+     * Return the URI Retriever, defaulting to making a new one if one
+     * was not yet set.
+     *
+     * @return UriRetriever
+     */
+    public function getUriRetriever()
+    {
+        if (is_null($this->uriRetriever)) {
+            $this->setUriRetriever(new UriRetriever);
+        }
+
+        return $this->uriRetriever;
+    }
+
+    /**
+     * Resolves all $ref references for a given schema.  Recurses through
+     * the object to resolve references of any child schemas.
+     *
+     * The 'format' property is omitted because it isn't required for
+     * validation.  Theoretically, this class could be extended to look
+     * for URIs in formats: "These custom formats MAY be expressed as
+     * an URI, and this URI MAY reference a schema of that format."
+     *
+     * The 'id' property is not filled in, but that could be made to happen.
+     *
+     * @param object $schema    JSON Schema to flesh out
+     * @param string $sourceUri URI where this schema was located
+     */
+    public function resolve($schema, $sourceUri = null)
+    {
+        if (self::$depth > self::$maxDepth) {
+            self::$depth = 0;
+            throw new JsonDecodingException(JSON_ERROR_DEPTH);
+        }
+        ++self::$depth;
+
+        if (! is_object($schema)) {
+            --self::$depth;
+            return;
+        }
+
+        if (null === $sourceUri && ! empty($schema->id)) {
+            $sourceUri = $schema->id;
+        }
+
+        if (null === $this->rootSchema) {
+            $this->rootSchema = $schema;
+        }
+
+        // Resolve $ref first
+        $this->resolveRef($schema, $sourceUri);
+
+        // These properties are just schemas
+        // eg.  items can be a schema or an array of schemas
+        foreach (array('additionalItems', 'additionalProperties', 'extends', 'items') as $propertyName) {
+            $this->resolveProperty($schema, $propertyName, $sourceUri);
+        }
+
+        // These are all potentially arrays that contain schema objects
+        // eg.  type can be a value or an array of values/schemas
+        // eg.  items can be a schema or an array of schemas
+        foreach (array('disallow', 'extends', 'items', 'type', 'allOf', 'anyOf', 'oneOf') as $propertyName) {
+            $this->resolveArrayOfSchemas($schema, $propertyName, $sourceUri);
+        }
+
+        // These are all objects containing properties whose values are schemas
+        foreach (array('dependencies', 'patternProperties', 'properties') as $propertyName) {
+            $this->resolveObjectOfSchemas($schema, $propertyName, $sourceUri);
+        }
+
+        --self::$depth;
+    }
+
+    /**
+     * Given an object and a property name, that property should be an
+     * array whose values can be schemas.
+     *
+     * @param object $schema       JSON Schema to flesh out
+     * @param string $propertyName Property to work on
+     * @param string $sourceUri    URI where this schema was located
+     */
+    public function resolveArrayOfSchemas($schema, $propertyName, $sourceUri)
+    {
+        if (! isset($schema->$propertyName) || ! is_array($schema->$propertyName)) {
+            return;
+        }
+
+        foreach ($schema->$propertyName as $possiblySchema) {
+            $this->resolve($possiblySchema, $sourceUri);
+        }
+    }
+
+    /**
+     * Given an object and a property name, that property should be an
+     * object whose properties are schema objects.
+     *
+     * @param object $schema       JSON Schema to flesh out
+     * @param string $propertyName Property to work on
+     * @param string $sourceUri    URI where this schema was located
+     */
+    public function resolveObjectOfSchemas($schema, $propertyName, $sourceUri)
+    {
+        if (! isset($schema->$propertyName) || ! is_object($schema->$propertyName)) {
+            return;
+        }
+
+        foreach (get_object_vars($schema->$propertyName) as $possiblySchema) {
+            $this->resolve($possiblySchema, $sourceUri);
+        }
+    }
+
+    /**
+     * Given an object and a property name, that property should be a
+     * schema object.
+     *
+     * @param object $schema       JSON Schema to flesh out
+     * @param string $propertyName Property to work on
+     * @param string $sourceUri    URI where this schema was located
+     */
+    public function resolveProperty($schema, $propertyName, $sourceUri)
+    {
+        if (! isset($schema->$propertyName)) {
+            return;
+        }
+
+        $this->resolve($schema->$propertyName, $sourceUri);
+    }
+
+    /**
+     * Look for the $ref property in the object.  If found, remove the
+     * reference and augment this object with the contents of another
+     * schema.
+     *
+     * @param object $schema    JSON Schema to flesh out
+     * @param string $sourceUri URI where this schema was located
+     */
+    public function resolveRef($schema, $sourceUri)
+    {
+        $ref = '$ref';
+
+        if (empty($schema->$ref)) {
+            return;
+        }
+
+        $splitRef = explode('#', $schema->$ref, 2);
+
+        $refDoc = $splitRef[0];
+        $refPath = null;
+        if (count($splitRef) === 2) {
+            $refPath = explode('/', $splitRef[1]);
+            array_shift($refPath);
+        }
+
+        if (empty($refDoc) && empty($refPath)) {
+            // TODO: Not yet implemented - root pointer ref, causes recursion issues
+            return;
+        }
+
+        if (!empty($refDoc)) {
+            $refSchema = $this->fetchRef($refDoc, $sourceUri);
+        } else {
+            $refSchema = $this->rootSchema;
+        }
+
+        if (null !== $refPath) {
+            $refSchema = $this->resolveRefSegment($refSchema, $refPath);
+        }
+
+        unset($schema->$ref);
+
+        // Augment the current $schema object with properties fetched
+        foreach (get_object_vars($refSchema) as $prop => $value) {
+            $schema->$prop = $value;
+        }
+    }
+
+    /**
+     * Set URI Retriever for use with the Ref Resolver
+     *
+     * @param UriRetriever $retriever
+     * @return $this for chaining
+     */
+    public function setUriRetriever(UriRetriever $retriever)
+    {
+        $this->uriRetriever = $retriever;
+
+        return $this;
+    }
+
+    protected function resolveRefSegment($data, $pathParts)
+    {
+        foreach ($pathParts as $path) {
+            $path = strtr($path, array('~1' => '/', '~0' => '~', '%25' => '%'));
+
+            if (is_array($data)) {
+                $data = $data[$path];
+            } else {
+                $data = $data->{$path};
+            }
+        }
+
+        return $data;
+    }
+}