dependabot-composer 0.95.62 → 0.95.63

data/helpers/vendor/justinrainbow/json-schema/.gitattributes

@@ -0,0 +1,5 @@
+/docs               export-ignore
+/tests              export-ignore
+.gitignore          export-ignore
+.travis.yml         export-ignore
+phpunit.dist.xml    export-ignore

data/helpers/vendor/justinrainbow/json-schema/.php_cs.dist

@@ -0,0 +1,33 @@
+<?php
+
+$finder = new PhpCsFixer\Finder();
+$config = new PhpCsFixer\Config('json-schema');
+$finder->in(__DIR__);
+
+/* Based on ^2.1 of php-cs-fixer */
+$config
+    ->setRules(array(
+        // default
+        '@PSR2' => true,
+        '@Symfony' => true,
+        // additionally
+        'align_multiline_comment' => array('comment_type' => 'phpdocs_like'),
+        'array_syntax' => array('syntax' => 'long'),
+        'binary_operator_spaces' => false,
+        'concat_space' => array('spacing' => 'one'),
+        'increment_style' => false,
+        'no_useless_else' => true,
+        'no_useless_return' => true,
+        'ordered_imports' => true,
+        'phpdoc_no_package' => false,
+        'phpdoc_order' => true,
+        'phpdoc_summary' => false,
+        'pre_increment' => false,
+        'simplified_null_return' => false,
+        'trailing_comma_in_multiline_array' => false,
+        'yoda_style' => null,
+    ))
+    ->setFinder($finder)
+;
+
+return $config;

data/helpers/vendor/justinrainbow/json-schema/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/helpers/vendor/justinrainbow/json-schema/README.md

