RubyGems - json_schemer - Versions diffs - 0.2.9 → 0.2.14 - Mend

json_schemer 0.2.9 → 0.2.14

Files changed (239) hide show

data/JSON-Schema-Test-Suite/.gitignore DELETED

	@@ -1 +0,0 @@
1	- TODO

data/JSON-Schema-Test-Suite/.travis.yml DELETED

@@ -1,8 +0,0 @@
-language: python
-python: "3.7"
-node_js: "9"
-install:
-  - pip install tox
-script:
-  - tox
-  - npm install && npm test || true

data/JSON-Schema-Test-Suite/LICENSE DELETED

@@ -1,19 +0,0 @@
-Copyright (c) 2012 Julian Berman
-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/JSON-Schema-Test-Suite/README.md DELETED

@@ -1,181 +0,0 @@
-JSON Schema Test Suite [![Build Status](https://travis-ci.org/json-schema-org/JSON-Schema-Test-Suite.svg?branch=master)](https://travis-ci.org/json-schema-org/JSON-Schema-Test-Suite)
-======================
-This repository contains a set of JSON objects that implementors of JSON Schema
-validation libraries can use to test their validators.
-It is meant to be language agnostic and should require only a JSON parser.
-The conversion of the JSON objects into tests within your test framework of
-choice is still the job of the validator implementor.
-Structure of a Test
--------------------
-If you're going to use this suite, you need to know how tests are laid out. The
-tests are contained in the `tests` directory at the root of this repository.
-Inside that directory is a subdirectory for each draft or version of the
-schema.
-If you look inside the draft directory, there are a number of `.json` files,
-which logically group a set of test cases together. Often the grouping is by
-property under test, but not always, especially within optional test files
-(discussed below).
-Inside each `.json` file is a single array containing objects. It's easiest to
-illustrate the structure of these with an example:
-```json
-    {
-        "description": "the description of the test case",
-        "schema": {"the schema that should" : "be validated against"},
-        "tests": [
-            {
-                "description": "a specific test of a valid instance",
-                "data": "the instance",
-                "valid": true
-            },
-            {
-                "description": "another specific test this time, invalid",
-                "data": 15,
-                "valid": false
-            }
-        ]
-    }
-```
-So a description, a schema, and some tests, where tests is an array containing
-one or more objects with descriptions, data, and a boolean indicating whether
-they should be valid or invalid.
-Coverage
---------
-Drafts 03, 04, 06, and 07 should have full coverage, with drafts 06 and 07
-being considered current and actively supported.  Bug fixes will be made as
-needed for draft-04 as it is still the most widely used, while draft-03
-is long since deprecated.
-If you see anything missing from the current supported drafts, or incorrect
-on any draft still accepting bug fixes, please file an issue or submit a PR.
-Who Uses the Test Suite
------------------------
-This suite is being used by:
-### Clojure ###
-* [jinx](https://github.com/juxt/jinx)
-* [json-schema](https://github.com/tatut/json-schema)
-### Coffeescript ###
-* [jsck](https://github.com/pandastrike/jsck)
-### C++ ###
-* [Modern C++ JSON schema validator](https://github.com/pboettch/json-schema-validator)
-### Dart ###
-* [json_schema](https://github.com/patefacio/json_schema)
-### Elixir ###
-* [ex_json_schema](https://github.com/jonasschmidt/ex_json_schema)
-### Erlang ###
-* [jesse](https://github.com/for-GET/jesse)
-### Go ###
-* [gojsonschema](https://github.com/sigu-399/gojsonschema)
-* [validate-json](https://github.com/cesanta/validate-json)
-### Haskell ###
-* [aeson-schema](https://github.com/timjb/aeson-schema)
-* [hjsonschema](https://github.com/seagreen/hjsonschema)
-### Java ###
-* [json-schema-validator](https://github.com/daveclayton/json-schema-validator)
-* [everit-org/json-schema](https://github.com/everit-org/json-schema)
-* [networknt/json-schema-validator](https://github.com/networknt/json-schema-validator)
-* [Justify](https://github.com/leadpony/justify)
-### JavaScript ###
-* [json-schema-benchmark](https://github.com/Muscula/json-schema-benchmark)
-* [direct-schema](https://github.com/IreneKnapp/direct-schema)
-* [is-my-json-valid](https://github.com/mafintosh/is-my-json-valid)
-* [jassi](https://github.com/iclanzan/jassi)
-* [JaySchema](https://github.com/natesilva/jayschema)
-* [json-schema-valid](https://github.com/ericgj/json-schema-valid)
-* [Jsonary](https://github.com/jsonary-js/jsonary)
-* [jsonschema](https://github.com/tdegrunt/jsonschema)
-* [request-validator](https://github.com/bugventure/request-validator)
-* [skeemas](https://github.com/Prestaul/skeemas)
-* [tv4](https://github.com/geraintluff/tv4)
-* [z-schema](https://github.com/zaggino/z-schema)
-* [jsen](https://github.com/bugventure/jsen)
-* [ajv](https://github.com/epoberezkin/ajv)
-* [djv](https://github.com/korzio/djv)
-### Node.js ###
-For node.js developers, the suite is also available as an
-[npm](https://www.npmjs.com/package/@json-schema-org/tests) package.
-Node-specific support is maintained in a [separate
-repository](https://github.com/json-schema-org/json-schema-test-suite-npm)
-which also welcomes your contributions!
-### .NET ###
-* [Newtonsoft.Json.Schema](https://github.com/JamesNK/Newtonsoft.Json.Schema)
-* [Manatee.Json](https://github.com/gregsdennis/Manatee.Json)
-### PHP ###
-* [json-schema](https://github.com/justinrainbow/json-schema)
-* [json-guard](https://github.com/thephpleague/json-guard)
-### PostgreSQL ###
-* [postgres-json-schema](https://github.com/gavinwahl/postgres-json-schema)
-* [is_jsonb_valid](https://github.com/furstenheim/is_jsonb_valid)
-### Python ###
-* [jsonschema](https://github.com/Julian/jsonschema)
-* [fastjsonschema](https://github.com/seznam/python-fastjsonschema)
-* [hypothesis-jsonschema](https://github.com/Zac-HD/hypothesis-jsonschema)
-### Ruby ###
-* [json-schema](https://github.com/hoxworth/json-schema)
-* [json_schemer](https://github.com/davishmcclurg/json_schemer)
-### Rust ###
-* [valico](https://github.com/rustless/valico)
-### Swift ###
-* [JSONSchema](https://github.com/kylef/JSONSchema.swift)
-If you use it as well, please fork and send a pull request adding yourself to
-the list :).
-Contributing
-------------
-If you see something missing or incorrect, a pull request is most welcome!
-There are some sanity checks in place for testing the test suite. You can run
-them with `bin/jsonschema_suite check && npm test` or `tox && npm test`. They will be run automatically by
-[Travis CI](https://travis-ci.org/) as well.

data/JSON-Schema-Test-Suite/bin/jsonschema_suite DELETED

@@ -1,298 +0,0 @@
-#! /usr/bin/env python3
-from __future__ import print_function
-from pprint import pformat
-import argparse
-import errno
-import fnmatch
-import json
-import os
-import random
-import shutil
-import sys
-import textwrap
-import unittest
-import warnings
-if getattr(unittest, "skipIf", None) is None:
-    unittest.skipIf = lambda cond, msg : lambda fn : fn
-try:
-    import jsonschema
-except ImportError:
-    jsonschema = None
-else:
-    validators = getattr(
-        jsonschema.validators, "validators", jsonschema.validators
-    )
-ROOT_DIR = os.path.abspath(
-    os.path.join(os.path.dirname(__file__), os.pardir).rstrip("__pycache__"),
-)
-SUITE_ROOT_DIR = os.path.join(ROOT_DIR, "tests")
-REMOTES = {
-    "integer.json": {u"type": u"integer"},
-    "name.json": {
-        u"type": "string",
-        u"definitions": {
-            u"orNull": {u"anyOf": [{u"type": u"null"}, {u"$ref": u"#"}]},
-        },
-    },
-    "name-defs.json": {
-        u"type": "string",
-        u"$defs": {
-            u"orNull": {u"anyOf": [{u"type": u"null"}, {u"$ref": u"#"}]},
-        },
-    },
-    "subSchemas.json": {
-        u"integer": {u"type": u"integer"},
-        u"refToInteger": {u"$ref": u"#/integer"},
-    },
-    "folder/folderInteger.json": {u"type": u"integer"}
-}
-REMOTES_DIR = os.path.join(ROOT_DIR, "remotes")
-with open(os.path.join(ROOT_DIR, "test-schema.json")) as schema:
-    TESTSUITE_SCHEMA = json.load(schema)
-def files(paths):
-    for path in paths:
-        with open(path) as test_file:
-            yield json.load(test_file)
-def groups(paths):
-    for test_file in files(paths):
-        for group in test_file:
-            yield group
-def cases(paths):
-    for test_group in groups(paths):
-        for test in test_group["tests"]:
-            test["schema"] = test_group["schema"]
-            yield test
-def collect(root_dir):
-    for root, dirs, files in os.walk(root_dir):
-        for filename in fnmatch.filter(files, "*.json"):
-            yield os.path.join(root, filename)
-class SanityTests(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        print("Looking for tests in %s" % SUITE_ROOT_DIR)
-        cls.test_files = list(collect(SUITE_ROOT_DIR))
-        print("Found %s test files" % len(cls.test_files))
-        assert cls.test_files, "Didn't find the test files!"
-    def test_all_files_are_valid_json(self):
-        for path in self.test_files:
-            with open(path) as test_file:
-                try:
-                    json.load(test_file)
-                except ValueError as error:
-                    self.fail("%s contains invalid JSON (%s)" % (path, error))
-    def test_all_descriptions_have_reasonable_length(self):
-        for case in cases(self.test_files):
-            description = case["description"]
-            self.assertLess(
-                len(description),
-                70,
-                "%r is too long! (keep it to less than 70 chars)" % (
-                    description,
-                ),
-            )
-    def test_all_descriptions_are_unique(self):
-        for group in groups(self.test_files):
-            descriptions = set(test["description"] for test in group["tests"])
-            self.assertEqual(
-                len(descriptions),
-                len(group["tests"]),
-                "%r contains a duplicate description" % (group,)
-            )
-    @unittest.skipIf(jsonschema is None, "Validation library not present!")
-    def test_all_schemas_are_valid(self):
-        for schema in os.listdir(SUITE_ROOT_DIR):
-            schema_validator = validators.get(schema)
-            if schema_validator is not None:
-                test_files = collect(os.path.join(SUITE_ROOT_DIR, schema))
-                for case in cases(test_files):
-                    try:
-                        schema_validator.check_schema(case["schema"])
-                    except jsonschema.SchemaError as error:
-                        self.fail("%s contains an invalid schema (%s)" %
-                                  (case, error))
-            else:
-                warnings.warn("No schema validator for %s" % schema)
-    @unittest.skipIf(jsonschema is None, "Validation library not present!")
-    def test_suites_are_valid(self):
-        validator = jsonschema.Draft4Validator(TESTSUITE_SCHEMA)
-        for tests in files(self.test_files):
-            try:
-                validator.validate(tests)
-            except jsonschema.ValidationError as error:
-                self.fail(str(error))
-    def test_remote_schemas_are_updated(self):
-        files = {}
-        for parent, _, paths in os.walk(REMOTES_DIR):
-            for path in paths:
-                absolute_path = os.path.join(parent, path)
-                with open(absolute_path) as schema_file:
-                    files[absolute_path] = json.load(schema_file)
-        expected = {
-            os.path.join(REMOTES_DIR, path): contents
-            for path, contents in REMOTES.items()
-        }
-        missing = set(files).symmetric_difference(expected)
-        changed = {
-            path
-            for path, contents in expected.items()
-            if path in files
-            and contents != files[path]
-        }
-        self.assertEqual(
-            files,
-            expected,
-            msg=textwrap.dedent(
-                """
-                Remotes in the remotes/ directory do not match those in the
-                ``jsonschema_suite`` Python script.
-                Unfortunately for the minute, each remote file is duplicated in
-                two places.""" + ("""
-                Only present in one location:
-                {}""".format("\n".join(missing)) if missing else "") + ("""
-                Conflicting between the two:
-                {}""".format("\n".join(changed)) if changed else "")
-            )
-        )
-def main(arguments):
-    if arguments.command == "check":
-        suite = unittest.TestLoader().loadTestsFromTestCase(SanityTests)
-        result = unittest.TextTestRunner(verbosity=2).run(suite)
-        sys.exit(not result.wasSuccessful())
-    elif arguments.command == "flatten":
-        selected_cases = [case for case in cases(collect(arguments.version))]
-        if arguments.randomize:
-            random.shuffle(selected_cases)
-        json.dump(selected_cases, sys.stdout, indent=4, sort_keys=True)
-    elif arguments.command == "remotes":
-        json.dump(REMOTES, sys.stdout, indent=4, sort_keys=True)
-    elif arguments.command == "dump_remotes":
-        if arguments.update:
-            shutil.rmtree(arguments.out_dir, ignore_errors=True)
-        try:
-            os.makedirs(arguments.out_dir)
-        except OSError as e:
-            if e.errno == errno.EEXIST:
-                print("%s already exists. Aborting." % arguments.out_dir)
-                sys.exit(1)
-            raise
-        for url, schema in REMOTES.items():
-            filepath = os.path.join(arguments.out_dir, url)
-            try:
-                os.makedirs(os.path.dirname(filepath))
-            except OSError as e:
-                if e.errno != errno.EEXIST:
-                    raise
-            with open(filepath, "w") as out_file:
-                json.dump(schema, out_file, indent=4, sort_keys=True)
-                out_file.write("\n")
-    elif arguments.command == "serve":
-        try:
-            from flask import Flask, jsonify
-        except ImportError:
-            print(textwrap.dedent("""
-                The Flask library is required to serve the remote schemas.
-                You can install it by running `pip install Flask`.
-                Alternatively, see the `jsonschema_suite remotes` or
-                `jsonschema_suite dump_remotes` commands to create static files
-                that can be served with your own web server.
-            """.strip("\n")))
-            sys.exit(1)
-        app = Flask(__name__)
-        @app.route("/<path:path>")
-        def serve_path(path):
-            if path in REMOTES:
-                return jsonify(REMOTES[path])
-            return "Document does not exist.", 404
-        app.run(port=1234)
-parser = argparse.ArgumentParser(
-    description="JSON Schema Test Suite utilities",
-)
-subparsers = parser.add_subparsers(help="utility commands", dest="command")
-check = subparsers.add_parser("check", help="Sanity check the test suite.")
-flatten = subparsers.add_parser(
-    "flatten",
-    help="Output a flattened file containing a selected version's test cases."
-)
-flatten.add_argument(
-    "--randomize",
-    action="store_true",
-    help="Randomize the order of the outputted cases.",
-)
-flatten.add_argument(
-    "version", help="The directory containing the version to output",
-)
-remotes = subparsers.add_parser(
-    "remotes",
-    help="Output the expected URLs and their associated schemas for remote "
-         "ref tests as a JSON object."
-)
-dump_remotes = subparsers.add_parser(
-    "dump_remotes", help="Dump the remote ref schemas into a file tree",
-)
-dump_remotes.add_argument(
-    "--update",
-    action="store_true",
-    help="Update the remotes in an existing directory.",
-)
-dump_remotes.add_argument(
-    "--out-dir",
-    default=REMOTES_DIR,
-    type=os.path.abspath,
-    help="The output directory to create as the root of the file tree",
-)
-serve = subparsers.add_parser(
-    "serve",
-    help="Start a webserver to serve schemas used by remote ref tests."
-)
-if __name__ == "__main__":
-    main(parser.parse_args())