@@ -0,0 +1,206 @@
+# JSON Schema for PHP
+
+[![Build Status](https://travis-ci.org/justinrainbow/json-schema.svg?branch=master)](https://travis-ci.org/justinrainbow/json-schema)
+[![Latest Stable Version](https://poser.pugx.org/justinrainbow/json-schema/v/stable.png)](https://packagist.org/packages/justinrainbow/json-schema)
+[![Total Downloads](https://poser.pugx.org/justinrainbow/json-schema/downloads.png)](https://packagist.org/packages/justinrainbow/json-schema)
+
+A PHP Implementation for validating `JSON` Structures against a given `Schema`.
+
+See [json-schema](http://json-schema.org/) for more details.
+
+## Installation
+
+### Library
+
+```bash
+git clone https://github.com/justinrainbow/json-schema.git
+```
+
+### Composer
+
+[Install PHP Composer](https://getcomposer.org/doc/00-intro.md)
+
+```bash
+composer require justinrainbow/json-schema
+```
+
+## Usage
+
+```php
+<?php
+
+$data = json_decode(file_get_contents('data.json'));
+
+// Validate
+$validator = new JsonSchema\Validator;
+$validator->validate($data, (object)['$ref' => 'file://' . realpath('schema.json')]);
+
+if ($validator->isValid()) {
+    echo "The supplied JSON validates against the schema.\n";
+} else {
+    echo "JSON does not validate. Violations:\n";
+    foreach ($validator->getErrors() as $error) {
+        echo sprintf("[%s] %s\n", $error['property'], $error['message']);
+    }
+}
+```
+
+### Type coercion
+
+If you're validating data passed to your application via HTTP, you can cast strings and booleans to
+the expected types defined by your schema:
+
+```php
+<?php
+
+use JsonSchema\SchemaStorage;
+use JsonSchema\Validator;
+use JsonSchema\Constraints\Factory;
+use JsonSchema\Constraints\Constraint;
+
+$request = (object)[
+    'processRefund'=>"true",
+    'refundAmount'=>"17"
+];
+
+$validator->validate(
+    $request, (object) [
+    "type"=>"object",
+        "properties"=>(object)[
+            "processRefund"=>(object)[
+                "type"=>"boolean"
+            ],
+            "refundAmount"=>(object)[
+                "type"=>"number"
+            ]
+        ]
+    ],
+    Constraint::CHECK_MODE_COERCE_TYPES
+); // validates!
+
+is_bool($request->processRefund); // true
+is_int($request->refundAmount); // true
+```
+
+A shorthand method is also available:
+```PHP
+$validator->coerce($request, $schema);
+// equivalent to $validator->validate($data, $schema, Constraint::CHECK_MODE_COERCE_TYPES);
+```
+
+### Default values
+
+If your schema contains default values, you can have these automatically applied during validation:
+
+```php
+<?php
+
+use JsonSchema\Validator;
+use JsonSchema\Constraints\Constraint;
+
+$request = (object)[
+    'refundAmount'=>17
+];
+
+$validator = new Validator();
+
+$validator->validate(
+    $request,
+    (object)[
+        "type"=>"object",
+        "properties"=>(object)[
+            "processRefund"=>(object)[
+                "type"=>"boolean",
+                "default"=>true
+            ]
+        ]
+    ],
+    Constraint::CHECK_MODE_APPLY_DEFAULTS
+); //validates, and sets defaults for missing properties
+
+is_bool($request->processRefund); // true
+$request->processRefund; // true
+```
+
+### With inline references
+
+```php
+<?php
+
+use JsonSchema\SchemaStorage;
+use JsonSchema\Validator;
+use JsonSchema\Constraints\Factory;
+
+$jsonSchema = <<<'JSON'
+{
+    "type": "object",
+    "properties": {
+        "data": {
+            "oneOf": [
+                { "$ref": "#/definitions/integerData" },
+                { "$ref": "#/definitions/stringData" }
+            ]
+        }
+    },
+    "required": ["data"],
+    "definitions": {
+        "integerData" : {
+            "type": "integer",
+            "minimum" : 0
+        },
+        "stringData" : {
+            "type": "string"
+        }
+    }
+}
+JSON;
+
+// Schema must be decoded before it can be used for validation
+$jsonSchemaObject = json_decode($jsonSchema);
+
+// The SchemaStorage can resolve references, loading additional schemas from file as needed, etc.
+$schemaStorage = new SchemaStorage();
+
+// This does two things:
+// 1) Mutates $jsonSchemaObject to normalize the references (to file://mySchema#/definitions/integerData, etc)
+// 2) Tells $schemaStorage that references to file://mySchema... should be resolved by looking in $jsonSchemaObject
+$schemaStorage->addSchema('file://mySchema', $jsonSchemaObject);
+
+// Provide $schemaStorage to the Validator so that references can be resolved during validation
+$jsonValidator = new Validator( new Factory($schemaStorage));
+
+// JSON must be decoded before it can be validated
+$jsonToValidateObject = json_decode('{"data":123}');
+
+// Do validation (use isValid() and getErrors() to check the result)
+$jsonValidator->validate($jsonToValidateObject, $jsonSchemaObject);
+```
+
+### Configuration Options
+A number of flags are available to alter the behavior of the validator. These can be passed as the
+third argument to `Validator::validate()`, or can be provided as the third argument to
+`Factory::__construct()` if you wish to persist them across multiple `validate()` calls.
+
+| Flag | Description |
+|------|-------------|
+| `Constraint::CHECK_MODE_NORMAL` | Validate in 'normal' mode - this is the default |
+| `Constraint::CHECK_MODE_TYPE_CAST` | Enable fuzzy type checking for associative arrays and objects |
+| `Constraint::CHECK_MODE_COERCE_TYPES` | Convert data types to match the schema where possible |
+| `Constraint::CHECK_MODE_APPLY_DEFAULTS` | Apply default values from the schema if not set |
+| `Constraint::CHECK_MODE_ONLY_REQUIRED_DEFAULTS` | When applying defaults, only set values that are required |
+| `Constraint::CHECK_MODE_EXCEPTIONS` | Throw an exception immediately if validation fails |
+| `Constraint::CHECK_MODE_DISABLE_FORMAT` | Do not validate "format" constraints |
+| `Constraint::CHECK_MODE_VALIDATE_SCHEMA` | Validate the schema as well as the provided document |
+
+Please note that using `Constraint::CHECK_MODE_COERCE_TYPES` or `Constraint::CHECK_MODE_APPLY_DEFAULTS`
+will modify your original data.
+
+## Running the tests
+
+```bash
+composer test                            # run all unit tests
+composer testOnly TestClass              # run specific unit test class
+composer testOnly TestClass::testMethod  # run specific unit test method
+composer style-check                     # check code style for errors
+composer style-fix                       # automatically fix code style errors
+```

data/helpers/vendor/justinrainbow/json-schema/bin/validate-json

@@ -0,0 +1,251 @@
+#!/usr/bin/env php
+<?php
+/**
+ * JSON schema validator
+ *
+ * @author Christian Weiske <christian.weiske@netresearch.de>
+ */
+
+/**
+ * Dead simple autoloader
+ *
+ * @param string $className Name of class to load
+ *
+ * @return void
+ */
+function __autoload($className)
+{
+    $className = ltrim($className, '\\');
+    $fileName  = '';
+    if ($lastNsPos = strrpos($className, '\\')) {
+        $namespace = substr($className, 0, $lastNsPos);
+        $className = substr($className, $lastNsPos + 1);
+        $fileName  = str_replace('\\', DIRECTORY_SEPARATOR, $namespace) . DIRECTORY_SEPARATOR;
+    }
+    $fileName .= str_replace('_', DIRECTORY_SEPARATOR, $className) . '.php';
+    if (stream_resolve_include_path($fileName)) {
+        require_once $fileName;
+    }
+}
+
+// support running this tool from git checkout
+if (is_dir(__DIR__ . '/../src/JsonSchema')) {
+    set_include_path(__DIR__ . '/../src' . PATH_SEPARATOR . get_include_path());
+}
+
+$arOptions = array();
+$arArgs = array();
+array_shift($argv);//script itself
+foreach ($argv as $arg) {
+    if ($arg{0} == '-') {
+        $arOptions[$arg] = true;
+    } else {
+        $arArgs[] = $arg;
+    }
+}
+
+if (count($arArgs) == 0
+    || isset($arOptions['--help']) || isset($arOptions['-h'])
+) {
+    echo <<<HLP
+Validate schema
+Usage: validate-json data.json
+   or: validate-json data.json schema.json
+
+Options:
+      --dump-schema     Output full schema and exit
+      --dump-schema-url Output URL of schema
+      --verbose         Show additional output
+      --quiet           Suppress all output
+   -h --help            Show this help
+
+HLP;
+    exit(1);
+}
+
+if (count($arArgs) == 1) {
+    $pathData   = $arArgs[0];
+    $pathSchema = null;
+} else {
+    $pathData   = $arArgs[0];
+    $pathSchema = getUrlFromPath($arArgs[1]);
+}
+
+/**
+ * Show the json parse error that happened last
+ *
+ * @return void
+ */
+function showJsonError()
+{
+    $constants = get_defined_constants(true);
+    $json_errors = array();
+    foreach ($constants['json'] as $name => $value) {
+        if (!strncmp($name, 'JSON_ERROR_', 11)) {
+            $json_errors[$value] = $name;
+        }
+    }
+
+    output('JSON parse error: ' . $json_errors[json_last_error()] . "\n");
+}
+
+function getUrlFromPath($path)
+{
+    if (parse_url($path, PHP_URL_SCHEME) !== null) {
+        //already an URL
+        return $path;
+    }
+    if ($path{0} == '/') {
+        //absolute path
+        return 'file://' . $path;
+    }
+
+    //relative path: make absolute
+    return 'file://' . getcwd() . '/' . $path;
+}
+
+/**
+ * Take a HTTP header value and split it up into parts.
+ *
+ * @param $headerValue
+ * @return array Key "_value" contains the main value, all others
+ *               as given in the header value
+ */
+function parseHeaderValue($headerValue)
+{
+    if (strpos($headerValue, ';') === false) {
+        return array('_value' => $headerValue);
+    }
+
+    $parts = explode(';', $headerValue);
+    $arData = array('_value' => array_shift($parts));
+    foreach ($parts as $part) {
+        list($name, $value) = explode('=', $part);
+        $arData[$name] = trim($value, ' "\'');
+    }
+    return $arData;
+}
+
+/**
+ * Send a string to the output stream, but only if --quiet is not enabled
+ *
+ * @param $str A string output
+ */
+function output($str) {
+    global $arOptions;
+    if (!isset($arOptions['--quiet'])) {
+        echo $str;
+    }
+}
+
+$urlData = getUrlFromPath($pathData);
+
+$context = stream_context_create(
+    array(
+        'http' => array(
+            'header'        => array(
+                'Accept: */*',
+                'Connection: Close'
+            ),
+            'max_redirects' => 5
+        )
+    )
+);
+$dataString = file_get_contents($pathData, false, $context);
+if ($dataString == '') {
+    output("Data file is not readable or empty.\n");
+    exit(3);
+}
+
+$data = json_decode($dataString);
+unset($dataString);
+if ($data === null) {
+    output("Error loading JSON data file\n");
+    showJsonError();
+    exit(5);
+}
+
+if ($pathSchema === null) {
+    if (isset($http_response_header)) {
+        array_shift($http_response_header);//HTTP/1.0 line
+        foreach ($http_response_header as $headerLine) {
+            list($hName, $hValue) = explode(':', $headerLine, 2);
+            $hName = strtolower($hName);
+            if ($hName == 'link') {
+                //Link: <http://example.org/schema#>; rel="describedBy"
+                $hParts = parseHeaderValue($hValue);
+                if (isset($hParts['rel']) && $hParts['rel'] == 'describedBy') {
+                    $pathSchema = trim($hParts['_value'], ' <>');
+                }
+            } else if ($hName == 'content-type') {
+                //Content-Type: application/my-media-type+json;
+                //              profile=http://example.org/schema#
+                $hParts = parseHeaderValue($hValue);
+                if (isset($hParts['profile'])) {
+                    $pathSchema = $hParts['profile'];
+                }
+
+            }
+        }
+    }
+    if (is_object($data) && property_exists($data, '$schema')) {
+        $pathSchema = $data->{'$schema'};
+    }
+
+    //autodetect schema
+    if ($pathSchema === null) {
+        output("JSON data must be an object and have a \$schema property.\n");
+        output("You can pass the schema file on the command line as well.\n");
+        output("Schema autodetection failed.\n");
+        exit(6);
+    }
+}
+if ($pathSchema{0} == '/') {
+    $pathSchema = 'file://' . $pathSchema;
+}
+
+$resolver = new JsonSchema\Uri\UriResolver();
+$retriever = new JsonSchema\Uri\UriRetriever();
+try {
+    $urlSchema = $resolver->resolve($pathSchema, $urlData);
+
+    if (isset($arOptions['--dump-schema-url'])) {
+        echo $urlSchema . "\n";
+        exit();
+    }
+} catch (Exception $e) {
+    output("Error loading JSON schema file\n");
+    output($urlSchema . "\n");
+    output($e->getMessage() . "\n");
+    exit(2);
+}
+$refResolver = new JsonSchema\SchemaStorage($retriever, $resolver);
+$schema = $refResolver->resolveRef($urlSchema);
+
+if (isset($arOptions['--dump-schema'])) {
+    $options = defined('JSON_PRETTY_PRINT') ? JSON_PRETTY_PRINT : 0;
+    echo json_encode($schema, $options) . "\n";
+    exit();
+}
+
+try {
+    $validator = new JsonSchema\Validator();
+    $validator->check($data, $schema);
+
+    if ($validator->isValid()) {
+        if(isset($arOptions['--verbose'])) {
+            output("OK. The supplied JSON validates against the schema.\n");
+        }
+    } else {
+        output("JSON does not validate. Violations:\n");
+        foreach ($validator->getErrors() as $error) {
+            output(sprintf("[%s] %s\n", $error['property'], $error['message']));
+        }
+        exit(23);
+    }
+} catch (Exception $e) {
+    output("JSON does not validate. Error:\n");
+    output($e->getMessage() . "\n");
+    output("Error code: " . $e->getCode() . "\n");
+    exit(24);
+}