├── .ackrc ├── .editorconfig ├── .gitattributes ├── .github └── workflows │ ├── ci.yml │ ├── website-build.yml │ └── website-deploy.yml ├── .gitignore ├── Brewfile ├── CMakeLists.txt ├── DEPENDENCIES ├── LICENSE ├── Makefile ├── README.markdown ├── assets └── banner.png ├── benchmark ├── CMakeLists.txt ├── compiler_2019_09.cc ├── compiler_draft6.cc ├── evaluator_2019_09.cc ├── evaluator_2020_12.cc ├── evaluator_draft4.cc ├── evaluator_draft6.cc ├── evaluator_draft7.cc ├── instances │ ├── 2019_09_omc_json_v2_1.json │ ├── 2020_12_cql_1.json │ ├── 2020_12_openapi_1.json │ ├── draft7_dependabot_1.json │ ├── draft7_helm_chart_lock_1.json │ ├── draft7_helm_chart_lock_2.json │ ├── draft7_jasmine_1.json │ └── draft7_vercel_1.json └── schemas │ ├── 2019_09_omc_json_v2.json │ ├── 2020_12_cql.json │ ├── 2020_12_openapi.json │ ├── draft6_adaptivecard.json │ ├── draft7_dependabot.json │ ├── draft7_helm_chart_lock.json │ ├── draft7_jasmine.json │ └── draft7_vercel.json ├── cmake └── FindCore.cmake ├── config.cmake.in ├── contrib ├── CMakeLists.txt ├── compile.cc ├── perf.cc ├── trace.cc ├── validate-diff.sh └── validate.cc ├── doxygen ├── Doxyfile.in ├── index.markdown └── logo.png ├── src ├── compiler │ ├── CMakeLists.txt │ ├── compile.cc │ ├── compile_describe.cc │ ├── compile_helpers.h │ ├── compile_output_simple.cc │ ├── compile_output_trace.cc │ ├── default_compiler.cc │ ├── default_compiler_2019_09.h │ ├── default_compiler_2020_12.h │ ├── default_compiler_draft4.h │ ├── default_compiler_draft6.h │ ├── default_compiler_draft7.h │ ├── include │ │ └── sourcemeta │ │ │ └── blaze │ │ │ ├── compiler.h │ │ │ ├── compiler_error.h │ │ │ ├── compiler_output.h │ │ │ └── compiler_unevaluated.h │ └── unevaluated.cc ├── evaluator │ ├── CMakeLists.txt │ ├── dispatch.inc.h │ ├── evaluator.cc │ ├── evaluator_complete.h │ ├── evaluator_dynamic.h │ ├── evaluator_fast.h │ ├── evaluator_string_set.cc │ ├── evaluator_track.h │ └── include │ │ └── sourcemeta │ │ └── blaze │ │ ├── evaluator.h │ │ ├── evaluator_error.h │ │ ├── evaluator_instruction.h │ │ ├── evaluator_string_set.h │ │ └── evaluator_value.h └── linter │ ├── CMakeLists.txt │ ├── include │ └── sourcemeta │ │ └── blaze │ │ └── linter.h │ ├── valid_default.cc │ └── valid_examples.cc ├── test ├── compiler │ ├── CMakeLists.txt │ ├── compiler_output_simple_test.cc │ ├── compiler_output_trace_test.cc │ ├── compiler_test_utils.h │ ├── compiler_unevaluated_2019_09_test.cc │ └── compiler_unevaluated_2020_12_test.cc ├── evaluator │ ├── CMakeLists.txt │ ├── evaluator_2019_09_test.cc │ ├── evaluator_2020_12_test.cc │ ├── evaluator_draft4_test.cc │ ├── evaluator_draft6_test.cc │ ├── evaluator_draft7_test.cc │ ├── evaluator_test.cc │ ├── evaluator_utils.h │ └── officialsuite.cc ├── linter │ ├── CMakeLists.txt │ ├── linter_valid_default_test.cc │ └── linter_valid_examples_test.cc └── packaging │ ├── CMakeLists.txt │ └── find_package │ ├── CMakeLists.txt │ └── hello.cc ├── vendor ├── core │ ├── CMakeLists.txt │ ├── LICENSE │ ├── cmake │ │ ├── FindBoostRegex.cmake │ │ ├── FindGoogleBenchmark.cmake │ │ ├── FindGoogleTest.cmake │ │ ├── FindUriParser.cmake │ │ ├── Findyaml.cmake │ │ ├── Sourcemeta.cmake │ │ └── common │ │ │ ├── commands │ │ │ └── copy-file.cmake │ │ │ ├── compiler │ │ │ ├── options.cmake │ │ │ ├── sanitizer.cmake │ │ │ └── simd.cmake │ │ │ ├── defaults.cmake │ │ │ ├── options │ │ │ └── enum.cmake │ │ │ ├── shim.cmake │ │ │ ├── targets │ │ │ ├── clang-format.cmake │ │ │ ├── clang-format.config │ │ │ ├── clang-tidy.cmake │ │ │ ├── clang-tidy.config │ │ │ ├── doxygen.cmake │ │ │ ├── executable.cmake │ │ │ ├── googlebenchmark.cmake │ │ │ ├── googletest.cmake │ │ │ ├── library.cmake │ │ │ └── shellcheck.cmake │ │ │ └── variables.cmake │ ├── config.cmake.in │ ├── src │ │ ├── core │ │ │ ├── json │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── grammar.h │ │ │ │ ├── include │ │ │ │ │ └── sourcemeta │ │ │ │ │ │ └── core │ │ │ │ │ │ ├── json.h │ │ │ │ │ │ ├── json_array.h │ │ │ │ │ │ ├── json_error.h │ │ │ │ │ │ ├── json_hash.h │ │ │ │ │ │ ├── json_object.h │ │ │ │ │ │ └── json_value.h │ │ │ │ ├── json.cc │ │ │ │ ├── json_value.cc │ │ │ │ ├── parser.h │ │ │ │ └── stringify.h │ │ │ ├── jsonl │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── grammar.h │ │ │ │ ├── include │ │ │ │ │ └── sourcemeta │ │ │ │ │ │ └── core │ │ │ │ │ │ ├── jsonl.h │ │ │ │ │ │ └── jsonl_iterator.h │ │ │ │ ├── iterator.cc │ │ │ │ └── jsonl.cc │ │ │ ├── jsonpointer │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── grammar.h │ │ │ │ ├── include │ │ │ │ │ └── sourcemeta │ │ │ │ │ │ └── core │ │ │ │ │ │ ├── jsonpointer.h │ │ │ │ │ │ ├── jsonpointer_error.h │ │ │ │ │ │ ├── jsonpointer_pointer.h │ │ │ │ │ │ ├── jsonpointer_position.h │ │ │ │ │ │ ├── jsonpointer_subpointer_walker.h │ │ │ │ │ │ ├── jsonpointer_template.h │ │ │ │ │ │ ├── jsonpointer_token.h │ │ │ │ │ │ └── jsonpointer_walker.h │ │ │ │ ├── jsonpointer.cc │ │ │ │ ├── parser.h │ │ │ │ ├── position.cc │ │ │ │ └── stringify.h │ │ │ ├── jsonschema │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── bundle.cc │ │ │ │ ├── frame.cc │ │ │ │ ├── include │ │ │ │ │ └── sourcemeta │ │ │ │ │ │ └── core │ │ │ │ │ │ ├── jsonschema.h │ │ │ │ │ │ ├── jsonschema_error.h │ │ │ │ │ │ ├── jsonschema_frame.h │ │ │ │ │ │ ├── jsonschema_resolver.h │ │ │ │ │ │ ├── jsonschema_transform.h │ │ │ │ │ │ ├── jsonschema_types.h │ │ │ │ │ │ └── jsonschema_walker.h │ │ │ │ ├── jsonschema.cc │ │ │ │ ├── official_resolver.cmake │ │ │ │ ├── official_resolver.in.cc │ │ │ │ ├── official_walker.cc │ │ │ │ ├── resolver.cc │ │ │ │ ├── transformer.cc │ │ │ │ └── walker.cc │ │ │ ├── regex │ │ │ │ ├── CMakeLists.txt │ │ │ │ └── include │ │ │ │ │ └── sourcemeta │ │ │ │ │ └── core │ │ │ │ │ └── regex.h │ │ │ ├── uri │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── escaping.cc │ │ │ │ ├── include │ │ │ │ │ └── sourcemeta │ │ │ │ │ │ └── core │ │ │ │ │ │ ├── uri.h │ │ │ │ │ │ ├── uri_error.h │ │ │ │ │ │ └── uri_escape.h │ │ │ │ └── uri.cc │ │ │ └── yaml │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── include │ │ │ │ └── sourcemeta │ │ │ │ │ └── core │ │ │ │ │ ├── yaml.h │ │ │ │ │ └── yaml_error.h │ │ │ │ └── yaml.cc │ │ └── extension │ │ │ └── alterschema │ │ │ ├── CMakeLists.txt │ │ │ ├── alterschema.cc │ │ │ ├── antipattern │ │ │ ├── const_with_type.h │ │ │ ├── duplicate_enum_values.h │ │ │ ├── duplicate_required_values.h │ │ │ ├── enum_with_type.h │ │ │ ├── exclusive_maximum_number_and_maximum.h │ │ │ └── exclusive_minimum_number_and_minimum.h │ │ │ ├── desugar │ │ │ ├── boolean_true.h │ │ │ ├── const_as_enum.h │ │ │ ├── exclusive_maximum_integer_to_maximum.h │ │ │ ├── exclusive_minimum_integer_to_minimum.h │ │ │ ├── type_array_to_any_of_2020_12.h │ │ │ ├── type_boolean_as_enum.h │ │ │ └── type_null_as_enum.h │ │ │ ├── implicit │ │ │ ├── max_contains_covered_by_max_items.h │ │ │ ├── min_items_given_min_contains.h │ │ │ ├── min_items_implicit.h │ │ │ ├── min_length_implicit.h │ │ │ ├── min_properties_covered_by_required.h │ │ │ ├── min_properties_implicit.h │ │ │ ├── multiple_of_implicit.h │ │ │ ├── properties_implicit.h │ │ │ └── type_union_implicit.h │ │ │ ├── include │ │ │ └── sourcemeta │ │ │ │ └── core │ │ │ │ └── alterschema.h │ │ │ ├── redundant │ │ │ ├── additional_properties_default.h │ │ │ ├── content_schema_default.h │ │ │ ├── dependencies_default.h │ │ │ ├── dependent_required_default.h │ │ │ ├── items_array_default.h │ │ │ ├── items_schema_default.h │ │ │ ├── pattern_properties_default.h │ │ │ ├── properties_default.h │ │ │ ├── unevaluated_items_default.h │ │ │ ├── unevaluated_properties_default.h │ │ │ ├── unsatisfiable_max_contains.h │ │ │ └── unsatisfiable_min_properties.h │ │ │ ├── simplify │ │ │ ├── dependencies_property_tautology.h │ │ │ ├── dependent_required_tautology.h │ │ │ ├── equal_numeric_bounds_to_enum.h │ │ │ ├── maximum_real_for_integer.h │ │ │ ├── minimum_real_for_integer.h │ │ │ └── single_type_array.h │ │ │ ├── superfluous │ │ │ ├── content_media_type_without_encoding.h │ │ │ ├── content_schema_without_media_type.h │ │ │ ├── drop_non_array_keywords_applicator_2019_09.h │ │ │ ├── drop_non_array_keywords_applicator_2020_12.h │ │ │ ├── drop_non_array_keywords_content_2019_09.h │ │ │ ├── drop_non_array_keywords_content_2020_12.h │ │ │ ├── drop_non_array_keywords_draft0.h │ │ │ ├── drop_non_array_keywords_draft1.h │ │ │ ├── drop_non_array_keywords_draft2.h │ │ │ ├── drop_non_array_keywords_draft3.h │ │ │ ├── drop_non_array_keywords_draft4.h │ │ │ ├── drop_non_array_keywords_draft6.h │ │ │ ├── drop_non_array_keywords_draft7.h │ │ │ ├── drop_non_array_keywords_format_2019_09.h │ │ │ ├── drop_non_array_keywords_format_2020_12.h │ │ │ ├── drop_non_array_keywords_unevaluated_2020_12.h │ │ │ ├── drop_non_array_keywords_validation_2019_09.h │ │ │ ├── drop_non_array_keywords_validation_2020_12.h │ │ │ ├── drop_non_boolean_keywords_applicator_2019_09.h │ │ │ ├── drop_non_boolean_keywords_applicator_2020_12.h │ │ │ ├── drop_non_boolean_keywords_content_2019_09.h │ │ │ ├── drop_non_boolean_keywords_content_2020_12.h │ │ │ ├── drop_non_boolean_keywords_draft0.h │ │ │ ├── drop_non_boolean_keywords_draft1.h │ │ │ ├── drop_non_boolean_keywords_draft2.h │ │ │ ├── drop_non_boolean_keywords_draft3.h │ │ │ ├── drop_non_boolean_keywords_draft4.h │ │ │ ├── drop_non_boolean_keywords_draft6.h │ │ │ ├── drop_non_boolean_keywords_draft7.h │ │ │ ├── drop_non_boolean_keywords_format_2019_09.h │ │ │ ├── drop_non_boolean_keywords_format_2020_12.h │ │ │ ├── drop_non_boolean_keywords_unevaluated_2020_12.h │ │ │ ├── drop_non_boolean_keywords_validation_2019_09.h │ │ │ ├── drop_non_boolean_keywords_validation_2020_12.h │ │ │ ├── drop_non_null_keywords_applicator_2019_09.h │ │ │ ├── drop_non_null_keywords_applicator_2020_12.h │ │ │ ├── drop_non_null_keywords_content_2019_09.h │ │ │ ├── drop_non_null_keywords_content_2020_12.h │ │ │ ├── drop_non_null_keywords_draft0.h │ │ │ ├── drop_non_null_keywords_draft1.h │ │ │ ├── drop_non_null_keywords_draft2.h │ │ │ ├── drop_non_null_keywords_draft3.h │ │ │ ├── drop_non_null_keywords_draft4.h │ │ │ ├── drop_non_null_keywords_draft6.h │ │ │ ├── drop_non_null_keywords_draft7.h │ │ │ ├── drop_non_null_keywords_format_2019_09.h │ │ │ ├── drop_non_null_keywords_format_2020_12.h │ │ │ ├── drop_non_null_keywords_unevaluated_2020_12.h │ │ │ ├── drop_non_null_keywords_validation_2019_09.h │ │ │ ├── drop_non_null_keywords_validation_2020_12.h │ │ │ ├── drop_non_numeric_keywords_applicator_2019_09.h │ │ │ ├── drop_non_numeric_keywords_applicator_2020_12.h │ │ │ ├── drop_non_numeric_keywords_content_2019_09.h │ │ │ ├── drop_non_numeric_keywords_content_2020_12.h │ │ │ ├── drop_non_numeric_keywords_draft0.h │ │ │ ├── drop_non_numeric_keywords_draft1.h │ │ │ ├── drop_non_numeric_keywords_draft2.h │ │ │ ├── drop_non_numeric_keywords_draft3.h │ │ │ ├── drop_non_numeric_keywords_draft4.h │ │ │ ├── drop_non_numeric_keywords_draft6.h │ │ │ ├── drop_non_numeric_keywords_draft7.h │ │ │ ├── drop_non_numeric_keywords_format_2019_09.h │ │ │ ├── drop_non_numeric_keywords_format_2020_12.h │ │ │ ├── drop_non_numeric_keywords_unevaluated_2020_12.h │ │ │ ├── drop_non_numeric_keywords_validation_2019_09.h │ │ │ ├── drop_non_numeric_keywords_validation_2020_12.h │ │ │ ├── drop_non_object_keywords_applicator_2019_09.h │ │ │ ├── drop_non_object_keywords_applicator_2020_12.h │ │ │ ├── drop_non_object_keywords_content_2019_09.h │ │ │ ├── drop_non_object_keywords_content_2020_12.h │ │ │ ├── drop_non_object_keywords_draft0.h │ │ │ ├── drop_non_object_keywords_draft1.h │ │ │ ├── drop_non_object_keywords_draft2.h │ │ │ ├── drop_non_object_keywords_draft3.h │ │ │ ├── drop_non_object_keywords_draft4.h │ │ │ ├── drop_non_object_keywords_draft6.h │ │ │ ├── drop_non_object_keywords_draft7.h │ │ │ ├── drop_non_object_keywords_format_2019_09.h │ │ │ ├── drop_non_object_keywords_format_2020_12.h │ │ │ ├── drop_non_object_keywords_unevaluated_2020_12.h │ │ │ ├── drop_non_object_keywords_validation_2019_09.h │ │ │ ├── drop_non_object_keywords_validation_2020_12.h │ │ │ ├── drop_non_string_keywords_applicator_2019_09.h │ │ │ ├── drop_non_string_keywords_applicator_2020_12.h │ │ │ ├── drop_non_string_keywords_draft0.h │ │ │ ├── drop_non_string_keywords_draft1.h │ │ │ ├── drop_non_string_keywords_draft2.h │ │ │ ├── drop_non_string_keywords_draft3.h │ │ │ ├── drop_non_string_keywords_draft4.h │ │ │ ├── drop_non_string_keywords_draft6.h │ │ │ ├── drop_non_string_keywords_draft7.h │ │ │ ├── drop_non_string_keywords_unevaluated_2020_12.h │ │ │ ├── drop_non_string_keywords_validation_2019_09.h │ │ │ ├── drop_non_string_keywords_validation_2020_12.h │ │ │ ├── duplicate_allof_branches.h │ │ │ ├── duplicate_anyof_branches.h │ │ │ ├── else_without_if.h │ │ │ ├── if_without_then_else.h │ │ │ ├── max_contains_without_contains.h │ │ │ ├── min_contains_without_contains.h │ │ │ └── then_without_if.h │ │ │ └── syntax_sugar │ │ │ └── enum_to_const.h │ └── vendor │ │ ├── boost-regex.mask │ │ ├── boost-regex │ │ └── include │ │ │ └── boost │ │ │ ├── cregex.hpp │ │ │ ├── regex.h │ │ │ ├── regex.hpp │ │ │ ├── regex │ │ │ ├── concepts.hpp │ │ │ ├── config.hpp │ │ │ ├── config │ │ │ │ ├── borland.hpp │ │ │ │ └── cwchar.hpp │ │ │ ├── icu.hpp │ │ │ ├── mfc.hpp │ │ │ ├── pattern_except.hpp │ │ │ ├── pending │ │ │ │ ├── object_cache.hpp │ │ │ │ ├── static_mutex.hpp │ │ │ │ └── unicode_iterator.hpp │ │ │ ├── regex_traits.hpp │ │ │ ├── user.hpp │ │ │ ├── v4 │ │ │ │ ├── basic_regex.hpp │ │ │ │ ├── basic_regex_creator.hpp │ │ │ │ ├── basic_regex_parser.hpp │ │ │ │ ├── c_regex_traits.hpp │ │ │ │ ├── char_regex_traits.hpp │ │ │ │ ├── cpp_regex_traits.hpp │ │ │ │ ├── cregex.hpp │ │ │ │ ├── error_type.hpp │ │ │ │ ├── icu.hpp │ │ │ │ ├── indexed_bit_flag.hpp │ │ │ │ ├── iterator_category.hpp │ │ │ │ ├── iterator_traits.hpp │ │ │ │ ├── match_flags.hpp │ │ │ │ ├── match_results.hpp │ │ │ │ ├── mem_block_cache.hpp │ │ │ │ ├── object_cache.hpp │ │ │ │ ├── pattern_except.hpp │ │ │ │ ├── perl_matcher.hpp │ │ │ │ ├── perl_matcher_common.hpp │ │ │ │ ├── perl_matcher_non_recursive.hpp │ │ │ │ ├── perl_matcher_recursive.hpp │ │ │ │ ├── primary_transform.hpp │ │ │ │ ├── protected_call.hpp │ │ │ │ ├── regbase.hpp │ │ │ │ ├── regex.hpp │ │ │ │ ├── regex_format.hpp │ │ │ │ ├── regex_fwd.hpp │ │ │ │ ├── regex_grep.hpp │ │ │ │ ├── regex_iterator.hpp │ │ │ │ ├── regex_match.hpp │ │ │ │ ├── regex_merge.hpp │ │ │ │ ├── regex_raw_buffer.hpp │ │ │ │ ├── regex_replace.hpp │ │ │ │ ├── regex_search.hpp │ │ │ │ ├── regex_split.hpp │ │ │ │ ├── regex_token_iterator.hpp │ │ │ │ ├── regex_traits.hpp │ │ │ │ ├── regex_traits_defaults.hpp │ │ │ │ ├── regex_workaround.hpp │ │ │ │ ├── states.hpp │ │ │ │ ├── sub_match.hpp │ │ │ │ ├── syntax_type.hpp │ │ │ │ ├── u32regex_iterator.hpp │ │ │ │ ├── u32regex_token_iterator.hpp │ │ │ │ ├── unicode_iterator.hpp │ │ │ │ └── w32_regex_traits.hpp │ │ │ └── v5 │ │ │ │ ├── basic_regex.hpp │ │ │ │ ├── basic_regex_creator.hpp │ │ │ │ ├── basic_regex_parser.hpp │ │ │ │ ├── c_regex_traits.hpp │ │ │ │ ├── char_regex_traits.hpp │ │ │ │ ├── cpp_regex_traits.hpp │ │ │ │ ├── cregex.hpp │ │ │ │ ├── error_type.hpp │ │ │ │ ├── icu.hpp │ │ │ │ ├── iterator_category.hpp │ │ │ │ ├── iterator_traits.hpp │ │ │ │ ├── match_flags.hpp │ │ │ │ ├── match_results.hpp │ │ │ │ ├── mem_block_cache.hpp │ │ │ │ ├── object_cache.hpp │ │ │ │ ├── pattern_except.hpp │ │ │ │ ├── perl_matcher.hpp │ │ │ │ ├── perl_matcher_common.hpp │ │ │ │ ├── perl_matcher_non_recursive.hpp │ │ │ │ ├── primary_transform.hpp │ │ │ │ ├── regbase.hpp │ │ │ │ ├── regex.hpp │ │ │ │ ├── regex_format.hpp │ │ │ │ ├── regex_fwd.hpp │ │ │ │ ├── regex_grep.hpp │ │ │ │ ├── regex_iterator.hpp │ │ │ │ ├── regex_match.hpp │ │ │ │ ├── regex_merge.hpp │ │ │ │ ├── regex_raw_buffer.hpp │ │ │ │ ├── regex_replace.hpp │ │ │ │ ├── regex_search.hpp │ │ │ │ ├── regex_split.hpp │ │ │ │ ├── regex_token_iterator.hpp │ │ │ │ ├── regex_traits.hpp │ │ │ │ ├── regex_traits_defaults.hpp │ │ │ │ ├── regex_workaround.hpp │ │ │ │ ├── states.hpp │ │ │ │ ├── sub_match.hpp │ │ │ │ ├── syntax_type.hpp │ │ │ │ ├── u32regex_iterator.hpp │ │ │ │ ├── u32regex_token_iterator.hpp │ │ │ │ ├── unicode_iterator.hpp │ │ │ │ └── w32_regex_traits.hpp │ │ │ └── regex_fwd.hpp │ │ ├── googlebenchmark │ │ ├── CMakeLists.txt │ │ ├── LICENSE │ │ ├── cmake │ │ │ ├── AddCXXCompilerFlag.cmake │ │ │ ├── CXXFeatureCheck.cmake │ │ │ ├── Config.cmake.in │ │ │ ├── GetGitVersion.cmake │ │ │ ├── GoogleTest.cmake │ │ │ ├── GoogleTest.cmake.in │ │ │ ├── Modules │ │ │ │ ├── FindLLVMAr.cmake │ │ │ │ ├── FindLLVMNm.cmake │ │ │ │ ├── FindLLVMRanLib.cmake │ │ │ │ └── FindPFM.cmake │ │ │ ├── benchmark.pc.in │ │ │ ├── benchmark_main.pc.in │ │ │ ├── gnu_posix_regex.cpp │ │ │ ├── llvm-toolchain.cmake │ │ │ ├── posix_regex.cpp │ │ │ ├── pthread_affinity.cpp │ │ │ ├── split_list.cmake │ │ │ ├── std_regex.cpp │ │ │ ├── steady_clock.cpp │ │ │ └── thread_safety_attributes.cpp │ │ ├── include │ │ │ └── benchmark │ │ │ │ ├── benchmark.h │ │ │ │ └── export.h │ │ └── src │ │ │ ├── CMakeLists.txt │ │ │ ├── arraysize.h │ │ │ ├── benchmark.cc │ │ │ ├── benchmark_api_internal.cc │ │ │ ├── benchmark_api_internal.h │ │ │ ├── benchmark_main.cc │ │ │ ├── benchmark_name.cc │ │ │ ├── benchmark_register.cc │ │ │ ├── benchmark_register.h │ │ │ ├── benchmark_runner.cc │ │ │ ├── benchmark_runner.h │ │ │ ├── check.cc │ │ │ ├── check.h │ │ │ ├── colorprint.cc │ │ │ ├── colorprint.h │ │ │ ├── commandlineflags.cc │ │ │ ├── commandlineflags.h │ │ │ ├── complexity.cc │ │ │ ├── complexity.h │ │ │ ├── console_reporter.cc │ │ │ ├── counter.cc │ │ │ ├── counter.h │ │ │ ├── csv_reporter.cc │ │ │ ├── cycleclock.h │ │ │ ├── internal_macros.h │ │ │ ├── json_reporter.cc │ │ │ ├── log.h │ │ │ ├── mutex.h │ │ │ ├── perf_counters.cc │ │ │ ├── perf_counters.h │ │ │ ├── re.h │ │ │ ├── reporter.cc │ │ │ ├── statistics.cc │ │ │ ├── statistics.h │ │ │ ├── string_util.cc │ │ │ ├── string_util.h │ │ │ ├── sysinfo.cc │ │ │ ├── thread_manager.h │ │ │ ├── thread_timer.h │ │ │ ├── timers.cc │ │ │ └── timers.h │ │ ├── googletest │ │ ├── CMakeLists.txt │ │ ├── LICENSE │ │ ├── googlemock │ │ │ ├── CMakeLists.txt │ │ │ ├── cmake │ │ │ │ ├── gmock.pc.in │ │ │ │ └── gmock_main.pc.in │ │ │ ├── include │ │ │ │ └── gmock │ │ │ │ │ ├── gmock-actions.h │ │ │ │ │ ├── gmock-cardinalities.h │ │ │ │ │ ├── gmock-function-mocker.h │ │ │ │ │ ├── gmock-matchers.h │ │ │ │ │ ├── gmock-more-actions.h │ │ │ │ │ ├── gmock-more-matchers.h │ │ │ │ │ ├── gmock-nice-strict.h │ │ │ │ │ ├── gmock-spec-builders.h │ │ │ │ │ ├── gmock.h │ │ │ │ │ └── internal │ │ │ │ │ ├── custom │ │ │ │ │ ├── README.md │ │ │ │ │ ├── gmock-generated-actions.h │ │ │ │ │ ├── gmock-matchers.h │ │ │ │ │ └── gmock-port.h │ │ │ │ │ ├── gmock-internal-utils.h │ │ │ │ │ ├── gmock-port.h │ │ │ │ │ └── gmock-pp.h │ │ │ └── src │ │ │ │ ├── gmock-all.cc │ │ │ │ ├── gmock-cardinalities.cc │ │ │ │ ├── gmock-internal-utils.cc │ │ │ │ ├── gmock-matchers.cc │ │ │ │ ├── gmock-spec-builders.cc │ │ │ │ ├── gmock.cc │ │ │ │ └── gmock_main.cc │ │ └── googletest │ │ │ ├── CMakeLists.txt │ │ │ ├── cmake │ │ │ ├── Config.cmake.in │ │ │ ├── gtest.pc.in │ │ │ ├── gtest_main.pc.in │ │ │ ├── internal_utils.cmake │ │ │ └── libgtest.la.in │ │ │ ├── include │ │ │ └── gtest │ │ │ │ ├── gtest-assertion-result.h │ │ │ │ ├── gtest-death-test.h │ │ │ │ ├── gtest-matchers.h │ │ │ │ ├── gtest-message.h │ │ │ │ ├── gtest-param-test.h │ │ │ │ ├── gtest-printers.h │ │ │ │ ├── gtest-spi.h │ │ │ │ ├── gtest-test-part.h │ │ │ │ ├── gtest-typed-test.h │ │ │ │ ├── gtest.h │ │ │ │ ├── gtest_pred_impl.h │ │ │ │ ├── gtest_prod.h │ │ │ │ └── internal │ │ │ │ ├── custom │ │ │ │ ├── README.md │ │ │ │ ├── gtest-port.h │ │ │ │ ├── gtest-printers.h │ │ │ │ └── gtest.h │ │ │ │ ├── gtest-death-test-internal.h │ │ │ │ ├── gtest-filepath.h │ │ │ │ ├── gtest-internal.h │ │ │ │ ├── gtest-param-util.h │ │ │ │ ├── gtest-port-arch.h │ │ │ │ ├── gtest-port.h │ │ │ │ ├── gtest-string.h │ │ │ │ └── gtest-type-util.h │ │ │ └── src │ │ │ ├── gtest-all.cc │ │ │ ├── gtest-assertion-result.cc │ │ │ ├── gtest-death-test.cc │ │ │ ├── gtest-filepath.cc │ │ │ ├── gtest-internal-inl.h │ │ │ ├── gtest-matchers.cc │ │ │ ├── gtest-port.cc │ │ │ ├── gtest-printers.cc │ │ │ ├── gtest-test-part.cc │ │ │ ├── gtest-typed-test.cc │ │ │ ├── gtest.cc │ │ │ └── gtest_main.cc │ │ ├── jsonschema-2019-09 │ │ ├── hyper-schema.json │ │ ├── links.json │ │ ├── meta │ │ │ ├── applicator.json │ │ │ ├── content.json │ │ │ ├── core.json │ │ │ ├── format.json │ │ │ ├── hyper-schema.json │ │ │ ├── meta-data.json │ │ │ └── validation.json │ │ ├── output │ │ │ ├── hyper-schema.json │ │ │ └── schema.json │ │ └── schema.json │ │ ├── jsonschema-2020-12 │ │ ├── hyper-schema.json │ │ ├── links.json │ │ ├── meta │ │ │ ├── applicator.json │ │ │ ├── content.json │ │ │ ├── core.json │ │ │ ├── format-annotation.json │ │ │ ├── format-assertion.json │ │ │ ├── hyper-schema.json │ │ │ ├── meta-data.json │ │ │ ├── unevaluated.json │ │ │ └── validation.json │ │ ├── output │ │ │ └── schema.json │ │ └── schema.json │ │ ├── jsonschema-draft0 │ │ ├── hyper-schema.json │ │ ├── json-ref.json │ │ ├── links.json │ │ └── schema.json │ │ ├── jsonschema-draft1 │ │ ├── hyper-schema.json │ │ ├── json-ref.json │ │ ├── links.json │ │ └── schema.json │ │ ├── jsonschema-draft2 │ │ ├── hyper-schema.json │ │ ├── json-ref.json │ │ ├── links.json │ │ └── schema.json │ │ ├── jsonschema-draft3 │ │ ├── hyper-schema.json │ │ ├── json-ref.json │ │ ├── links.json │ │ └── schema.json │ │ ├── jsonschema-draft4 │ │ ├── hyper-schema.json │ │ ├── links.json │ │ └── schema.json │ │ ├── jsonschema-draft6 │ │ ├── hyper-schema.json │ │ ├── links.json │ │ └── schema.json │ │ ├── jsonschema-draft7 │ │ ├── hyper-schema-output.json │ │ ├── hyper-schema.json │ │ ├── links.json │ │ └── schema.json │ │ ├── uriparser │ │ ├── COPYING │ │ ├── include │ │ │ └── uriparser │ │ │ │ ├── Uri.h │ │ │ │ ├── UriBase.h │ │ │ │ ├── UriDefsAnsi.h │ │ │ │ ├── UriDefsConfig.h │ │ │ │ ├── UriDefsUnicode.h │ │ │ │ └── UriIp4.h │ │ └── src │ │ │ ├── UriCommon.c │ │ │ ├── UriCommon.h │ │ │ ├── UriCompare.c │ │ │ ├── UriConfig.h.in │ │ │ ├── UriEscape.c │ │ │ ├── UriFile.c │ │ │ ├── UriIp4.c │ │ │ ├── UriIp4Base.c │ │ │ ├── UriIp4Base.h │ │ │ ├── UriMemory.c │ │ │ ├── UriMemory.h │ │ │ ├── UriNormalize.c │ │ │ ├── UriNormalizeBase.c │ │ │ ├── UriNormalizeBase.h │ │ │ ├── UriParse.c │ │ │ ├── UriParseBase.c │ │ │ ├── UriParseBase.h │ │ │ ├── UriQuery.c │ │ │ ├── UriRecompose.c │ │ │ ├── UriResolve.c │ │ │ └── UriShorten.c │ │ ├── yaml.mask │ │ └── yaml │ │ ├── License │ │ ├── include │ │ └── yaml.h │ │ └── src │ │ ├── api.c │ │ ├── dumper.c │ │ ├── emitter.c │ │ ├── loader.c │ │ ├── parser.c │ │ ├── reader.c │ │ ├── scanner.c │ │ ├── writer.c │ │ └── yaml_private.h ├── jsonschema-test-suite.mask ├── jsonschema-test-suite │ ├── LICENSE │ ├── remotes │ │ ├── baseUriChange │ │ │ └── folderInteger.json │ │ ├── baseUriChangeFolder │ │ │ └── folderInteger.json │ │ ├── baseUriChangeFolderInSubschema │ │ │ └── folderInteger.json │ │ ├── different-id-ref-string.json │ │ ├── draft2019-09 │ │ │ ├── baseUriChange │ │ │ │ └── folderInteger.json │ │ │ ├── baseUriChangeFolder │ │ │ │ └── folderInteger.json │ │ │ ├── baseUriChangeFolderInSubschema │ │ │ │ └── folderInteger.json │ │ │ ├── dependentRequired.json │ │ │ ├── detached-ref.json │ │ │ ├── extendible-dynamic-ref.json │ │ │ ├── ignore-prefixItems.json │ │ │ ├── integer.json │ │ │ ├── locationIndependentIdentifier.json │ │ │ ├── metaschema-no-validation.json │ │ │ ├── metaschema-optional-vocabulary.json │ │ │ ├── name-defs.json │ │ │ ├── nested │ │ │ │ ├── foo-ref-string.json │ │ │ │ └── string.json │ │ │ ├── ref-and-defs.json │ │ │ ├── subSchemas.json │ │ │ └── tree.json │ │ ├── draft2020-12 │ │ │ ├── baseUriChange │ │ │ │ └── folderInteger.json │ │ │ ├── baseUriChangeFolder │ │ │ │ └── folderInteger.json │ │ │ ├── baseUriChangeFolderInSubschema │ │ │ │ └── folderInteger.json │ │ │ ├── detached-dynamicref.json │ │ │ ├── detached-ref.json │ │ │ ├── extendible-dynamic-ref.json │ │ │ ├── format-assertion-false.json │ │ │ ├── format-assertion-true.json │ │ │ ├── integer.json │ │ │ ├── locationIndependentIdentifier.json │ │ │ ├── metaschema-no-validation.json │ │ │ ├── metaschema-optional-vocabulary.json │ │ │ ├── name-defs.json │ │ │ ├── nested │ │ │ │ ├── foo-ref-string.json │ │ │ │ └── string.json │ │ │ ├── prefixItems.json │ │ │ ├── ref-and-defs.json │ │ │ ├── subSchemas.json │ │ │ └── tree.json │ │ ├── draft3 │ │ │ └── subSchemas.json │ │ ├── draft4 │ │ │ ├── locationIndependentIdentifier.json │ │ │ ├── name.json │ │ │ └── subSchemas.json │ │ ├── draft6 │ │ │ ├── detached-ref.json │ │ │ ├── locationIndependentIdentifier.json │ │ │ ├── name.json │ │ │ ├── ref-and-definitions.json │ │ │ └── subSchemas.json │ │ ├── draft7 │ │ │ ├── detached-ref.json │ │ │ ├── ignore-dependentRequired.json │ │ │ ├── locationIndependentIdentifier.json │ │ │ ├── name.json │ │ │ ├── ref-and-definitions.json │ │ │ └── subSchemas.json │ │ ├── integer.json │ │ ├── nested-absolute-ref-to-string.json │ │ ├── nested │ │ │ ├── foo-ref-string.json │ │ │ └── string.json │ │ └── urn-ref-string.json │ └── tests │ │ ├── draft2019-09 │ │ ├── additionalItems.json │ │ ├── additionalProperties.json │ │ ├── allOf.json │ │ ├── anchor.json │ │ ├── anyOf.json │ │ ├── boolean_schema.json │ │ ├── const.json │ │ ├── contains.json │ │ ├── content.json │ │ ├── default.json │ │ ├── defs.json │ │ ├── dependentRequired.json │ │ ├── dependentSchemas.json │ │ ├── enum.json │ │ ├── exclusiveMaximum.json │ │ ├── exclusiveMinimum.json │ │ ├── format.json │ │ ├── if-then-else.json │ │ ├── infinite-loop-detection.json │ │ ├── items.json │ │ ├── maxContains.json │ │ ├── maxItems.json │ │ ├── maxLength.json │ │ ├── maxProperties.json │ │ ├── maximum.json │ │ ├── minContains.json │ │ ├── minItems.json │ │ ├── minLength.json │ │ ├── minProperties.json │ │ ├── minimum.json │ │ ├── multipleOf.json │ │ ├── not.json │ │ ├── oneOf.json │ │ ├── optional │ │ │ ├── anchor.json │ │ │ ├── bignum.json │ │ │ ├── cross-draft.json │ │ │ ├── dependencies-compatibility.json │ │ │ ├── ecmascript-regex.json │ │ │ ├── float-overflow.json │ │ │ ├── format │ │ │ │ ├── date-time.json │ │ │ │ ├── date.json │ │ │ │ ├── duration.json │ │ │ │ ├── email.json │ │ │ │ ├── hostname.json │ │ │ │ ├── idn-email.json │ │ │ │ ├── idn-hostname.json │ │ │ │ ├── ipv4.json │ │ │ │ ├── ipv6.json │ │ │ │ ├── iri-reference.json │ │ │ │ ├── iri.json │ │ │ │ ├── json-pointer.json │ │ │ │ ├── regex.json │ │ │ │ ├── relative-json-pointer.json │ │ │ │ ├── time.json │ │ │ │ ├── unknown.json │ │ │ │ ├── uri-reference.json │ │ │ │ ├── uri-template.json │ │ │ │ ├── uri.json │ │ │ │ └── uuid.json │ │ │ ├── id.json │ │ │ ├── no-schema.json │ │ │ ├── non-bmp-regex.json │ │ │ ├── refOfUnknownKeyword.json │ │ │ └── unknownKeyword.json │ │ ├── pattern.json │ │ ├── patternProperties.json │ │ ├── properties.json │ │ ├── propertyNames.json │ │ ├── recursiveRef.json │ │ ├── ref.json │ │ ├── refRemote.json │ │ ├── required.json │ │ ├── type.json │ │ ├── unevaluatedItems.json │ │ ├── unevaluatedProperties.json │ │ ├── uniqueItems.json │ │ └── vocabulary.json │ │ ├── draft2020-12 │ │ ├── additionalProperties.json │ │ ├── allOf.json │ │ ├── anchor.json │ │ ├── anyOf.json │ │ ├── boolean_schema.json │ │ ├── const.json │ │ ├── contains.json │ │ ├── content.json │ │ ├── default.json │ │ ├── defs.json │ │ ├── dependentRequired.json │ │ ├── dependentSchemas.json │ │ ├── dynamicRef.json │ │ ├── enum.json │ │ ├── exclusiveMaximum.json │ │ ├── exclusiveMinimum.json │ │ ├── format.json │ │ ├── if-then-else.json │ │ ├── infinite-loop-detection.json │ │ ├── items.json │ │ ├── maxContains.json │ │ ├── maxItems.json │ │ ├── maxLength.json │ │ ├── maxProperties.json │ │ ├── maximum.json │ │ ├── minContains.json │ │ ├── minItems.json │ │ ├── minLength.json │ │ ├── minProperties.json │ │ ├── minimum.json │ │ ├── multipleOf.json │ │ ├── not.json │ │ ├── oneOf.json │ │ ├── optional │ │ │ ├── anchor.json │ │ │ ├── bignum.json │ │ │ ├── cross-draft.json │ │ │ ├── dependencies-compatibility.json │ │ │ ├── dynamicRef.json │ │ │ ├── ecmascript-regex.json │ │ │ ├── float-overflow.json │ │ │ ├── format-assertion.json │ │ │ ├── format │ │ │ │ ├── date-time.json │ │ │ │ ├── date.json │ │ │ │ ├── duration.json │ │ │ │ ├── ecmascript-regex.json │ │ │ │ ├── email.json │ │ │ │ ├── hostname.json │ │ │ │ ├── idn-email.json │ │ │ │ ├── idn-hostname.json │ │ │ │ ├── ipv4.json │ │ │ │ ├── ipv6.json │ │ │ │ ├── iri-reference.json │ │ │ │ ├── iri.json │ │ │ │ ├── json-pointer.json │ │ │ │ ├── regex.json │ │ │ │ ├── relative-json-pointer.json │ │ │ │ ├── time.json │ │ │ │ ├── unknown.json │ │ │ │ ├── uri-reference.json │ │ │ │ ├── uri-template.json │ │ │ │ ├── uri.json │ │ │ │ └── uuid.json │ │ │ ├── id.json │ │ │ ├── no-schema.json │ │ │ ├── non-bmp-regex.json │ │ │ ├── refOfUnknownKeyword.json │ │ │ └── unknownKeyword.json │ │ ├── pattern.json │ │ ├── patternProperties.json │ │ ├── prefixItems.json │ │ ├── properties.json │ │ ├── propertyNames.json │ │ ├── ref.json │ │ ├── refRemote.json │ │ ├── required.json │ │ ├── type.json │ │ ├── unevaluatedItems.json │ │ ├── unevaluatedProperties.json │ │ ├── uniqueItems.json │ │ └── vocabulary.json │ │ ├── draft4 │ │ ├── additionalItems.json │ │ ├── additionalProperties.json │ │ ├── allOf.json │ │ ├── anyOf.json │ │ ├── default.json │ │ ├── definitions.json │ │ ├── dependencies.json │ │ ├── enum.json │ │ ├── format.json │ │ ├── infinite-loop-detection.json │ │ ├── items.json │ │ ├── maxItems.json │ │ ├── maxLength.json │ │ ├── maxProperties.json │ │ ├── maximum.json │ │ ├── minItems.json │ │ ├── minLength.json │ │ ├── minProperties.json │ │ ├── minimum.json │ │ ├── multipleOf.json │ │ ├── not.json │ │ ├── oneOf.json │ │ ├── optional │ │ │ ├── bignum.json │ │ │ ├── ecmascript-regex.json │ │ │ ├── float-overflow.json │ │ │ ├── format │ │ │ │ ├── date-time.json │ │ │ │ ├── email.json │ │ │ │ ├── hostname.json │ │ │ │ ├── ipv4.json │ │ │ │ ├── ipv6.json │ │ │ │ ├── unknown.json │ │ │ │ └── uri.json │ │ │ ├── id.json │ │ │ ├── non-bmp-regex.json │ │ │ └── zeroTerminatedFloats.json │ │ ├── pattern.json │ │ ├── patternProperties.json │ │ ├── properties.json │ │ ├── ref.json │ │ ├── refRemote.json │ │ ├── required.json │ │ ├── type.json │ │ └── uniqueItems.json │ │ ├── draft6 │ │ ├── additionalItems.json │ │ ├── additionalProperties.json │ │ ├── allOf.json │ │ ├── anyOf.json │ │ ├── boolean_schema.json │ │ ├── const.json │ │ ├── contains.json │ │ ├── default.json │ │ ├── definitions.json │ │ ├── dependencies.json │ │ ├── enum.json │ │ ├── exclusiveMaximum.json │ │ ├── exclusiveMinimum.json │ │ ├── format.json │ │ ├── infinite-loop-detection.json │ │ ├── items.json │ │ ├── maxItems.json │ │ ├── maxLength.json │ │ ├── maxProperties.json │ │ ├── maximum.json │ │ ├── minItems.json │ │ ├── minLength.json │ │ ├── minProperties.json │ │ ├── minimum.json │ │ ├── multipleOf.json │ │ ├── not.json │ │ ├── oneOf.json │ │ ├── optional │ │ │ ├── bignum.json │ │ │ ├── ecmascript-regex.json │ │ │ ├── float-overflow.json │ │ │ ├── format │ │ │ │ ├── date-time.json │ │ │ │ ├── email.json │ │ │ │ ├── hostname.json │ │ │ │ ├── ipv4.json │ │ │ │ ├── ipv6.json │ │ │ │ ├── json-pointer.json │ │ │ │ ├── unknown.json │ │ │ │ ├── uri-reference.json │ │ │ │ ├── uri-template.json │ │ │ │ └── uri.json │ │ │ ├── id.json │ │ │ ├── non-bmp-regex.json │ │ │ └── unknownKeyword.json │ │ ├── pattern.json │ │ ├── patternProperties.json │ │ ├── properties.json │ │ ├── propertyNames.json │ │ ├── ref.json │ │ ├── refRemote.json │ │ ├── required.json │ │ ├── type.json │ │ └── uniqueItems.json │ │ └── draft7 │ │ ├── additionalItems.json │ │ ├── additionalProperties.json │ │ ├── allOf.json │ │ ├── anyOf.json │ │ ├── boolean_schema.json │ │ ├── const.json │ │ ├── contains.json │ │ ├── default.json │ │ ├── definitions.json │ │ ├── dependencies.json │ │ ├── enum.json │ │ ├── exclusiveMaximum.json │ │ ├── exclusiveMinimum.json │ │ ├── format.json │ │ ├── if-then-else.json │ │ ├── infinite-loop-detection.json │ │ ├── items.json │ │ ├── maxItems.json │ │ ├── maxLength.json │ │ ├── maxProperties.json │ │ ├── maximum.json │ │ ├── minItems.json │ │ ├── minLength.json │ │ ├── minProperties.json │ │ ├── minimum.json │ │ ├── multipleOf.json │ │ ├── not.json │ │ ├── oneOf.json │ │ ├── optional │ │ ├── bignum.json │ │ ├── content.json │ │ ├── cross-draft.json │ │ ├── ecmascript-regex.json │ │ ├── float-overflow.json │ │ ├── format │ │ │ ├── date-time.json │ │ │ ├── date.json │ │ │ ├── email.json │ │ │ ├── hostname.json │ │ │ ├── idn-email.json │ │ │ ├── idn-hostname.json │ │ │ ├── ipv4.json │ │ │ ├── ipv6.json │ │ │ ├── iri-reference.json │ │ │ ├── iri.json │ │ │ ├── json-pointer.json │ │ │ ├── regex.json │ │ │ ├── relative-json-pointer.json │ │ │ ├── time.json │ │ │ ├── unknown.json │ │ │ ├── uri-reference.json │ │ │ ├── uri-template.json │ │ │ └── uri.json │ │ ├── id.json │ │ ├── non-bmp-regex.json │ │ └── unknownKeyword.json │ │ ├── pattern.json │ │ ├── patternProperties.json │ │ ├── properties.json │ │ ├── propertyNames.json │ │ ├── ref.json │ │ ├── refRemote.json │ │ ├── required.json │ │ ├── type.json │ │ └── uniqueItems.json └── vendorpull │ ├── LICENSE │ └── pull └── vendorpull.mask /.ackrc: -------------------------------------------------------------------------------- 1 | --ignore-dir=build 2 | --ignore-dir=vendor 3 | -------------------------------------------------------------------------------- /.editorconfig: -------------------------------------------------------------------------------- 1 | # editorconfig.org 2 | root = true 3 | 4 | [*] 5 | indent_style = space 6 | indent_size = 2 7 | end_of_line = lf 8 | charset = utf-8 9 | trim_trailing_whitespace = true 10 | insert_final_newline = true 11 | 12 | [Makefile] 13 | indent_style = tab 14 | 15 | [*.mk] 16 | indent_style = tab 17 | -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | /vendor/** linguist-generated=true 2 | -------------------------------------------------------------------------------- /.github/workflows/website-build.yml: -------------------------------------------------------------------------------- 1 | name: website 2 | on: 3 | pull_request: 4 | 5 | concurrency: 6 | group: website-build-${{ github.ref }} 7 | cancel-in-progress: true 8 | 9 | jobs: 10 | build: 11 | runs-on: ubuntu-latest 12 | steps: 13 | - uses: actions/checkout@v4 14 | - run: sudo apt update 15 | - run: sudo apt install -y doxygen 16 | - run: > 17 | cmake -S . -B ./build 18 | -DCMAKE_BUILD_TYPE:STRING=Release 19 | -DBLAZE_COMPILER:BOOL=OFF 20 | -DBLAZE_EVALUATOR:BOOL=OFF 21 | -DBLAZE_LINTER:BOOL=OFF 22 | -DBLAZE_TESTS:BOOL=OFF 23 | -DBLAZE_DOCS:BOOL=ON 24 | - run: cmake --build ./build --config Release --target doxygen 25 | -------------------------------------------------------------------------------- /.github/workflows/website-deploy.yml: -------------------------------------------------------------------------------- 1 | name: website 2 | on: 3 | push: 4 | branches: [ "main" ] 5 | workflow_dispatch: 6 | 7 | permissions: 8 | contents: read 9 | pages: write 10 | id-token: write 11 | 12 | concurrency: 13 | group: website-deploy-${{ github.ref }} 14 | cancel-in-progress: true 15 | 16 | jobs: 17 | deploy: 18 | environment: 19 | name: github-pages 20 | url: ${{ steps.deployment.outputs.page_url }} 21 | runs-on: ubuntu-latest 22 | steps: 23 | - uses: actions/checkout@v4 24 | - run: sudo apt update 25 | - run: sudo apt install -y doxygen 26 | - run: > 27 | cmake -S . -B ./build 28 | -DCMAKE_BUILD_TYPE:STRING=Release 29 | -DCMAKE_BUILD_TYPE:STRING=Release 30 | -DBLAZE_COMPILER:BOOL=OFF 31 | -DBLAZE_EVALUATOR:BOOL=OFF 32 | -DBLAZE_LINTER:BOOL=OFF 33 | -DBLAZE_TESTS:BOOL=OFF 34 | -DBLAZE_DOCS:BOOL=ON 35 | - run: cmake --build ./build --config Release --target doxygen 36 | - name: Setup Pages 37 | uses: actions/configure-pages@v5 38 | - name: Upload artifact 39 | uses: actions/upload-pages-artifact@v3 40 | with: 41 | path: ./build/website 42 | - name: Deploy to GitHub Pages 43 | id: deployment 44 | uses: actions/deploy-pages@v4 45 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | CMakeLists.txt.user 2 | CMakeCache.txt 3 | CMakeFiles 4 | CMakeScripts 5 | Testing 6 | cmake_install.cmake 7 | install_manifest.txt 8 | compile_commands.json 9 | CTestTestfile.cmake 10 | _deps 11 | /build 12 | Brewfile.lock.json 13 | .DS_Store 14 | .cache 15 | /bindings/*/build 16 | -------------------------------------------------------------------------------- /Brewfile: -------------------------------------------------------------------------------- 1 | brew "cmake" 2 | brew "doxygen" 3 | brew "gcc@13" 4 | -------------------------------------------------------------------------------- /DEPENDENCIES: -------------------------------------------------------------------------------- 1 | vendorpull https://github.com/sourcemeta/vendorpull dea311b5bfb53b6926a4140267959ae334d3ecf4 2 | core https://github.com/sourcemeta/core 375cdcacefe7f8bedb038c761fce1802e4954244 3 | jsonschema-test-suite https://github.com/json-schema-org/JSON-Schema-Test-Suite bc919bdb266a4949f8a2425f2f540371604d82b4 4 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | This software is dual-licensed: you can redistribute it and/or modify it under 2 | the terms of the GNU Affero General Public License as published by the Free 3 | Software Foundation, either version 3 of the License, or (at your option) any 4 | later version. For the terms of this license, see 5 | . 6 | 7 | You are free to use this software under the terms of the GNU Affero General 8 | Public License WITHOUT ANY WARRANTY; without even the implied warranty of 9 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 10 | 11 | Alternatively, you can use this software under a commercial license, as set out 12 | in . 13 | -------------------------------------------------------------------------------- /assets/banner.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sourcemeta/blaze/b2525db645648128075fc8260fa96681740b96ec/assets/banner.png -------------------------------------------------------------------------------- /benchmark/compiler_2019_09.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include // assert 4 | 5 | #include 6 | #include 7 | 8 | #include 9 | 10 | static void Compiler_2019_09_OMC_JSON_V2(benchmark::State &state) { 11 | const auto schema{ 12 | sourcemeta::core::read_json(std::filesystem::path{CURRENT_DIRECTORY} / 13 | "schemas" / "2019_09_omc_json_v2.json")}; 14 | 15 | for (auto _ : state) { 16 | auto result{sourcemeta::blaze::compile( 17 | schema, sourcemeta::core::schema_official_walker, 18 | sourcemeta::core::schema_official_resolver, 19 | sourcemeta::blaze::default_schema_compiler)}; 20 | assert(!result.instructions.empty()); 21 | benchmark::DoNotOptimize(result.instructions); 22 | } 23 | } 24 | 25 | BENCHMARK(Compiler_2019_09_OMC_JSON_V2); 26 | -------------------------------------------------------------------------------- /benchmark/compiler_draft6.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include // assert 4 | 5 | #include 6 | #include 7 | 8 | #include 9 | 10 | static void Compiler_Draft6_AdaptiveCard(benchmark::State &state) { 11 | const auto schema{ 12 | sourcemeta::core::read_json(std::filesystem::path{CURRENT_DIRECTORY} / 13 | "schemas" / "draft6_adaptivecard.json")}; 14 | 15 | for (auto _ : state) { 16 | auto result{sourcemeta::blaze::compile( 17 | schema, sourcemeta::core::schema_official_walker, 18 | sourcemeta::core::schema_official_resolver, 19 | sourcemeta::blaze::default_schema_compiler)}; 20 | assert(!result.instructions.empty()); 21 | benchmark::DoNotOptimize(result.instructions); 22 | } 23 | } 24 | 25 | BENCHMARK(Compiler_Draft6_AdaptiveCard); 26 | -------------------------------------------------------------------------------- /benchmark/instances/draft7_jasmine_1.json: -------------------------------------------------------------------------------- 1 | { 2 | "spec_dir": "test/jasmine/", 3 | "spec_files": [ 4 | "**/*[sS]pec.js", 5 | "**/*[sS]pecCli.js" 6 | ], 7 | "helpers": [ 8 | "helpers/**/*.js" 9 | ], 10 | "random": false, 11 | "seed": null, 12 | "stopSpecOnExpectationFailure": false 13 | } 14 | -------------------------------------------------------------------------------- /benchmark/schemas/draft7_helm_chart_lock.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "http://json-schema.org/draft-07/schema#", 3 | "type": "object", 4 | "required": [ 5 | "generated", 6 | "digest", 7 | "dependencies" 8 | ], 9 | "properties": { 10 | "dependencies": { 11 | "type": "array", 12 | "items": { 13 | "type": "object", 14 | "required": [ 15 | "name", 16 | "version", 17 | "repository" 18 | ], 19 | "properties": { 20 | "name": { 21 | "type": "string" 22 | }, 23 | "repository": { 24 | "type": "string", 25 | "format": "uri" 26 | }, 27 | "version": { 28 | "type": "string" 29 | } 30 | }, 31 | "additionalProperties": false 32 | } 33 | }, 34 | "digest": { 35 | "type": "string" 36 | }, 37 | "generated": { 38 | "type": "string", 39 | "format": "date-time" 40 | } 41 | }, 42 | "additionalProperties": false 43 | } 44 | -------------------------------------------------------------------------------- /benchmark/schemas/draft7_jasmine.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "http://json-schema.org/draft-07/schema#", 3 | "allOf": [ 4 | { "$ref": "#/definitions/root-items" }, 5 | { 6 | "type": "object", 7 | "properties": { 8 | "env": { "$ref": "#/definitions/env-items" } 9 | } 10 | }, 11 | { "$ref": "#/definitions/env-items" } 12 | ], 13 | "definitions": { 14 | "env-items": { 15 | "type": "object", 16 | "properties": { 17 | "autoCleanClosure": { "type": "boolean" }, 18 | "failSpecWithNoExpectations": { "type": "boolean" }, 19 | "hideDisbaled": { "type": "boolean" }, 20 | "random": { "type": "boolean" }, 21 | "seed": { 22 | "anyOf": [ 23 | { "type": "string" }, 24 | { "type": "number" }, 25 | { "type": "null" } 26 | ] 27 | }, 28 | "stopOnSpecFailure": { "type": "boolean" }, 29 | "stopSpecOnExpectationFailure": { "type": "boolean" }, 30 | "verboseDeprication": { "type": "boolean" } 31 | } 32 | }, 33 | "root-items": { 34 | "type": "object", 35 | "required": [ "spec_dir", "spec_files" ], 36 | "properties": { 37 | "helpers": { 38 | "type": "array", 39 | "items": { "type": "string" } 40 | }, 41 | "spec_dir": { "type": "string" }, 42 | "spec_files": { 43 | "type": "array", 44 | "items": { "type": "string" } 45 | } 46 | } 47 | } 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /cmake/FindCore.cmake: -------------------------------------------------------------------------------- 1 | if(NOT Core_FOUND) 2 | if(BLAZE_INSTALL) 3 | set(SOURCEMETA_CORE_INSTALL ON CACHE BOOL "enable installation") 4 | else() 5 | set(SOURCEMETA_CORE_INSTALL OFF CACHE BOOL "disable installation") 6 | endif() 7 | 8 | set(SOURCEMETA_CORE_YAML OFF CACHE BOOL "disable YAML support") 9 | set(SOURCEMETA_CORE_CONTRIB_GOOGLETEST ${BLAZE_TESTS} CACHE BOOL "GoogleTest") 10 | set(SOURCEMETA_CORE_CONTRIB_GOOGLEBENCHMARK ${BLAZE_BENCHMARK} CACHE BOOL "GoogleBenchmark") 11 | add_subdirectory("${PROJECT_SOURCE_DIR}/vendor/core") 12 | include(Sourcemeta) 13 | set(Core_FOUND ON) 14 | endif() 15 | -------------------------------------------------------------------------------- /config.cmake.in: -------------------------------------------------------------------------------- 1 | @PACKAGE_INIT@ 2 | 3 | # Support both casing styles 4 | list(APPEND BLAZE_COMPONENTS ${Blaze_FIND_COMPONENTS}) 5 | list(APPEND BLAZE_COMPONENTS ${blaze_FIND_COMPONENTS}) 6 | if(NOT BLAZE_COMPONENTS) 7 | list(APPEND BLAZE_COMPONENTS compiler) 8 | list(APPEND BLAZE_COMPONENTS evaluator) 9 | list(APPEND BLAZE_COMPONENTS linter) 10 | endif() 11 | 12 | include(CMakeFindDependencyMacro) 13 | find_dependency(Core COMPONENTS regex uri json jsonpointer jsonschema) 14 | 15 | foreach(component ${BLAZE_COMPONENTS}) 16 | if(component STREQUAL "compiler") 17 | include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_blaze_evaluator.cmake") 18 | include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_blaze_compiler.cmake") 19 | elseif(component STREQUAL "evaluator") 20 | include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_blaze_evaluator.cmake") 21 | elseif(component STREQUAL "linter") 22 | include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_blaze_evaluator.cmake") 23 | include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_blaze_compiler.cmake") 24 | include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_blaze_linter.cmake") 25 | else() 26 | message(FATAL_ERROR "Unknown Blaze component: ${component}") 27 | endif() 28 | endforeach() 29 | 30 | check_required_components("@PROJECT_NAME@") 31 | -------------------------------------------------------------------------------- /contrib/validate-diff.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | set -o errexit 4 | set -o nounset 5 | 6 | # To easily diff JSONL output from multiple runs of `validate.cc` 7 | 8 | usage() { 9 | echo "Usage $0 " 1>&2 10 | exit 1 11 | } 12 | 13 | if [ "$#" -lt 2 ] 14 | then 15 | usage 16 | fi 17 | 18 | LEFT="$1" 19 | RIGHT="$2" 20 | 21 | echo "Comparing $LEFT against $RIGHT" 22 | 23 | extract_ns() { 24 | echo "$1" | awk -F' ' '{print $2}' | sed 's/ns//' 25 | } 26 | 27 | while IFS= read -r line_left && IFS= read -r line_right <&3 28 | do 29 | row1="$(echo "$line_left" | awk '{print $1}')" 30 | row2="$(echo "$line_right" | awk '{print $1}')" 31 | 32 | if [ "$row1" != "$row2" ] 33 | then 34 | echo "error: row mismatch ($row1 vs $row2)" 35 | exit 1 36 | fi 37 | 38 | ns_left="$(extract_ns "$line_left")" 39 | ns_right="$(extract_ns "$line_right")" 40 | diff="$(awk -v ns_left="$ns_left" -v ns_right="$ns_right" 'BEGIN { 41 | diff = (ns_left - ns_right) / ((ns_left + ns_right) / 2) * 100 42 | printf "%.2f", diff 43 | }')" 44 | 45 | printf "%s %sns|%sns %s%%\n" "$row1" "$ns_left" "$ns_right" "$diff" 46 | done < "$LEFT" 3< "$RIGHT" 47 | -------------------------------------------------------------------------------- /doxygen/logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sourcemeta/blaze/b2525db645648128075fc8260fa96681740b96ec/doxygen/logo.png -------------------------------------------------------------------------------- /src/compiler/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | sourcemeta_library(NAMESPACE sourcemeta PROJECT blaze NAME compiler 2 | FOLDER "Blaze/Compiler" 3 | PRIVATE_HEADERS error.h output.h unevaluated.h 4 | SOURCES 5 | compile.cc compile_describe.cc 6 | compile_output_simple.cc compile_output_trace.cc 7 | compile_helpers.h default_compiler.cc unevaluated.cc 8 | default_compiler_2020_12.h 9 | default_compiler_2019_09.h 10 | default_compiler_draft7.h 11 | default_compiler_draft6.h 12 | default_compiler_draft4.h) 13 | 14 | if(BLAZE_INSTALL) 15 | sourcemeta_library_install(NAMESPACE sourcemeta PROJECT blaze NAME compiler) 16 | endif() 17 | 18 | target_link_libraries(sourcemeta_blaze_compiler PUBLIC 19 | sourcemeta::core::json) 20 | target_link_libraries(sourcemeta_blaze_compiler PRIVATE 21 | sourcemeta::core::regex) 22 | target_link_libraries(sourcemeta_blaze_compiler PUBLIC 23 | sourcemeta::core::jsonpointer) 24 | target_link_libraries(sourcemeta_blaze_compiler PRIVATE 25 | sourcemeta::core::uri) 26 | target_link_libraries(sourcemeta_blaze_compiler PUBLIC 27 | sourcemeta::core::jsonschema) 28 | target_link_libraries(sourcemeta_blaze_compiler PUBLIC 29 | sourcemeta::blaze::evaluator) 30 | -------------------------------------------------------------------------------- /src/evaluator/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | sourcemeta_library(NAMESPACE sourcemeta PROJECT blaze NAME evaluator 2 | FOLDER "Blaze/Evaluator" 3 | PRIVATE_HEADERS error.h value.h instruction.h string_set.h 4 | SOURCES evaluator.cc dispatch.inc.h 5 | evaluator_string_set.cc 6 | evaluator_complete.h evaluator_dynamic.h 7 | evaluator_track.h evaluator_fast.h) 8 | 9 | if(BLAZE_INSTALL) 10 | sourcemeta_library_install(NAMESPACE sourcemeta PROJECT blaze NAME evaluator) 11 | endif() 12 | 13 | if(PROJECT_IS_TOP_LEVEL) 14 | sourcemeta_add_vectorization_diagnostics(sourcemeta_blaze_evaluator) 15 | endif() 16 | 17 | target_link_libraries(sourcemeta_blaze_evaluator PUBLIC 18 | sourcemeta::core::json) 19 | target_link_libraries(sourcemeta_blaze_evaluator PUBLIC 20 | sourcemeta::core::regex) 21 | target_link_libraries(sourcemeta_blaze_evaluator PUBLIC 22 | sourcemeta::core::jsonpointer) 23 | target_link_libraries(sourcemeta_blaze_evaluator PRIVATE 24 | sourcemeta::core::uri) 25 | -------------------------------------------------------------------------------- /src/evaluator/evaluator_string_set.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include // std::sort 4 | 5 | namespace sourcemeta::blaze { 6 | 7 | auto StringSet::contains(const value_type &value, const hash_type hash) const 8 | -> bool { 9 | if (this->hasher.is_perfect(hash)) { 10 | for (const auto &entry : this->data) { 11 | if (entry.second == hash) { 12 | return true; 13 | } 14 | } 15 | } else { 16 | for (const auto &entry : this->data) { 17 | if (entry.second == hash && entry.first == value) { 18 | return true; 19 | } 20 | } 21 | } 22 | 23 | return false; 24 | } 25 | 26 | auto StringSet::insert(const value_type &value) -> void { 27 | const auto hash{this->hasher(value)}; 28 | if (!this->contains(value, hash)) { 29 | this->data.emplace_back(value, hash); 30 | std::sort(this->data.begin(), this->data.end(), 31 | [](const auto &left, const auto &right) { 32 | return left.first < right.first; 33 | }); 34 | } 35 | } 36 | 37 | auto StringSet::insert(value_type &&value) -> void { 38 | const auto hash{this->hasher(value)}; 39 | if (!this->contains(value, hash)) { 40 | this->data.emplace_back(std::move(value), hash); 41 | std::sort(this->data.begin(), this->data.end(), 42 | [](const auto &left, const auto &right) { 43 | return left.first < right.first; 44 | }); 45 | } 46 | } 47 | 48 | } // namespace sourcemeta::blaze 49 | -------------------------------------------------------------------------------- /src/evaluator/include/sourcemeta/blaze/evaluator_error.h: -------------------------------------------------------------------------------- 1 | #ifndef SOURCEMETA_BLAZE_EVALUATOR_ERROR_H 2 | #define SOURCEMETA_BLAZE_EVALUATOR_ERROR_H 3 | 4 | #ifndef SOURCEMETA_BLAZE_EVALUATOR_EXPORT 5 | #include 6 | #endif 7 | 8 | #include // std::exception 9 | #include // std::string 10 | #include // std::move 11 | 12 | namespace sourcemeta::blaze { 13 | 14 | // Exporting symbols that depends on the standard C++ library is considered 15 | // safe. 16 | // https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-2-c4275?view=msvc-170&redirectedfrom=MSDN 17 | #if defined(_MSC_VER) 18 | #pragma warning(disable : 4251 4275) 19 | #endif 20 | 21 | /// @ingroup evaluator 22 | /// An error that represents a schema evaluation error event 23 | class SOURCEMETA_BLAZE_EVALUATOR_EXPORT EvaluationError 24 | : public std::exception { 25 | public: 26 | EvaluationError(std::string message) : message_{std::move(message)} {} 27 | [[nodiscard]] auto what() const noexcept -> const char * override { 28 | return this->message_.c_str(); 29 | } 30 | 31 | private: 32 | std::string message_; 33 | }; 34 | 35 | #if defined(_MSC_VER) 36 | #pragma warning(default : 4251 4275) 37 | #endif 38 | 39 | } // namespace sourcemeta::blaze 40 | 41 | #endif 42 | -------------------------------------------------------------------------------- /src/linter/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | sourcemeta_library(NAMESPACE sourcemeta PROJECT blaze NAME linter 2 | FOLDER "Blaze/Linter" 3 | SOURCES 4 | valid_default.cc 5 | valid_examples.cc) 6 | 7 | if(BLAZE_INSTALL) 8 | sourcemeta_library_install(NAMESPACE sourcemeta PROJECT blaze NAME linter) 9 | endif() 10 | 11 | target_link_libraries(sourcemeta_blaze_linter PUBLIC 12 | sourcemeta::core::jsonschema) 13 | target_link_libraries(sourcemeta_blaze_linter PUBLIC 14 | sourcemeta::blaze::compiler) 15 | target_link_libraries(sourcemeta_blaze_linter PRIVATE 16 | sourcemeta::blaze::evaluator) 17 | -------------------------------------------------------------------------------- /test/compiler/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | sourcemeta_googletest(NAMESPACE sourcemeta PROJECT blaze NAME compiler 2 | FOLDER "Blaze/Compiler" 3 | SOURCES 4 | compiler_output_simple_test.cc 5 | compiler_output_trace_test.cc 6 | compiler_unevaluated_2019_09_test.cc 7 | compiler_unevaluated_2020_12_test.cc 8 | compiler_test_utils.h) 9 | 10 | target_link_libraries(sourcemeta_blaze_compiler_unit 11 | PRIVATE sourcemeta::core::json) 12 | target_link_libraries(sourcemeta_blaze_compiler_unit 13 | PRIVATE sourcemeta::core::jsonschema) 14 | target_link_libraries(sourcemeta_blaze_compiler_unit 15 | PRIVATE sourcemeta::blaze::compiler) 16 | target_link_libraries(sourcemeta_blaze_compiler_unit 17 | PRIVATE sourcemeta::blaze::evaluator) 18 | -------------------------------------------------------------------------------- /test/linter/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | sourcemeta_googletest(NAMESPACE sourcemeta PROJECT blaze NAME linter 2 | FOLDER "Blaze/Linter" 3 | SOURCES 4 | linter_valid_default_test.cc 5 | linter_valid_examples_test.cc) 6 | 7 | target_link_libraries(sourcemeta_blaze_linter_unit 8 | PRIVATE sourcemeta::core::json) 9 | target_link_libraries(sourcemeta_blaze_linter_unit 10 | PRIVATE sourcemeta::core::jsonschema) 11 | target_link_libraries(sourcemeta_blaze_linter_unit 12 | PRIVATE sourcemeta::blaze::compiler) 13 | target_link_libraries(sourcemeta_blaze_linter_unit 14 | PRIVATE sourcemeta::blaze::evaluator) 15 | target_link_libraries(sourcemeta_blaze_linter_unit 16 | PRIVATE sourcemeta::blaze::linter) 17 | -------------------------------------------------------------------------------- /test/packaging/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # TODO: Get install path from a variable? 2 | add_test(NAME packaging.find_package_configure COMMAND 3 | "${CMAKE_COMMAND}" 4 | -S "${CMAKE_CURRENT_SOURCE_DIR}/find_package" 5 | -B "${CMAKE_CURRENT_BINARY_DIR}/find_package" 6 | "-DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}" 7 | "-DCMAKE_PREFIX_PATH:PATH=${CMAKE_PREFIX_PATH};${PROJECT_SOURCE_DIR}/build/dist" 8 | "-DCMAKE_TOOLCHAIN_FILE:PATH=${CMAKE_TOOLCHAIN_FILE}") 9 | add_test(NAME packaging.find_package_build COMMAND 10 | "${CMAKE_COMMAND}" 11 | --build "${CMAKE_CURRENT_BINARY_DIR}/find_package" 12 | --config "${CMAKE_BUILD_TYPE}") 13 | set_tests_properties(packaging.find_package_build 14 | PROPERTIES DEPENDS packaging.find_package_configure) 15 | -------------------------------------------------------------------------------- /test/packaging/find_package/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.18) 2 | project(blaze_hello VERSION 0.0.1 LANGUAGES CXX) 3 | set(CMAKE_CXX_STANDARD 20) 4 | set(CMAKE_CXX_STANDARD_REQUIRED ON) 5 | set(CMAKE_CXX_EXTENSIONS OFF) 6 | find_package(Blaze REQUIRED) 7 | add_executable(blaze_hello hello.cc) 8 | target_link_libraries(blaze_hello PRIVATE sourcemeta::core::json) 9 | target_link_libraries(blaze_hello PRIVATE sourcemeta::core::jsonschema) 10 | target_link_libraries(blaze_hello PRIVATE sourcemeta::blaze::compiler) 11 | target_link_libraries(blaze_hello PRIVATE sourcemeta::blaze::evaluator) 12 | target_link_libraries(blaze_hello PRIVATE sourcemeta::blaze::linter) 13 | -------------------------------------------------------------------------------- /test/packaging/find_package/hello.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | #include // EXIT_SUCCESS 9 | #include // std::cerr 10 | 11 | auto main() -> int { 12 | const auto schema{sourcemeta::core::parse_json(R"JSON({ 13 | "$schema": "https://json-schema.org/draft/2020-12/schema", 14 | "type": "string" 15 | })JSON")}; 16 | 17 | const auto compiled_schema{sourcemeta::blaze::compile( 18 | schema, sourcemeta::core::schema_official_walker, 19 | sourcemeta::core::schema_official_resolver, 20 | sourcemeta::blaze::default_schema_compiler)}; 21 | 22 | const sourcemeta::core::JSON instance{"foo"}; 23 | sourcemeta::blaze::Evaluator evaluator; 24 | if (!evaluator.validate(compiled_schema, instance)) { 25 | std::cerr << "JSON Schema validation failed\n"; 26 | return EXIT_FAILURE; 27 | } 28 | 29 | return EXIT_SUCCESS; 30 | } 31 | -------------------------------------------------------------------------------- /vendor/core/LICENSE: -------------------------------------------------------------------------------- 1 | This software is dual-licensed: you can redistribute it and/or modify it under 2 | the terms of the GNU Affero General Public License as published by the Free 3 | Software Foundation, either version 3 of the License, or (at your option) any 4 | later version. For the terms of this license, see 5 | . 6 | 7 | You are free to use this software under the terms of the GNU Affero General 8 | Public License WITHOUT ANY WARRANTY; without even the implied warranty of 9 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 10 | 11 | Alternatively, you can use this software under a commercial license, as set out 12 | in . 13 | -------------------------------------------------------------------------------- /vendor/core/cmake/FindGoogleBenchmark.cmake: -------------------------------------------------------------------------------- 1 | if(NOT Benchmark_FOUND) 2 | set(BENCHMARK_ENABLE_TESTING OFF CACHE BOOL "enable testing of the benchmark library") 3 | add_subdirectory("${PROJECT_SOURCE_DIR}/vendor/googlebenchmark") 4 | set(Benchmark_FOUND ON) 5 | endif() 6 | -------------------------------------------------------------------------------- /vendor/core/cmake/FindGoogleTest.cmake: -------------------------------------------------------------------------------- 1 | if(NOT GoogleTest_FOUND) 2 | set(BUILD_GMOCK ON CACHE BOOL "enable googlemock") 3 | set(INSTALL_GTEST OFF CACHE BOOL "disable installation") 4 | add_subdirectory("${PROJECT_SOURCE_DIR}/vendor/googletest") 5 | set(GoogleTest_FOUND ON) 6 | endif() 7 | -------------------------------------------------------------------------------- /vendor/core/cmake/Sourcemeta.cmake: -------------------------------------------------------------------------------- 1 | set(SOURCEMETA_UTILITIES_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/common") 2 | include("${SOURCEMETA_UTILITIES_DIRECTORY}/shim.cmake") 3 | include("${SOURCEMETA_UTILITIES_DIRECTORY}/variables.cmake") 4 | include("${SOURCEMETA_UTILITIES_DIRECTORY}/defaults.cmake") 5 | include("${SOURCEMETA_UTILITIES_DIRECTORY}/compiler/simd.cmake") 6 | include("${SOURCEMETA_UTILITIES_DIRECTORY}/compiler/sanitizer.cmake") 7 | include("${SOURCEMETA_UTILITIES_DIRECTORY}/compiler/options.cmake") 8 | include("${SOURCEMETA_UTILITIES_DIRECTORY}/options/enum.cmake") 9 | include("${SOURCEMETA_UTILITIES_DIRECTORY}/commands/copy-file.cmake") 10 | include("${SOURCEMETA_UTILITIES_DIRECTORY}/targets/library.cmake") 11 | include("${SOURCEMETA_UTILITIES_DIRECTORY}/targets/executable.cmake") 12 | include("${SOURCEMETA_UTILITIES_DIRECTORY}/targets/clang-format.cmake") 13 | include("${SOURCEMETA_UTILITIES_DIRECTORY}/targets/clang-tidy.cmake") 14 | include("${SOURCEMETA_UTILITIES_DIRECTORY}/targets/shellcheck.cmake") 15 | include("${SOURCEMETA_UTILITIES_DIRECTORY}/targets/doxygen.cmake") 16 | include("${SOURCEMETA_UTILITIES_DIRECTORY}/targets/googletest.cmake") 17 | include("${SOURCEMETA_UTILITIES_DIRECTORY}/targets/googlebenchmark.cmake") 18 | 19 | # To let downstream projects directly include this file 20 | if(NOT PROJECT_IS_TOP_LEVEL) 21 | set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" PARENT_SCOPE) 22 | endif() 23 | -------------------------------------------------------------------------------- /vendor/core/cmake/common/commands/copy-file.cmake: -------------------------------------------------------------------------------- 1 | function(sourcemeta_command_copy_file) 2 | cmake_parse_arguments(SOURCEMETA_COMMAND_COPY_FILE "" "FROM;TO" "" ${ARGN}) 3 | 4 | if(NOT SOURCEMETA_COMMAND_COPY_FILE_FROM) 5 | message(FATAL_ERROR "You must pass the file to copy using the FROM option") 6 | endif() 7 | if(NOT SOURCEMETA_COMMAND_COPY_FILE_TO) 8 | message(FATAL_ERROR "You must pass the destination to copy to using the TO option") 9 | endif() 10 | 11 | add_custom_command( 12 | OUTPUT "${SOURCEMETA_COMMAND_COPY_FILE_TO}" 13 | COMMAND "${CMAKE_COMMAND}" -E copy "${SOURCEMETA_COMMAND_COPY_FILE_FROM}" "${SOURCEMETA_COMMAND_COPY_FILE_TO}" 14 | MAIN_DEPENDENCY "${SOURCEMETA_COMMAND_COPY_FILE_FROM}" 15 | DEPENDS "${SOURCEMETA_COMMAND_COPY_FILE_FROM}" 16 | COMMENT "Copying ${SOURCEMETA_COMMAND_COPY_FILE_FROM} ot ${SOURCEMETA_COMMAND_COPY_FILE_TO}") 17 | endfunction() 18 | -------------------------------------------------------------------------------- /vendor/core/cmake/common/options/enum.cmake: -------------------------------------------------------------------------------- 1 | function(sourcemeta_option_enum) 2 | cmake_parse_arguments(SOURCEMETA_OPTION_ENUM "" "NAME;DEFAULT;DESCRIPTION" "CHOICES" ${ARGN}) 3 | 4 | if(NOT SOURCEMETA_OPTION_ENUM_NAME) 5 | message(FATAL_ERROR "You must pass the option name as NAME") 6 | endif() 7 | if(NOT SOURCEMETA_OPTION_ENUM_DEFAULT) 8 | message(FATAL_ERROR "You must pass the option default value as DEFAULT") 9 | endif() 10 | if(NOT "${SOURCEMETA_OPTION_ENUM_DEFAULT}" IN_LIST SOURCEMETA_OPTION_ENUM_CHOICES) 11 | message(FATAL_ERROR "Default value of ${SOURCEMETA_OPTION_ENUM_NAME} must be one of these: ${SOURCEMETA_OPTION_ENUM_CHOICES}") 12 | endif() 13 | if(NOT SOURCEMETA_OPTION_ENUM_DESCRIPTION) 14 | message(FATAL_ERROR "You must pass the option description as DESCRIPTION") 15 | endif() 16 | if(NOT SOURCEMETA_OPTION_ENUM_CHOICES) 17 | message(FATAL_ERROR "You must pass the option enum choices as CHOICES") 18 | endif() 19 | 20 | # Declare the option 21 | set("${SOURCEMETA_OPTION_ENUM_NAME}" "${SOURCEMETA_OPTION_ENUM_DEFAULT}" 22 | CACHE STRING "${SOURCEMETA_OPTION_ENUM_DESCRIPTION}") 23 | 24 | # Display a nice set of options in `cmake-gui` 25 | set_property(CACHE "${SOURCEMETA_OPTION_ENUM_NAME}" 26 | PROPERTY STRINGS ${SOURCEMETA_OPTION_ENUM_CHOICES}) 27 | 28 | # Perform validation 29 | if(NOT "${${SOURCEMETA_OPTION_ENUM_NAME}}" IN_LIST SOURCEMETA_OPTION_ENUM_CHOICES) 30 | message(FATAL_ERROR "Value of ${SOURCEMETA_OPTION_ENUM_NAME} must be one of these: ${SOURCEMETA_OPTION_ENUM_CHOICES}") 31 | endif() 32 | endfunction() 33 | -------------------------------------------------------------------------------- /vendor/core/cmake/common/shim.cmake: -------------------------------------------------------------------------------- 1 | # The PROJECT_IS_TOP_LEVEL handy variable is only 2 | # available on CMake >=3.21. 3 | if(NOT DEFINED PROJECT_IS_TOP_LEVEL AND "${CMAKE_PROJECT_NAME}" STREQUAL "${PROJECT_NAME}") 4 | set(PROJECT_IS_TOP_LEVEL YES) 5 | endif() 6 | -------------------------------------------------------------------------------- /vendor/core/cmake/common/targets/clang-format.config: -------------------------------------------------------------------------------- 1 | --- 2 | BasedOnStyle: LLVM 3 | IndentCaseLabels: true 4 | -------------------------------------------------------------------------------- /vendor/core/cmake/common/targets/clang-tidy.config: -------------------------------------------------------------------------------- 1 | --- 2 | # See https://clang.llvm.org/extra/clang-tidy/index.html 3 | # First disable all default checks (with -*) 4 | Checks: '-*,bugprone-*,clang-analyzer-*,clang-diagnostic-*,modernize-*,concurrency-*,cppcoreguidelines-*,performance-*,portability-*,objc-*,misc-*,-misc-no-recursion,-bugprone-easily-swappable-parameters' 5 | WarningsAsErrors: '*' 6 | HeaderFilterRegex: '' 7 | FormatStyle: none 8 | CheckOptions: 9 | # See https://clang.llvm.org/extra/clang-tidy/checks/misc/include-cleaner.html 10 | # Otherwise ClangTidy wants us to directly include private headers from our modules 11 | - key: misc-include-cleaner.MissingIncludes 12 | value: 'false' 13 | -------------------------------------------------------------------------------- /vendor/core/cmake/common/targets/doxygen.cmake: -------------------------------------------------------------------------------- 1 | function(sourcemeta_target_doxygen) 2 | cmake_parse_arguments(SOURCEMETA_TARGET_DOXYGEN "" "CONFIG;OUTPUT" "" ${ARGN}) 3 | 4 | if(NOT SOURCEMETA_TARGET_DOXYGEN_CONFIG) 5 | message(FATAL_ERROR "You must pass an input config file using the CONFIG option") 6 | endif() 7 | if(NOT SOURCEMETA_TARGET_DOXYGEN_OUTPUT) 8 | message(FATAL_ERROR "You must pass an output directory using the OUTPUT option") 9 | endif() 10 | 11 | find_package(Doxygen) 12 | if(DOXYGEN_FOUND) 13 | set(DOXYGEN_IN "${SOURCEMETA_TARGET_DOXYGEN_CONFIG}") 14 | set(DOXYGEN_OUT "${CMAKE_CURRENT_BINARY_DIR}/Doxyfile") 15 | configure_file("${DOXYGEN_IN}" "${DOXYGEN_OUT}" @ONLY) 16 | add_custom_target(doxygen 17 | WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}" 18 | VERBATIM 19 | COMMAND "${CMAKE_COMMAND}" -E make_directory "${SOURCEMETA_TARGET_DOXYGEN_OUTPUT}" 20 | COMMAND "${DOXYGEN_EXECUTABLE}" "${DOXYGEN_OUT}") 21 | else() 22 | add_custom_target(doxygen VERBATIM 23 | COMMAND "${CMAKE_COMMAND}" -E echo "Could not locate Doxygen" 24 | COMMAND "${CMAKE_COMMAND}" -E false) 25 | endif() 26 | endfunction() 27 | -------------------------------------------------------------------------------- /vendor/core/cmake/common/targets/googlebenchmark.cmake: -------------------------------------------------------------------------------- 1 | function(sourcemeta_googlebenchmark) 2 | cmake_parse_arguments(SOURCEMETA_GOOGLEBENCHMARK "" 3 | "NAMESPACE;PROJECT" "SOURCES" ${ARGN}) 4 | 5 | if(NOT SOURCEMETA_GOOGLEBENCHMARK_PROJECT) 6 | message(FATAL_ERROR "You must pass the project name using the PROJECT option") 7 | endif() 8 | if(NOT SOURCEMETA_GOOGLEBENCHMARK_SOURCES) 9 | message(FATAL_ERROR "You must pass the sources list using the SOURCES option") 10 | endif() 11 | 12 | if(SOURCEMETA_GOOGLEBENCHMARK_NAMESPACE) 13 | set(TARGET_NAME "${SOURCEMETA_GOOGLEBENCHMARK_NAMESPACE}_${SOURCEMETA_GOOGLEBENCHMARK_PROJECT}_benchmark") 14 | set(FOLDER_NAME "${SOURCEMETA_GOOGLEBENCHMARK_NAMESPACE}/${SOURCEMETA_GOOGLEBENCHMARK_PROJECT}") 15 | else() 16 | set(TARGET_NAME "${SOURCEMETA_GOOGLEBENCHMARK_PROJECT}_benchmark") 17 | set(FOLDER_NAME "${SOURCEMETA_GOOGLEBENCHMARK_PROJECT}") 18 | endif() 19 | 20 | add_executable("${TARGET_NAME}" ${SOURCEMETA_GOOGLEBENCHMARK_SOURCES}) 21 | sourcemeta_add_default_options(PRIVATE ${TARGET_NAME}) 22 | set_target_properties("${TARGET_NAME}" PROPERTIES FOLDER "${FOLDER_NAME}") 23 | target_link_libraries("${TARGET_NAME}" PRIVATE benchmark::benchmark) 24 | target_link_libraries("${TARGET_NAME}" PRIVATE benchmark::benchmark_main) 25 | endfunction() 26 | -------------------------------------------------------------------------------- /vendor/core/cmake/common/targets/googletest.cmake: -------------------------------------------------------------------------------- 1 | function(sourcemeta_googletest) 2 | cmake_parse_arguments(SOURCEMETA_GOOGLETEST "" 3 | "NAMESPACE;PROJECT;NAME;VARIANT" "SOURCES" ${ARGN}) 4 | 5 | if(SOURCEMETA_GOOGLETEST_VARIANT) 6 | set(TARGET_VARIANT "${SOURCEMETA_GOOGLETEST_VARIANT}_unit") 7 | else() 8 | set(TARGET_VARIANT "unit") 9 | endif() 10 | 11 | sourcemeta_executable( 12 | NAMESPACE "${SOURCEMETA_GOOGLETEST_NAMESPACE}" 13 | PROJECT "${SOURCEMETA_GOOGLETEST_PROJECT}" 14 | NAME "${SOURCEMETA_GOOGLETEST_NAME}" 15 | VARIANT "${TARGET_VARIANT}" 16 | SOURCES "${SOURCEMETA_GOOGLETEST_SOURCES}" 17 | OUTPUT TARGET_NAME) 18 | 19 | target_link_libraries("${TARGET_NAME}" 20 | PRIVATE GTest::gtest GTest::gmock GTest::gtest_main) 21 | add_test(NAME "${SOURCEMETA_GOOGLETEST_PROJECT}.${SOURCEMETA_GOOGLETEST_NAME}" 22 | COMMAND "${TARGET_NAME}" --gtest_brief=1) 23 | endfunction() 24 | -------------------------------------------------------------------------------- /vendor/core/cmake/common/targets/shellcheck.cmake: -------------------------------------------------------------------------------- 1 | function(sourcemeta_target_shellcheck) 2 | cmake_parse_arguments(SOURCEMETA_TARGET_SHELLCHECK "REQUIRED" "" "SOURCES" ${ARGN}) 3 | 4 | if(SOURCEMETA_TARGET_SHELLCHECK_REQUIRED) 5 | find_program(SHELLCHECK_BIN NAMES shellcheck REQUIRED) 6 | else() 7 | find_program(SHELLCHECK_BIN NAMES shellcheck) 8 | endif() 9 | 10 | # This covers the empty list too 11 | if(NOT SOURCEMETA_TARGET_SHELLCHECK_SOURCES) 12 | message(FATAL_ERROR "You must pass file globs to lint in the SOURCES option") 13 | endif() 14 | file(GLOB_RECURSE SOURCEMETA_TARGET_SHELLCHECK_FILES 15 | ${SOURCEMETA_TARGET_SHELLCHECK_SOURCES}) 16 | 17 | if(SHELLCHECK_BIN) 18 | add_custom_target(shellcheck 19 | WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}" 20 | VERBATIM 21 | COMMAND "${SHELLCHECK_BIN}" ${SOURCEMETA_TARGET_SHELLCHECK_FILES} 22 | COMMENT "Analyzing sources using ShellCheck") 23 | else() 24 | add_custom_target(shellcheck 25 | WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}" 26 | VERBATIM 27 | COMMAND "${CMAKE_COMMAND}" -E echo "Could not locate ShellCheck" 28 | COMMAND "${CMAKE_COMMAND}" -E false) 29 | endif() 30 | 31 | set_target_properties(shellcheck PROPERTIES FOLDER "Linting") 32 | endfunction() 33 | -------------------------------------------------------------------------------- /vendor/core/cmake/common/variables.cmake: -------------------------------------------------------------------------------- 1 | # Get the list of languages defined in the project 2 | get_property(SOURCEMETA_LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES) 3 | 4 | # Compiler detection (C++) 5 | # TODO: Detect compilers on programming languages other than C++ 6 | if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang") 7 | set(SOURCEMETA_COMPILER_LLVM ON) 8 | elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") 9 | set(SOURCEMETA_COMPILER_GCC ON) 10 | elseif(MSVC) 11 | set(SOURCEMETA_COMPILER_MSVC ON) 12 | endif() 13 | 14 | if(CMAKE_SYSTEM_NAME STREQUAL "Darwin") 15 | set(SOURCEMETA_OS_MACOS ON) 16 | # It seems that in some cases, `LINUX` is not set on GNU/Linux on WSL 17 | elseif(LINUX OR CMAKE_SYSTEM_NAME STREQUAL "Linux") 18 | set(SOURCEMETA_OS_LINUX ON) 19 | elseif(WIN32) 20 | set(SOURCEMETA_OS_WINDOWS ON) 21 | elseif(${CMAKE_SYSTEM_NAME} MATCHES ".*BSD") 22 | set(SOURCEMETA_OS_BSD ON) 23 | endif() 24 | -------------------------------------------------------------------------------- /vendor/core/src/core/json/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | sourcemeta_library(NAMESPACE sourcemeta PROJECT core NAME json 2 | PRIVATE_HEADERS array.h error.h object.h value.h hash.h 3 | SOURCES grammar.h parser.h stringify.h json.cc json_value.cc) 4 | 5 | if(SOURCEMETA_CORE_INSTALL) 6 | sourcemeta_library_install(NAMESPACE sourcemeta PROJECT core NAME json) 7 | endif() 8 | -------------------------------------------------------------------------------- /vendor/core/src/core/jsonl/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | sourcemeta_library(NAMESPACE sourcemeta PROJECT core NAME jsonl 2 | PRIVATE_HEADERS iterator.h 3 | SOURCES jsonl.cc iterator.cc grammar.h) 4 | 5 | if(SOURCEMETA_CORE_INSTALL) 6 | sourcemeta_library_install(NAMESPACE sourcemeta PROJECT core NAME jsonl) 7 | endif() 8 | 9 | target_link_libraries(sourcemeta_core_jsonl PUBLIC 10 | sourcemeta::core::json) 11 | -------------------------------------------------------------------------------- /vendor/core/src/core/jsonl/grammar.h: -------------------------------------------------------------------------------- 1 | #ifndef SOURCEMETA_CORE_JSONL_GRAMMAR_H_ 2 | #define SOURCEMETA_CORE_JSONL_GRAMMAR_H_ 3 | 4 | namespace sourcemeta::core::internal { 5 | template 6 | static constexpr CharT token_jsonl_line_feed{'\u000A'}; 7 | 8 | // Whitespace is any sequence of one or more of the following code points: 9 | // character tabulation (U+0009), line feed (U+000A), carriage return (U+000D), 10 | // and space (U+0020). 11 | // See 12 | // https://www.ecma-international.org/wp-content/uploads/ECMA-404_2nd_edition_december_2017.pdf 13 | template 14 | static constexpr CharT token_jsonl_whitespace_tabulation{'\u0009'}; 15 | template 16 | static constexpr CharT token_jsonl_whitespace_carriage_return{'\u000D'}; 17 | template 18 | static constexpr CharT token_jsonl_whitespace_space{'\u0020'}; 19 | 20 | } // namespace sourcemeta::core::internal 21 | 22 | #endif 23 | -------------------------------------------------------------------------------- /vendor/core/src/core/jsonl/jsonl.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include // std::basic_istream 5 | 6 | namespace sourcemeta::core { 7 | 8 | JSONL::JSONL(std::basic_istream &stream) 9 | : data{stream} {} 10 | 11 | auto JSONL::begin() -> JSONL::const_iterator { return {&this->data}; } 12 | auto JSONL::end() -> JSONL::const_iterator { return {nullptr}; } 13 | auto JSONL::cbegin() -> JSONL::const_iterator { return {&this->data}; } 14 | auto JSONL::cend() -> JSONL::const_iterator { return {nullptr}; } 15 | 16 | } // namespace sourcemeta::core 17 | -------------------------------------------------------------------------------- /vendor/core/src/core/jsonpointer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | sourcemeta_library(NAMESPACE sourcemeta PROJECT core NAME jsonpointer 2 | PRIVATE_HEADERS pointer.h position.h error.h token.h 3 | walker.h subpointer_walker.h template.h 4 | SOURCES jsonpointer.cc stringify.h parser.h grammar.h position.cc) 5 | 6 | if(SOURCEMETA_CORE_INSTALL) 7 | sourcemeta_library_install(NAMESPACE sourcemeta PROJECT core NAME jsonpointer) 8 | endif() 9 | 10 | target_link_libraries(sourcemeta_core_jsonpointer PUBLIC 11 | sourcemeta::core::uri) 12 | target_link_libraries(sourcemeta_core_jsonpointer PUBLIC 13 | sourcemeta::core::json) 14 | target_link_libraries(sourcemeta_core_jsonpointer PUBLIC 15 | sourcemeta::core::regex) 16 | -------------------------------------------------------------------------------- /vendor/core/src/core/jsonpointer/include/sourcemeta/core/jsonpointer_error.h: -------------------------------------------------------------------------------- 1 | #ifndef SOURCEMETA_CORE_JSONPOINTER_ERROR_H_ 2 | #define SOURCEMETA_CORE_JSONPOINTER_ERROR_H_ 3 | 4 | #ifndef SOURCEMETA_CORE_JSONPOINTER_EXPORT 5 | #include 6 | #endif 7 | 8 | #include 9 | 10 | #include // std::uint64_t 11 | 12 | namespace sourcemeta::core { 13 | 14 | /// @ingroup jsonpointer 15 | /// This class represents a parsing error. 16 | class SOURCEMETA_CORE_JSONPOINTER_EXPORT PointerParseError 17 | // TODO: It makes no sense for a JSON Pointer error to inherit from a JSON 18 | // error. Make them independent 19 | : public JSONParseError { 20 | public: 21 | /// Create a parsing error 22 | PointerParseError(const std::uint64_t column) : JSONParseError{1, column} {} 23 | 24 | [[nodiscard]] auto what() const noexcept -> const char * override { 25 | return "The input is not a valid JSON Pointer"; 26 | } 27 | }; 28 | 29 | } // namespace sourcemeta::core 30 | 31 | #endif 32 | -------------------------------------------------------------------------------- /vendor/core/src/core/jsonschema/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(OFFICIAL_RESOLVER_INPUT "${CMAKE_CURRENT_SOURCE_DIR}/official_resolver.in.cc") 2 | set(OFFICIAL_RESOLVER_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/official_resolver.cc") 3 | include(./official_resolver.cmake) 4 | 5 | sourcemeta_library(NAMESPACE sourcemeta PROJECT core NAME jsonschema 6 | PRIVATE_HEADERS resolver.h walker.h frame.h error.h types.h transform.h 7 | SOURCES jsonschema.cc official_walker.cc frame.cc 8 | resolver.cc walker.cc bundle.cc transformer.cc 9 | "${CMAKE_CURRENT_BINARY_DIR}/official_resolver.cc") 10 | 11 | if(SOURCEMETA_CORE_INSTALL) 12 | sourcemeta_library_install(NAMESPACE sourcemeta PROJECT core NAME jsonschema) 13 | endif() 14 | 15 | target_link_libraries(sourcemeta_core_jsonschema PUBLIC 16 | sourcemeta::core::json) 17 | target_link_libraries(sourcemeta_core_jsonschema PUBLIC 18 | sourcemeta::core::jsonpointer) 19 | target_link_libraries(sourcemeta_core_jsonschema PRIVATE 20 | sourcemeta::core::uri) 21 | -------------------------------------------------------------------------------- /vendor/core/src/core/regex/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | sourcemeta_library(NAMESPACE sourcemeta PROJECT core NAME regex) 2 | 3 | if(SOURCEMETA_CORE_INSTALL) 4 | sourcemeta_library_install(NAMESPACE sourcemeta PROJECT core NAME regex) 5 | endif() 6 | 7 | target_link_libraries(sourcemeta_core_regex INTERFACE Boost::regex) 8 | -------------------------------------------------------------------------------- /vendor/core/src/core/uri/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | sourcemeta_library(NAMESPACE sourcemeta PROJECT core NAME uri 2 | PRIVATE_HEADERS escape.h error.h 3 | SOURCES uri.cc escaping.cc) 4 | 5 | if(SOURCEMETA_CORE_INSTALL) 6 | sourcemeta_library_install(NAMESPACE sourcemeta PROJECT core NAME uri) 7 | endif() 8 | 9 | target_link_libraries(sourcemeta_core_uri 10 | PRIVATE uriparser::uriparser) 11 | -------------------------------------------------------------------------------- /vendor/core/src/core/yaml/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | sourcemeta_library(NAMESPACE sourcemeta PROJECT core NAME yaml 2 | PRIVATE_HEADERS error.h 3 | SOURCES yaml.cc) 4 | 5 | if(SOURCEMETA_CORE_INSTALL) 6 | sourcemeta_library_install(NAMESPACE sourcemeta PROJECT core NAME yaml) 7 | endif() 8 | 9 | target_link_libraries(sourcemeta_core_yaml PRIVATE yaml) 10 | target_link_libraries(sourcemeta_core_yaml PUBLIC sourcemeta::core::json) 11 | -------------------------------------------------------------------------------- /vendor/core/src/extension/alterschema/antipattern/const_with_type.h: -------------------------------------------------------------------------------- 1 | class ConstWithType final : public SchemaTransformRule { 2 | public: 3 | ConstWithType() 4 | : SchemaTransformRule{ 5 | "const_with_type", 6 | "Setting `type` alongside `const` is considered an anti-pattern, " 7 | "as the constant already implies its respective type"} {}; 8 | 9 | [[nodiscard]] auto 10 | condition(const sourcemeta::core::JSON &schema, 11 | const sourcemeta::core::JSON &, 12 | const sourcemeta::core::Vocabularies &vocabularies, 13 | const sourcemeta::core::SchemaFrame &, 14 | const sourcemeta::core::SchemaFrame::Location &, 15 | const sourcemeta::core::SchemaWalker &, 16 | const sourcemeta::core::SchemaResolver &) const 17 | -> sourcemeta::core::SchemaTransformRule::Result override { 18 | return contains_any( 19 | vocabularies, 20 | {"https://json-schema.org/draft/2020-12/vocab/validation", 21 | "https://json-schema.org/draft/2019-09/vocab/validation", 22 | "http://json-schema.org/draft-07/schema#", 23 | "http://json-schema.org/draft-06/schema#"}) && 24 | schema.is_object() && schema.defines("type") && 25 | schema.defines("const"); 26 | } 27 | 28 | auto transform(JSON &schema) const -> void override { schema.erase("type"); } 29 | }; 30 | -------------------------------------------------------------------------------- /vendor/core/src/extension/alterschema/desugar/boolean_true.h: -------------------------------------------------------------------------------- 1 | class BooleanTrue final : public SchemaTransformRule { 2 | public: 3 | BooleanTrue() 4 | : SchemaTransformRule{ 5 | "boolean_true", 6 | "The boolean schema `true` is syntax sugar for the empty schema"} { 7 | }; 8 | 9 | [[nodiscard]] auto condition(const sourcemeta::core::JSON &schema, 10 | const sourcemeta::core::JSON &, 11 | const sourcemeta::core::Vocabularies &, 12 | const sourcemeta::core::SchemaFrame &, 13 | const sourcemeta::core::SchemaFrame::Location &, 14 | const sourcemeta::core::SchemaWalker &, 15 | const sourcemeta::core::SchemaResolver &) const 16 | -> sourcemeta::core::SchemaTransformRule::Result override { 17 | return schema.is_boolean() && schema.to_boolean(); 18 | } 19 | 20 | auto transform(JSON &schema) const -> void override { 21 | schema.into(sourcemeta::core::JSON::make_object()); 22 | } 23 | }; 24 | -------------------------------------------------------------------------------- /vendor/core/src/extension/alterschema/desugar/const_as_enum.h: -------------------------------------------------------------------------------- 1 | class ConstAsEnum final : public SchemaTransformRule { 2 | public: 3 | ConstAsEnum() 4 | : SchemaTransformRule{"const_as_enum", 5 | "Setting `const` is syntax sugar for an " 6 | "enumeration of a single value"} {}; 7 | 8 | [[nodiscard]] auto 9 | condition(const sourcemeta::core::JSON &schema, 10 | const sourcemeta::core::JSON &, 11 | const sourcemeta::core::Vocabularies &vocabularies, 12 | const sourcemeta::core::SchemaFrame &, 13 | const sourcemeta::core::SchemaFrame::Location &, 14 | const sourcemeta::core::SchemaWalker &, 15 | const sourcemeta::core::SchemaResolver &) const 16 | -> sourcemeta::core::SchemaTransformRule::Result override { 17 | return contains_any( 18 | vocabularies, 19 | {"https://json-schema.org/draft/2020-12/vocab/validation", 20 | "https://json-schema.org/draft/2019-09/vocab/validation", 21 | "http://json-schema.org/draft-07/schema#", 22 | "http://json-schema.org/draft-06/schema#"}) && 23 | schema.is_object() && schema.defines("const") && 24 | !schema.defines("enum"); 25 | } 26 | 27 | auto transform(JSON &schema) const -> void override { 28 | auto values = sourcemeta::core::JSON::make_array(); 29 | values.push_back(schema.at("const")); 30 | schema.at("const").into(std::move(values)); 31 | schema.rename("const", "enum"); 32 | } 33 | }; 34 | -------------------------------------------------------------------------------- /vendor/core/src/extension/alterschema/redundant/content_schema_default.h: -------------------------------------------------------------------------------- 1 | class ContentSchemaDefault final : public SchemaTransformRule { 2 | public: 3 | ContentSchemaDefault() 4 | : SchemaTransformRule{ 5 | "content_schema_default", 6 | "Setting the `contentSchema` keyword to the true schema " 7 | "does not add any further constraint"} {}; 8 | 9 | [[nodiscard]] auto 10 | condition(const sourcemeta::core::JSON &schema, 11 | const sourcemeta::core::JSON &, 12 | const sourcemeta::core::Vocabularies &vocabularies, 13 | const sourcemeta::core::SchemaFrame &, 14 | const sourcemeta::core::SchemaFrame::Location &, 15 | const sourcemeta::core::SchemaWalker &, 16 | const sourcemeta::core::SchemaResolver &) const 17 | -> sourcemeta::core::SchemaTransformRule::Result override { 18 | return contains_any( 19 | vocabularies, 20 | {"https://json-schema.org/draft/2020-12/vocab/content", 21 | "https://json-schema.org/draft/2019-09/vocab/content"}) && 22 | schema.is_object() && schema.defines("contentSchema") && 23 | ((schema.at("contentSchema").is_boolean() && 24 | schema.at("contentSchema").to_boolean()) || 25 | (schema.at("contentSchema").is_object() && 26 | schema.at("contentSchema").empty())); 27 | } 28 | 29 | auto transform(JSON &schema) const -> void override { 30 | schema.erase("contentSchema"); 31 | } 32 | }; 33 | -------------------------------------------------------------------------------- /vendor/core/src/extension/alterschema/redundant/dependencies_default.h: -------------------------------------------------------------------------------- 1 | class DependenciesDefault final : public SchemaTransformRule { 2 | public: 3 | DependenciesDefault() 4 | : SchemaTransformRule{ 5 | "dependencies_default", 6 | "Setting the `dependencies` keyword to an empty object " 7 | "does not add any further constraint"} {}; 8 | 9 | [[nodiscard]] auto 10 | condition(const sourcemeta::core::JSON &schema, 11 | const sourcemeta::core::JSON &, 12 | const sourcemeta::core::Vocabularies &vocabularies, 13 | const sourcemeta::core::SchemaFrame &, 14 | const sourcemeta::core::SchemaFrame::Location &, 15 | const sourcemeta::core::SchemaWalker &, 16 | const sourcemeta::core::SchemaResolver &) const 17 | -> sourcemeta::core::SchemaTransformRule::Result override { 18 | return contains_any(vocabularies, 19 | {"http://json-schema.org/draft-07/schema#", 20 | "http://json-schema.org/draft-06/schema#", 21 | "http://json-schema.org/draft-04/schema#", 22 | "http://json-schema.org/draft-03/schema#"}) && 23 | schema.is_object() && schema.defines("dependencies") && 24 | schema.at("dependencies").is_object() && 25 | schema.at("dependencies").empty(); 26 | } 27 | 28 | auto transform(JSON &schema) const -> void override { 29 | schema.erase("dependencies"); 30 | } 31 | }; 32 | -------------------------------------------------------------------------------- /vendor/core/src/extension/alterschema/redundant/dependent_required_default.h: -------------------------------------------------------------------------------- 1 | class DependentRequiredDefault final : public SchemaTransformRule { 2 | public: 3 | DependentRequiredDefault() 4 | : SchemaTransformRule{ 5 | "dependent_required_default", 6 | "Setting the `dependentRequired` keyword to an empty object " 7 | "does not add any further constraint"} {}; 8 | 9 | [[nodiscard]] auto 10 | condition(const sourcemeta::core::JSON &schema, 11 | const sourcemeta::core::JSON &, 12 | const sourcemeta::core::Vocabularies &vocabularies, 13 | const sourcemeta::core::SchemaFrame &, 14 | const sourcemeta::core::SchemaFrame::Location &, 15 | const sourcemeta::core::SchemaWalker &, 16 | const sourcemeta::core::SchemaResolver &) const 17 | -> sourcemeta::core::SchemaTransformRule::Result override { 18 | return contains_any( 19 | vocabularies, 20 | {"https://json-schema.org/draft/2020-12/vocab/validation", 21 | "https://json-schema.org/draft/2019-09/vocab/validation"}) && 22 | schema.is_object() && schema.defines("dependentRequired") && 23 | schema.at("dependentRequired").is_object() && 24 | schema.at("dependentRequired").empty(); 25 | } 26 | 27 | auto transform(JSON &schema) const -> void override { 28 | schema.erase("dependentRequired"); 29 | } 30 | }; 31 | -------------------------------------------------------------------------------- /vendor/core/src/extension/alterschema/redundant/unevaluated_items_default.h: -------------------------------------------------------------------------------- 1 | class UnevaluatedItemsDefault final : public SchemaTransformRule { 2 | public: 3 | UnevaluatedItemsDefault() 4 | : SchemaTransformRule{ 5 | "unevaluated_items_default", 6 | "Setting the `unevaluatedItems` keyword to the true schema " 7 | "does not add any further constraint"} {}; 8 | 9 | [[nodiscard]] auto 10 | condition(const sourcemeta::core::JSON &schema, 11 | const sourcemeta::core::JSON &, 12 | const sourcemeta::core::Vocabularies &vocabularies, 13 | const sourcemeta::core::SchemaFrame &, 14 | const sourcemeta::core::SchemaFrame::Location &, 15 | const sourcemeta::core::SchemaWalker &, 16 | const sourcemeta::core::SchemaResolver &) const 17 | -> sourcemeta::core::SchemaTransformRule::Result override { 18 | return contains_any( 19 | vocabularies, 20 | {"https://json-schema.org/draft/2020-12/vocab/unevaluated", 21 | "https://json-schema.org/draft/2019-09/vocab/applicator"}) && 22 | schema.is_object() && schema.defines("unevaluatedItems") && 23 | ((schema.at("unevaluatedItems").is_boolean() && 24 | schema.at("unevaluatedItems").to_boolean()) || 25 | (schema.at("unevaluatedItems").is_object() && 26 | schema.at("unevaluatedItems").empty())); 27 | } 28 | 29 | auto transform(JSON &schema) const -> void override { 30 | schema.erase("unevaluatedItems"); 31 | } 32 | }; 33 | -------------------------------------------------------------------------------- /vendor/core/src/extension/alterschema/superfluous/content_media_type_without_encoding.h: -------------------------------------------------------------------------------- 1 | class ContentMediaTypeWithoutEncoding final : public SchemaTransformRule { 2 | public: 3 | ContentMediaTypeWithoutEncoding() 4 | : SchemaTransformRule{ 5 | "content_media_type_without_encoding", 6 | "The `contentMediaType` keyword is meaningless " 7 | "without the presence of the `contentEncoding` keyword"} {}; 8 | 9 | [[nodiscard]] auto 10 | condition(const sourcemeta::core::JSON &schema, 11 | const sourcemeta::core::JSON &, 12 | const sourcemeta::core::Vocabularies &vocabularies, 13 | const sourcemeta::core::SchemaFrame &, 14 | const sourcemeta::core::SchemaFrame::Location &, 15 | const sourcemeta::core::SchemaWalker &, 16 | const sourcemeta::core::SchemaResolver &) const 17 | -> sourcemeta::core::SchemaTransformRule::Result override { 18 | return contains_any(vocabularies, 19 | {"https://json-schema.org/draft/2020-12/vocab/content", 20 | "https://json-schema.org/draft/2019-09/vocab/content", 21 | "http://json-schema.org/draft-07/schema#"}) && 22 | schema.is_object() && schema.defines("contentMediaType") && 23 | !schema.defines("contentEncoding"); 24 | } 25 | 26 | auto transform(JSON &schema) const -> void override { 27 | schema.erase("contentMediaType"); 28 | } 29 | }; 30 | -------------------------------------------------------------------------------- /vendor/core/src/extension/alterschema/superfluous/content_schema_without_media_type.h: -------------------------------------------------------------------------------- 1 | class ContentSchemaWithoutMediaType final : public SchemaTransformRule { 2 | public: 3 | ContentSchemaWithoutMediaType() 4 | : SchemaTransformRule{ 5 | "content_schema_without_media_type", 6 | "The `contentSchema` keyword is meaningless without the presence " 7 | "of the `contentMediaType` keyword"} {}; 8 | 9 | [[nodiscard]] auto 10 | condition(const sourcemeta::core::JSON &schema, 11 | const sourcemeta::core::JSON &, 12 | const sourcemeta::core::Vocabularies &vocabularies, 13 | const sourcemeta::core::SchemaFrame &, 14 | const sourcemeta::core::SchemaFrame::Location &, 15 | const sourcemeta::core::SchemaWalker &, 16 | const sourcemeta::core::SchemaResolver &) const 17 | -> sourcemeta::core::SchemaTransformRule::Result override { 18 | return contains_any( 19 | vocabularies, 20 | {"https://json-schema.org/draft/2020-12/vocab/content", 21 | "https://json-schema.org/draft/2019-09/vocab/content"}) && 22 | schema.is_object() && schema.defines("contentSchema") && 23 | !schema.defines("contentMediaType"); 24 | } 25 | 26 | auto transform(JSON &schema) const -> void override { 27 | schema.erase("contentSchema"); 28 | } 29 | }; 30 | -------------------------------------------------------------------------------- /vendor/core/src/extension/alterschema/superfluous/else_without_if.h: -------------------------------------------------------------------------------- 1 | class ElseWithoutIf final : public SchemaTransformRule { 2 | public: 3 | ElseWithoutIf() 4 | : SchemaTransformRule{"else_without_if", 5 | "The `else` keyword is meaningless " 6 | "without the presence of the `if` keyword"} {}; 7 | 8 | [[nodiscard]] auto 9 | condition(const sourcemeta::core::JSON &schema, 10 | const sourcemeta::core::JSON &, 11 | const sourcemeta::core::Vocabularies &vocabularies, 12 | const sourcemeta::core::SchemaFrame &, 13 | const sourcemeta::core::SchemaFrame::Location &, 14 | const sourcemeta::core::SchemaWalker &, 15 | const sourcemeta::core::SchemaResolver &) const 16 | -> sourcemeta::core::SchemaTransformRule::Result override { 17 | return contains_any( 18 | vocabularies, 19 | {"https://json-schema.org/draft/2020-12/vocab/applicator", 20 | "https://json-schema.org/draft/2019-09/vocab/applicator", 21 | "http://json-schema.org/draft-07/schema#"}) && 22 | schema.is_object() && schema.defines("else") && 23 | !schema.defines("if"); 24 | } 25 | 26 | auto transform(JSON &schema) const -> void override { schema.erase("else"); } 27 | }; 28 | -------------------------------------------------------------------------------- /vendor/core/src/extension/alterschema/superfluous/if_without_then_else.h: -------------------------------------------------------------------------------- 1 | class IfWithoutThenElse final : public SchemaTransformRule { 2 | public: 3 | IfWithoutThenElse() 4 | : SchemaTransformRule{ 5 | "if_without_then_else", 6 | "The `if` keyword is meaningless " 7 | "without the presence of the `then` or `else` keywords"} {}; 8 | 9 | [[nodiscard]] auto 10 | condition(const sourcemeta::core::JSON &schema, 11 | const sourcemeta::core::JSON &, 12 | const sourcemeta::core::Vocabularies &vocabularies, 13 | const sourcemeta::core::SchemaFrame &, 14 | const sourcemeta::core::SchemaFrame::Location &, 15 | const sourcemeta::core::SchemaWalker &, 16 | const sourcemeta::core::SchemaResolver &) const 17 | -> sourcemeta::core::SchemaTransformRule::Result override { 18 | return contains_any( 19 | vocabularies, 20 | {"https://json-schema.org/draft/2020-12/vocab/applicator", 21 | "https://json-schema.org/draft/2019-09/vocab/applicator", 22 | "http://json-schema.org/draft-07/schema#"}) && 23 | schema.is_object() && schema.defines("if") && 24 | !schema.defines("then") && !schema.defines("else"); 25 | } 26 | 27 | auto transform(JSON &schema) const -> void override { schema.erase("if"); } 28 | }; 29 | -------------------------------------------------------------------------------- /vendor/core/src/extension/alterschema/superfluous/max_contains_without_contains.h: -------------------------------------------------------------------------------- 1 | class MaxContainsWithoutContains final : public SchemaTransformRule { 2 | public: 3 | MaxContainsWithoutContains() 4 | : SchemaTransformRule{"max_contains_without_contains", 5 | "The `maxContains` keyword is meaningless " 6 | "without the presence of the `contains` keyword"} { 7 | }; 8 | 9 | [[nodiscard]] auto 10 | condition(const sourcemeta::core::JSON &schema, 11 | const sourcemeta::core::JSON &, 12 | const sourcemeta::core::Vocabularies &vocabularies, 13 | const sourcemeta::core::SchemaFrame &, 14 | const sourcemeta::core::SchemaFrame::Location &, 15 | const sourcemeta::core::SchemaWalker &, 16 | const sourcemeta::core::SchemaResolver &) const 17 | -> sourcemeta::core::SchemaTransformRule::Result override { 18 | return contains_any( 19 | vocabularies, 20 | {"https://json-schema.org/draft/2020-12/vocab/validation", 21 | "https://json-schema.org/draft/2019-09/vocab/validation"}) && 22 | schema.is_object() && schema.defines("maxContains") && 23 | !schema.defines("contains"); 24 | } 25 | 26 | auto transform(JSON &schema) const -> void override { 27 | schema.erase("maxContains"); 28 | } 29 | }; 30 | -------------------------------------------------------------------------------- /vendor/core/src/extension/alterschema/superfluous/min_contains_without_contains.h: -------------------------------------------------------------------------------- 1 | class MinContainsWithoutContains final : public SchemaTransformRule { 2 | public: 3 | MinContainsWithoutContains() 4 | : SchemaTransformRule{"min_contains_without_contains", 5 | "The `minContains` keyword is meaningless " 6 | "without the presence of the `contains` keyword"} { 7 | }; 8 | 9 | [[nodiscard]] auto 10 | condition(const sourcemeta::core::JSON &schema, 11 | const sourcemeta::core::JSON &, 12 | const sourcemeta::core::Vocabularies &vocabularies, 13 | const sourcemeta::core::SchemaFrame &, 14 | const sourcemeta::core::SchemaFrame::Location &, 15 | const sourcemeta::core::SchemaWalker &, 16 | const sourcemeta::core::SchemaResolver &) const 17 | -> sourcemeta::core::SchemaTransformRule::Result override { 18 | return contains_any( 19 | vocabularies, 20 | {"https://json-schema.org/draft/2020-12/vocab/validation", 21 | "https://json-schema.org/draft/2019-09/vocab/validation"}) && 22 | schema.is_object() && schema.defines("minContains") && 23 | !schema.defines("contains"); 24 | } 25 | 26 | auto transform(JSON &schema) const -> void override { 27 | schema.erase("minContains"); 28 | } 29 | }; 30 | -------------------------------------------------------------------------------- /vendor/core/src/extension/alterschema/superfluous/then_without_if.h: -------------------------------------------------------------------------------- 1 | class ThenWithoutIf final : public SchemaTransformRule { 2 | public: 3 | ThenWithoutIf() 4 | : SchemaTransformRule{"then_without_if", 5 | "The `then` keyword is meaningless " 6 | "without the presence of the `if` keyword"} {}; 7 | 8 | [[nodiscard]] auto 9 | condition(const sourcemeta::core::JSON &schema, 10 | const sourcemeta::core::JSON &, 11 | const sourcemeta::core::Vocabularies &vocabularies, 12 | const sourcemeta::core::SchemaFrame &, 13 | const sourcemeta::core::SchemaFrame::Location &, 14 | const sourcemeta::core::SchemaWalker &, 15 | const sourcemeta::core::SchemaResolver &) const 16 | -> sourcemeta::core::SchemaTransformRule::Result override { 17 | return contains_any( 18 | vocabularies, 19 | {"https://json-schema.org/draft/2020-12/vocab/applicator", 20 | "https://json-schema.org/draft/2019-09/vocab/applicator", 21 | "http://json-schema.org/draft-07/schema#"}) && 22 | schema.is_object() && schema.defines("then") && 23 | !schema.defines("if"); 24 | } 25 | 26 | auto transform(JSON &schema) const -> void override { schema.erase("then"); } 27 | }; 28 | -------------------------------------------------------------------------------- /vendor/core/src/extension/alterschema/syntax_sugar/enum_to_const.h: -------------------------------------------------------------------------------- 1 | class EnumToConst final : public SchemaTransformRule { 2 | public: 3 | EnumToConst() 4 | : SchemaTransformRule{ 5 | "enum_to_const", 6 | "An `enum` of a single value can be expressed as `const`"} {}; 7 | 8 | [[nodiscard]] auto 9 | condition(const sourcemeta::core::JSON &schema, 10 | const sourcemeta::core::JSON &, 11 | const sourcemeta::core::Vocabularies &vocabularies, 12 | const sourcemeta::core::SchemaFrame &, 13 | const sourcemeta::core::SchemaFrame::Location &, 14 | const sourcemeta::core::SchemaWalker &, 15 | const sourcemeta::core::SchemaResolver &) const 16 | -> sourcemeta::core::SchemaTransformRule::Result override { 17 | return contains_any( 18 | vocabularies, 19 | {"https://json-schema.org/draft/2020-12/vocab/validation", 20 | "https://json-schema.org/draft/2019-09/vocab/validation", 21 | "http://json-schema.org/draft-07/schema#", 22 | "http://json-schema.org/draft-06/schema#"}) && 23 | schema.is_object() && !schema.defines("const") && 24 | schema.defines("enum") && schema.at("enum").is_array() && 25 | schema.at("enum").size() == 1; 26 | } 27 | 28 | auto transform(JSON &schema) const -> void override { 29 | auto front{schema.at("enum").front()}; 30 | schema.at("enum").into(front); 31 | schema.rename("enum", "const"); 32 | } 33 | }; 34 | -------------------------------------------------------------------------------- /vendor/core/vendor/boost-regex.mask: -------------------------------------------------------------------------------- 1 | build/ 2 | doc/ 3 | example/ 4 | meta/ 5 | performance/ 6 | src/ 7 | test/ 8 | tools/ 9 | CMakeLists.txt 10 | index.html 11 | README.md 12 | readme.txt 13 | -------------------------------------------------------------------------------- /vendor/core/vendor/boost-regex/include/boost/cregex.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 1998-2002 4 | * John Maddock 5 | * 6 | * Use, modification and distribution are subject to the 7 | * Boost Software License, Version 1.0. (See accompanying file 8 | * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | * 10 | */ 11 | 12 | /* 13 | * LOCATION: see http://www.boost.org/libs/regex for most recent version. 14 | * FILE cregex.cpp 15 | * VERSION see 16 | * DESCRIPTION: Declares POSIX API functions 17 | * + boost::RegEx high level wrapper. 18 | */ 19 | 20 | #ifndef BOOST_RE_CREGEX_HPP 21 | #define BOOST_RE_CREGEX_HPP 22 | 23 | #ifndef BOOST_REGEX_CONFIG_HPP 24 | #include 25 | #endif 26 | 27 | #ifdef BOOST_REGEX_CXX03 28 | #include 29 | #else 30 | #include 31 | #endif 32 | 33 | #endif /* include guard */ 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | -------------------------------------------------------------------------------- /vendor/core/vendor/boost-regex/include/boost/regex.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 1998-2002 4 | * John Maddock 5 | * 6 | * Use, modification and distribution are subject to the 7 | * Boost Software License, Version 1.0. (See accompanying file 8 | * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | * 10 | */ 11 | 12 | /* 13 | * LOCATION: see http://www.boost.org/libs/regex for documentation. 14 | * FILE regex.cpp 15 | * VERSION see 16 | * DESCRIPTION: Declares boost::basic_regex<> and associated 17 | * functions and classes. This header is the main 18 | * entry point for the template regex code. 19 | */ 20 | 21 | 22 | /* start with C compatibility API */ 23 | 24 | #ifndef BOOST_RE_REGEX_HPP 25 | #define BOOST_RE_REGEX_HPP 26 | 27 | #ifndef BOOST_REGEX_CONFIG_HPP 28 | #include 29 | #endif 30 | 31 | #ifdef BOOST_REGEX_CXX03 32 | #include 33 | #else 34 | #include 35 | #endif 36 | 37 | #endif // include 38 | 39 | 40 | 41 | 42 | -------------------------------------------------------------------------------- /vendor/core/vendor/boost-regex/include/boost/regex/icu.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2020 4 | * John Maddock 5 | * 6 | * Use, modification and distribution are subject to the 7 | * Boost Software License, Version 1.0. (See accompanying file 8 | * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | * 10 | */ 11 | 12 | /* 13 | * LOCATION: see http://www.boost.org for most recent version. 14 | * FILE icu.hpp 15 | * VERSION see 16 | * DESCRIPTION: Unicode regular expressions on top of the ICU Library. 17 | */ 18 | 19 | #ifndef BOOST_REGEX_ICU_HPP 20 | #define BOOST_REGEX_ICU_HPP 21 | 22 | #include 23 | 24 | #ifdef BOOST_REGEX_CXX03 25 | #include 26 | #else 27 | #include 28 | #endif 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /vendor/core/vendor/boost-regex/include/boost/regex/pattern_except.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 1998-2002 4 | * John Maddock 5 | * 6 | * Use, modification and distribution are subject to the 7 | * Boost Software License, Version 1.0. (See accompanying file 8 | * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | * 10 | */ 11 | 12 | /* 13 | * LOCATION: see http://www.boost.org for most recent version. 14 | * FILE pattern_except.hpp 15 | * VERSION see 16 | * DESCRIPTION: Declares pattern-matching exception classes. 17 | */ 18 | 19 | #ifndef BOOST_RE_PAT_EXCEPT_HPP 20 | #define BOOST_RE_PAT_EXCEPT_HPP 21 | 22 | #ifndef BOOST_REGEX_CONFIG_HPP 23 | #include 24 | #endif 25 | 26 | #ifdef BOOST_REGEX_CXX03 27 | #include 28 | #else 29 | #include 30 | #endif 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /vendor/core/vendor/boost-regex/include/boost/regex/pending/object_cache.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2004 4 | * John Maddock 5 | * 6 | * Use, modification and distribution are subject to the 7 | * Boost Software License, Version 1.0. (See accompanying file 8 | * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | * 10 | */ 11 | 12 | /* 13 | * LOCATION: see http://www.boost.org for most recent version. 14 | * FILE object_cache.hpp 15 | * VERSION see 16 | * DESCRIPTION: Implements a generic object cache. 17 | */ 18 | 19 | #ifndef BOOST_REGEX_OBJECT_CACHE_HPP 20 | #define BOOST_REGEX_OBJECT_CACHE_HPP 21 | 22 | #include 23 | #ifdef BOOST_REGEX_CXX03 24 | #include 25 | #else 26 | #include 27 | #endif 28 | 29 | #endif 30 | -------------------------------------------------------------------------------- /vendor/core/vendor/boost-regex/include/boost/regex/pending/unicode_iterator.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2020 4 | * John Maddock 5 | * 6 | * Use, modification and distribution are subject to the 7 | * Boost Software License, Version 1.0. (See accompanying file 8 | * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | * 10 | */ 11 | 12 | /* 13 | * LOCATION: see http://www.boost.org for most recent version. 14 | * FILE unicode_iterator.hpp 15 | * VERSION see 16 | * DESCRIPTION: Iterator adapters for converting between different Unicode encodings. 17 | */ 18 | 19 | #ifndef BOOST_REGEX_PENDING_UNICODE_ITERATOR_HPP 20 | #define BOOST_REGEX_PENDING_UNICODE_ITERATOR_HPP 21 | 22 | #include 23 | 24 | #if defined(BOOST_REGEX_CXX03) 25 | #include 26 | #else 27 | #include 28 | #endif 29 | 30 | 31 | #endif // BOOST_REGEX_PENDING_UNICODE_ITERATOR_HPP 32 | 33 | -------------------------------------------------------------------------------- /vendor/core/vendor/boost-regex/include/boost/regex/regex_traits.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 1998-2002 4 | * John Maddock 5 | * 6 | * Use, modification and distribution are subject to the 7 | * Boost Software License, Version 1.0. (See accompanying file 8 | * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | * 10 | */ 11 | 12 | /* 13 | * LOCATION: see http://www.boost.org for most recent version. 14 | * FILE regex_traits.hpp 15 | * VERSION see 16 | * DESCRIPTION: Declares regular expression traits classes. 17 | */ 18 | 19 | #ifndef BOOST_REGEX_TRAITS_HPP 20 | #define BOOST_REGEX_TRAITS_HPP 21 | 22 | #ifndef BOOST_REGEX_CONFIG_HPP 23 | # include 24 | #endif 25 | 26 | # ifndef BOOST_REGEX_TRAITS_HPP_INCLUDED 27 | #ifdef BOOST_REGEX_CXX03 28 | # include 29 | #else 30 | # include 31 | #endif 32 | # endif 33 | 34 | #endif // include 35 | 36 | 37 | 38 | 39 | 40 | -------------------------------------------------------------------------------- /vendor/core/vendor/boost-regex/include/boost/regex/v4/error_type.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2003-2005 4 | * John Maddock 5 | * 6 | * Use, modification and distribution are subject to the 7 | * Boost Software License, Version 1.0. (See accompanying file 8 | * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | * 10 | */ 11 | 12 | /* 13 | * LOCATION: see http://www.boost.org for most recent version. 14 | * FILE error_type.hpp 15 | * VERSION see 16 | * DESCRIPTION: Declares regular expression error type enumerator. 17 | */ 18 | 19 | #ifndef BOOST_REGEX_ERROR_TYPE_HPP 20 | #define BOOST_REGEX_ERROR_TYPE_HPP 21 | 22 | #ifdef __cplusplus 23 | namespace boost{ 24 | #endif 25 | 26 | #ifdef __cplusplus 27 | namespace regex_constants{ 28 | 29 | enum error_type{ 30 | 31 | error_ok = 0, /* not used */ 32 | error_no_match = 1, /* not used */ 33 | error_bad_pattern = 2, 34 | error_collate = 3, 35 | error_ctype = 4, 36 | error_escape = 5, 37 | error_backref = 6, 38 | error_brack = 7, 39 | error_paren = 8, 40 | error_brace = 9, 41 | error_badbrace = 10, 42 | error_range = 11, 43 | error_space = 12, 44 | error_badrepeat = 13, 45 | error_end = 14, /* not used */ 46 | error_size = 15, 47 | error_right_paren = 16, /* not used */ 48 | error_empty = 17, 49 | error_complexity = 18, 50 | error_stack = 19, 51 | error_perl_extension = 20, 52 | error_unknown = 21 53 | }; 54 | 55 | } 56 | } 57 | #endif /* __cplusplus */ 58 | 59 | #endif 60 | -------------------------------------------------------------------------------- /vendor/core/vendor/boost-regex/include/boost/regex/v4/indexed_bit_flag.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2020 4 | * John Maddock 5 | * 6 | * Use, modification and distribution are subject to the 7 | * Boost Software License, Version 1.0. (See accompanying file 8 | * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | * 10 | */ 11 | 12 | /* 13 | * LOCATION: see http://www.boost.org for most recent version. 14 | * FILE basic_regex_parser.cpp 15 | * VERSION see 16 | * DESCRIPTION: Declares template class basic_regex_parser. 17 | */ 18 | 19 | #include 20 | #include 21 | 22 | #ifndef BOOST_REGEX_V4_INDEXED_BIT_FLAG_HPP 23 | #define BOOST_REGEX_V4_INDEXED_BIT_FLAG_HPP 24 | 25 | namespace boost{ 26 | namespace BOOST_REGEX_DETAIL_NS{ 27 | 28 | class indexed_bit_flag 29 | { 30 | boost::uint64_t low_mask; 31 | std::set mask_set; 32 | public: 33 | indexed_bit_flag() : low_mask(0) {} 34 | void set(std::size_t i) 35 | { 36 | if (i < std::numeric_limits::digits - 1) 37 | low_mask |= static_cast(1u) << i; 38 | else 39 | mask_set.insert(i); 40 | } 41 | bool test(std::size_t i) 42 | { 43 | if (i < std::numeric_limits::digits - 1) 44 | return low_mask & static_cast(1u) << i ? true : false; 45 | else 46 | return mask_set.find(i) != mask_set.end(); 47 | } 48 | }; 49 | 50 | } // namespace BOOST_REGEX_DETAIL_NS 51 | } // namespace boost 52 | 53 | 54 | #endif 55 | -------------------------------------------------------------------------------- /vendor/core/vendor/boost-regex/include/boost/regex/v5/error_type.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2003-2005 4 | * John Maddock 5 | * 6 | * Use, modification and distribution are subject to the 7 | * Boost Software License, Version 1.0. (See accompanying file 8 | * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | * 10 | */ 11 | 12 | /* 13 | * LOCATION: see http://www.boost.org for most recent version. 14 | * FILE error_type.hpp 15 | * VERSION see 16 | * DESCRIPTION: Declares regular expression error type enumerator. 17 | */ 18 | 19 | #ifndef BOOST_REGEX_ERROR_TYPE_HPP 20 | #define BOOST_REGEX_ERROR_TYPE_HPP 21 | 22 | #ifdef __cplusplus 23 | namespace boost{ 24 | #endif 25 | 26 | #ifdef __cplusplus 27 | namespace regex_constants{ 28 | 29 | enum error_type{ 30 | 31 | error_ok = 0, /* not used */ 32 | error_no_match = 1, /* not used */ 33 | error_bad_pattern = 2, 34 | error_collate = 3, 35 | error_ctype = 4, 36 | error_escape = 5, 37 | error_backref = 6, 38 | error_brack = 7, 39 | error_paren = 8, 40 | error_brace = 9, 41 | error_badbrace = 10, 42 | error_range = 11, 43 | error_space = 12, 44 | error_badrepeat = 13, 45 | error_end = 14, /* not used */ 46 | error_size = 15, 47 | error_right_paren = 16, /* not used */ 48 | error_empty = 17, 49 | error_complexity = 18, 50 | error_stack = 19, 51 | error_perl_extension = 20, 52 | error_unknown = 21 53 | }; 54 | 55 | } 56 | } 57 | #endif /* __cplusplus */ 58 | 59 | #endif 60 | -------------------------------------------------------------------------------- /vendor/core/vendor/boost-regex/include/boost/regex/v5/iterator_traits.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 1998-2002 4 | * John Maddock 5 | * 6 | * Use, modification and distribution are subject to the 7 | * Boost Software License, Version 1.0. (See accompanying file 8 | * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | * 10 | */ 11 | 12 | /* 13 | * LOCATION: see http://www.boost.org for most recent version. 14 | * FILE iterator_traits.cpp 15 | * VERSION see 16 | * DESCRIPTION: Declares iterator traits workarounds. 17 | */ 18 | 19 | #ifndef BOOST_REGEX_V5_ITERATOR_TRAITS_HPP 20 | #define BOOST_REGEX_V5_ITERATOR_TRAITS_HPP 21 | 22 | namespace boost{ 23 | namespace BOOST_REGEX_DETAIL_NS{ 24 | 25 | template 26 | struct regex_iterator_traits : public std::iterator_traits {}; 27 | 28 | } // namespace BOOST_REGEX_DETAIL_NS 29 | } // namespace boost 30 | 31 | #endif 32 | 33 | -------------------------------------------------------------------------------- /vendor/core/vendor/boost-regex/include/boost/regex_fwd.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 1998-2002 4 | * John Maddock 5 | * 6 | * Use, modification and distribution are subject to the 7 | * Boost Software License, Version 1.0. (See accompanying file 8 | * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | * 10 | */ 11 | 12 | /* 13 | * LOCATION: see http://www.boost.org/libs/regex for documentation. 14 | * FILE regex_fwd.cpp 15 | * VERSION see 16 | * DESCRIPTION: Forward declares boost::basic_regex<> and 17 | * associated typedefs. 18 | */ 19 | 20 | #ifndef BOOST_REGEX_FWD_HPP 21 | #define BOOST_REGEX_FWD_HPP 22 | 23 | #ifndef BOOST_REGEX_CONFIG_HPP 24 | #include 25 | #endif 26 | 27 | #ifdef BOOST_REGEX_CXX03 28 | #include 29 | #else 30 | #include 31 | #endif 32 | 33 | #endif 34 | 35 | 36 | 37 | 38 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/cmake/Config.cmake.in: -------------------------------------------------------------------------------- 1 | @PACKAGE_INIT@ 2 | 3 | include (CMakeFindDependencyMacro) 4 | 5 | find_dependency (Threads) 6 | 7 | if (@BENCHMARK_ENABLE_LIBPFM@) 8 | find_dependency (PFM) 9 | endif() 10 | 11 | include("${CMAKE_CURRENT_LIST_DIR}/@targets_export_name@.cmake") 12 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/cmake/GetGitVersion.cmake: -------------------------------------------------------------------------------- 1 | # - Returns a version string from Git tags 2 | # 3 | # This function inspects the annotated git tags for the project and returns a string 4 | # into a CMake variable 5 | # 6 | # get_git_version() 7 | # 8 | # - Example 9 | # 10 | # include(GetGitVersion) 11 | # get_git_version(GIT_VERSION) 12 | # 13 | # Requires CMake 2.8.11+ 14 | find_package(Git) 15 | 16 | if(__get_git_version) 17 | return() 18 | endif() 19 | set(__get_git_version INCLUDED) 20 | 21 | function(get_git_version var) 22 | if(GIT_EXECUTABLE) 23 | execute_process(COMMAND ${GIT_EXECUTABLE} describe --tags --match "v[0-9]*.[0-9]*.[0-9]*" --abbrev=8 --dirty 24 | WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} 25 | RESULT_VARIABLE status 26 | OUTPUT_VARIABLE GIT_VERSION 27 | ERROR_QUIET) 28 | if(status) 29 | set(GIT_VERSION "v0.0.0") 30 | endif() 31 | else() 32 | set(GIT_VERSION "v0.0.0") 33 | endif() 34 | 35 | set(${var} ${GIT_VERSION} PARENT_SCOPE) 36 | endfunction() 37 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/cmake/Modules/FindLLVMAr.cmake: -------------------------------------------------------------------------------- 1 | include(FeatureSummary) 2 | 3 | find_program(LLVMAR_EXECUTABLE 4 | NAMES llvm-ar 5 | DOC "The llvm-ar executable" 6 | ) 7 | 8 | include(FindPackageHandleStandardArgs) 9 | find_package_handle_standard_args(LLVMAr 10 | DEFAULT_MSG 11 | LLVMAR_EXECUTABLE) 12 | 13 | SET_PACKAGE_PROPERTIES(LLVMAr PROPERTIES 14 | URL https://llvm.org/docs/CommandGuide/llvm-ar.html 15 | DESCRIPTION "create, modify, and extract from archives" 16 | ) 17 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/cmake/Modules/FindLLVMNm.cmake: -------------------------------------------------------------------------------- 1 | include(FeatureSummary) 2 | 3 | find_program(LLVMNM_EXECUTABLE 4 | NAMES llvm-nm 5 | DOC "The llvm-nm executable" 6 | ) 7 | 8 | include(FindPackageHandleStandardArgs) 9 | find_package_handle_standard_args(LLVMNm 10 | DEFAULT_MSG 11 | LLVMNM_EXECUTABLE) 12 | 13 | SET_PACKAGE_PROPERTIES(LLVMNm PROPERTIES 14 | URL https://llvm.org/docs/CommandGuide/llvm-nm.html 15 | DESCRIPTION "list LLVM bitcode and object file’s symbol table" 16 | ) 17 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/cmake/Modules/FindLLVMRanLib.cmake: -------------------------------------------------------------------------------- 1 | include(FeatureSummary) 2 | 3 | find_program(LLVMRANLIB_EXECUTABLE 4 | NAMES llvm-ranlib 5 | DOC "The llvm-ranlib executable" 6 | ) 7 | 8 | include(FindPackageHandleStandardArgs) 9 | find_package_handle_standard_args(LLVMRanLib 10 | DEFAULT_MSG 11 | LLVMRANLIB_EXECUTABLE) 12 | 13 | SET_PACKAGE_PROPERTIES(LLVMRanLib PROPERTIES 14 | DESCRIPTION "generate index for LLVM archive" 15 | ) 16 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/cmake/Modules/FindPFM.cmake: -------------------------------------------------------------------------------- 1 | # If successful, the following variables will be defined: 2 | # PFM_FOUND. 3 | # PFM_LIBRARIES 4 | # PFM_INCLUDE_DIRS 5 | # the following target will be defined: 6 | # PFM::libpfm 7 | 8 | include(FeatureSummary) 9 | include(FindPackageHandleStandardArgs) 10 | 11 | set_package_properties(PFM PROPERTIES 12 | URL http://perfmon2.sourceforge.net/ 13 | DESCRIPTION "A helper library to develop monitoring tools" 14 | PURPOSE "Used to program specific performance monitoring events") 15 | 16 | find_library(PFM_LIBRARY NAMES pfm) 17 | find_path(PFM_INCLUDE_DIR NAMES perfmon/pfmlib.h) 18 | 19 | find_package_handle_standard_args(PFM REQUIRED_VARS PFM_LIBRARY PFM_INCLUDE_DIR) 20 | 21 | if (PFM_FOUND AND NOT TARGET PFM::libpfm) 22 | add_library(PFM::libpfm UNKNOWN IMPORTED) 23 | set_target_properties(PFM::libpfm PROPERTIES 24 | IMPORTED_LOCATION "${PFM_LIBRARY}" 25 | INTERFACE_INCLUDE_DIRECTORIES "${PFM_INCLUDE_DIR}") 26 | endif() 27 | 28 | mark_as_advanced(PFM_LIBRARY PFM_INCLUDE_DIR) 29 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/cmake/benchmark.pc.in: -------------------------------------------------------------------------------- 1 | prefix=@CMAKE_INSTALL_PREFIX@ 2 | exec_prefix=${prefix} 3 | libdir=@CMAKE_INSTALL_FULL_LIBDIR@ 4 | includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@ 5 | 6 | Name: @PROJECT_NAME@ 7 | Description: Google microbenchmark framework 8 | Version: @VERSION@ 9 | 10 | Libs: -L${libdir} -lbenchmark 11 | Libs.private: -lpthread @BENCHMARK_PRIVATE_LINK_LIBRARIES@ 12 | Cflags: -I${includedir} 13 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/cmake/benchmark_main.pc.in: -------------------------------------------------------------------------------- 1 | libdir=@CMAKE_INSTALL_FULL_LIBDIR@ 2 | 3 | Name: @PROJECT_NAME@ 4 | Description: Google microbenchmark framework (with main() function) 5 | Version: @VERSION@ 6 | Requires: benchmark 7 | Libs: -L${libdir} -lbenchmark_main 8 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/cmake/gnu_posix_regex.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int main() { 4 | std::string str = "test0159"; 5 | regex_t re; 6 | int ec = regcomp(&re, "^[a-z]+[0-9]+$", REG_EXTENDED | REG_NOSUB); 7 | if (ec != 0) { 8 | return ec; 9 | } 10 | return regexec(&re, str.c_str(), 0, nullptr, 0) ? -1 : 0; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/cmake/llvm-toolchain.cmake: -------------------------------------------------------------------------------- 1 | find_package(LLVMAr REQUIRED) 2 | set(CMAKE_AR "${LLVMAR_EXECUTABLE}" CACHE FILEPATH "" FORCE) 3 | 4 | find_package(LLVMNm REQUIRED) 5 | set(CMAKE_NM "${LLVMNM_EXECUTABLE}" CACHE FILEPATH "" FORCE) 6 | 7 | find_package(LLVMRanLib REQUIRED) 8 | set(CMAKE_RANLIB "${LLVMRANLIB_EXECUTABLE}" CACHE FILEPATH "" FORCE) 9 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/cmake/posix_regex.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int main() { 4 | std::string str = "test0159"; 5 | regex_t re; 6 | int ec = regcomp(&re, "^[a-z]+[0-9]+$", REG_EXTENDED | REG_NOSUB); 7 | if (ec != 0) { 8 | return ec; 9 | } 10 | int ret = regexec(&re, str.c_str(), 0, nullptr, 0) ? -1 : 0; 11 | regfree(&re); 12 | return ret; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/cmake/pthread_affinity.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int main() { 3 | cpu_set_t set; 4 | CPU_ZERO(&set); 5 | for (int i = 0; i < CPU_SETSIZE; ++i) { 6 | CPU_SET(i, &set); 7 | CPU_CLR(i, &set); 8 | } 9 | pthread_t self = pthread_self(); 10 | int ret; 11 | ret = pthread_getaffinity_np(self, sizeof(set), &set); 12 | if (ret != 0) return ret; 13 | ret = pthread_setaffinity_np(self, sizeof(set), &set); 14 | if (ret != 0) return ret; 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/cmake/split_list.cmake: -------------------------------------------------------------------------------- 1 | macro(split_list listname) 2 | string(REPLACE ";" " " ${listname} "${${listname}}") 3 | endmacro() 4 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/cmake/std_regex.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int main() { 4 | const std::string str = "test0159"; 5 | std::regex re; 6 | re = std::regex("^[a-z]+[0-9]+$", 7 | std::regex_constants::extended | std::regex_constants::nosubs); 8 | return std::regex_search(str, re) ? 0 : -1; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/cmake/steady_clock.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | typedef std::chrono::steady_clock Clock; 5 | Clock::time_point tp = Clock::now(); 6 | ((void)tp); 7 | } 8 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/cmake/thread_safety_attributes.cpp: -------------------------------------------------------------------------------- 1 | #define HAVE_THREAD_SAFETY_ATTRIBUTES 2 | #include "../src/mutex.h" 3 | 4 | int main() {} 5 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/src/arraysize.h: -------------------------------------------------------------------------------- 1 | #ifndef BENCHMARK_ARRAYSIZE_H_ 2 | #define BENCHMARK_ARRAYSIZE_H_ 3 | 4 | #include "internal_macros.h" 5 | 6 | namespace benchmark { 7 | namespace internal { 8 | // The arraysize(arr) macro returns the # of elements in an array arr. 9 | // The expression is a compile-time constant, and therefore can be 10 | // used in defining new arrays, for example. If you use arraysize on 11 | // a pointer by mistake, you will get a compile-time error. 12 | // 13 | 14 | // This template function declaration is used in defining arraysize. 15 | // Note that the function doesn't need an implementation, as we only 16 | // use its type. 17 | template 18 | char (&ArraySizeHelper(T (&array)[N]))[N]; 19 | 20 | // That gcc wants both of these prototypes seems mysterious. VC, for 21 | // its part, can't decide which to use (another mystery). Matching of 22 | // template overloads: the final frontier. 23 | #ifndef COMPILER_MSVC 24 | template 25 | char (&ArraySizeHelper(const T (&array)[N]))[N]; 26 | #endif 27 | 28 | #define arraysize(array) (sizeof(::benchmark::internal::ArraySizeHelper(array))) 29 | 30 | } // end namespace internal 31 | } // end namespace benchmark 32 | 33 | #endif // BENCHMARK_ARRAYSIZE_H_ 34 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/src/benchmark_main.cc: -------------------------------------------------------------------------------- 1 | // Copyright 2018 Google Inc. All rights reserved. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | #include "benchmark/benchmark.h" 16 | 17 | BENCHMARK_EXPORT int main(int, char**); 18 | BENCHMARK_MAIN(); 19 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/src/check.cc: -------------------------------------------------------------------------------- 1 | #include "check.h" 2 | 3 | namespace benchmark { 4 | namespace internal { 5 | 6 | static AbortHandlerT* handler = &std::abort; 7 | 8 | BENCHMARK_EXPORT AbortHandlerT*& GetAbortHandler() { return handler; } 9 | 10 | } // namespace internal 11 | } // namespace benchmark 12 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/src/colorprint.h: -------------------------------------------------------------------------------- 1 | #ifndef BENCHMARK_COLORPRINT_H_ 2 | #define BENCHMARK_COLORPRINT_H_ 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | namespace benchmark { 9 | enum LogColor { 10 | COLOR_DEFAULT, 11 | COLOR_RED, 12 | COLOR_GREEN, 13 | COLOR_YELLOW, 14 | COLOR_BLUE, 15 | COLOR_MAGENTA, 16 | COLOR_CYAN, 17 | COLOR_WHITE 18 | }; 19 | 20 | std::string FormatString(const char* msg, va_list args); 21 | std::string FormatString(const char* msg, ...); 22 | 23 | void ColorPrintf(std::ostream& out, LogColor color, const char* fmt, 24 | va_list args); 25 | void ColorPrintf(std::ostream& out, LogColor color, const char* fmt, ...); 26 | 27 | // Returns true if stdout appears to be a terminal that supports colored 28 | // output, false otherwise. 29 | bool IsColorTerminal(); 30 | 31 | } // end namespace benchmark 32 | 33 | #endif // BENCHMARK_COLORPRINT_H_ 34 | -------------------------------------------------------------------------------- /vendor/core/vendor/googlebenchmark/src/counter.h: -------------------------------------------------------------------------------- 1 | // Copyright 2015 Google Inc. All rights reserved. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | #ifndef BENCHMARK_COUNTER_H_ 16 | #define BENCHMARK_COUNTER_H_ 17 | 18 | #include "benchmark/benchmark.h" 19 | 20 | namespace benchmark { 21 | 22 | // these counter-related functions are hidden to reduce API surface. 23 | namespace internal { 24 | void Finish(UserCounters* l, IterationCount iterations, double time, 25 | double num_threads); 26 | void Increment(UserCounters* l, UserCounters const& r); 27 | bool SameNames(UserCounters const& l, UserCounters const& r); 28 | } // end namespace internal 29 | 30 | } // end namespace benchmark 31 | 32 | #endif // BENCHMARK_COUNTER_H_ 33 | -------------------------------------------------------------------------------- /vendor/core/vendor/googletest/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Note: CMake support is community-based. The maintainers do not use CMake 2 | # internally. 3 | 4 | cmake_minimum_required(VERSION 3.13) 5 | 6 | project(googletest-distribution) 7 | set(GOOGLETEST_VERSION 1.14.0) 8 | 9 | if(NOT CYGWIN AND NOT MSYS AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL QNX) 10 | set(CMAKE_CXX_EXTENSIONS OFF) 11 | endif() 12 | 13 | enable_testing() 14 | 15 | include(CMakeDependentOption) 16 | include(GNUInstallDirs) 17 | 18 | # Note that googlemock target already builds googletest. 19 | option(BUILD_GMOCK "Builds the googlemock subproject" ON) 20 | option(INSTALL_GTEST "Enable installation of googletest. (Projects embedding googletest may want to turn this OFF.)" ON) 21 | option(GTEST_HAS_ABSL "Use Abseil and RE2. Requires Abseil and RE2 to be separately added to the build." OFF) 22 | 23 | if(GTEST_HAS_ABSL) 24 | if(NOT TARGET absl::base) 25 | find_package(absl REQUIRED) 26 | endif() 27 | if(NOT TARGET re2::re2) 28 | find_package(re2 REQUIRED) 29 | endif() 30 | endif() 31 | 32 | if(BUILD_GMOCK) 33 | add_subdirectory( googlemock ) 34 | else() 35 | add_subdirectory( googletest ) 36 | endif() 37 | -------------------------------------------------------------------------------- /vendor/core/vendor/googletest/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright 2008, Google Inc. 2 | All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without 5 | modification, are permitted provided that the following conditions are 6 | met: 7 | 8 | * Redistributions of source code must retain the above copyright 9 | notice, this list of conditions and the following disclaimer. 10 | * Redistributions in binary form must reproduce the above 11 | copyright notice, this list of conditions and the following disclaimer 12 | in the documentation and/or other materials provided with the 13 | distribution. 14 | * Neither the name of Google Inc. nor the names of its 15 | contributors may be used to endorse or promote products derived from 16 | this software without specific prior written permission. 17 | 18 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | -------------------------------------------------------------------------------- /vendor/core/vendor/googletest/googlemock/cmake/gmock.pc.in: -------------------------------------------------------------------------------- 1 | libdir=@CMAKE_INSTALL_FULL_LIBDIR@ 2 | includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@ 3 | 4 | Name: gmock 5 | Description: GoogleMock (without main() function) 6 | Version: @PROJECT_VERSION@ 7 | URL: https://github.com/google/googletest 8 | Requires: gtest = @PROJECT_VERSION@ 9 | Libs: -L${libdir} -lgmock @CMAKE_THREAD_LIBS_INIT@ 10 | Cflags: -I${includedir} @GTEST_HAS_PTHREAD_MACRO@ 11 | -------------------------------------------------------------------------------- /vendor/core/vendor/googletest/googlemock/cmake/gmock_main.pc.in: -------------------------------------------------------------------------------- 1 | libdir=@CMAKE_INSTALL_FULL_LIBDIR@ 2 | includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@ 3 | 4 | Name: gmock_main 5 | Description: GoogleMock (with main() function) 6 | Version: @PROJECT_VERSION@ 7 | URL: https://github.com/google/googletest 8 | Requires: gmock = @PROJECT_VERSION@ 9 | Libs: -L${libdir} -lgmock_main @CMAKE_THREAD_LIBS_INIT@ 10 | Cflags: -I${includedir} @GTEST_HAS_PTHREAD_MACRO@ 11 | -------------------------------------------------------------------------------- /vendor/core/vendor/googletest/googlemock/include/gmock/internal/custom/README.md: -------------------------------------------------------------------------------- 1 | # Customization Points 2 | 3 | The custom directory is an injection point for custom user configurations. 4 | 5 | ## Header `gmock-port.h` 6 | 7 | The following macros can be defined: 8 | 9 | ### Flag related macros: 10 | 11 | * `GMOCK_DECLARE_bool_(name)` 12 | * `GMOCK_DECLARE_int32_(name)` 13 | * `GMOCK_DECLARE_string_(name)` 14 | * `GMOCK_DEFINE_bool_(name, default_val, doc)` 15 | * `GMOCK_DEFINE_int32_(name, default_val, doc)` 16 | * `GMOCK_DEFINE_string_(name, default_val, doc)` 17 | * `GMOCK_FLAG_GET(flag_name)` 18 | * `GMOCK_FLAG_SET(flag_name, value)` 19 | -------------------------------------------------------------------------------- /vendor/core/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h: -------------------------------------------------------------------------------- 1 | // IWYU pragma: private, include "gmock/gmock.h" 2 | // IWYU pragma: friend gmock/.* 3 | 4 | #ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_ 5 | #define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_ 6 | 7 | #endif // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_ 8 | -------------------------------------------------------------------------------- /vendor/core/vendor/googletest/googletest/cmake/Config.cmake.in: -------------------------------------------------------------------------------- 1 | @PACKAGE_INIT@ 2 | include(CMakeFindDependencyMacro) 3 | if (@GTEST_HAS_PTHREAD@) 4 | set(THREADS_PREFER_PTHREAD_FLAG @THREADS_PREFER_PTHREAD_FLAG@) 5 | find_dependency(Threads) 6 | endif() 7 | if (@GTEST_HAS_ABSL@) 8 | find_dependency(absl) 9 | find_dependency(re2) 10 | endif() 11 | 12 | include("${CMAKE_CURRENT_LIST_DIR}/@targets_export_name@.cmake") 13 | check_required_components("@project_name@") 14 | -------------------------------------------------------------------------------- /vendor/core/vendor/googletest/googletest/cmake/gtest.pc.in: -------------------------------------------------------------------------------- 1 | libdir=@CMAKE_INSTALL_FULL_LIBDIR@ 2 | includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@ 3 | 4 | Name: gtest 5 | Description: GoogleTest (without main() function) 6 | Version: @PROJECT_VERSION@ 7 | URL: https://github.com/google/googletest 8 | Libs: -L${libdir} -lgtest @CMAKE_THREAD_LIBS_INIT@ 9 | Cflags: -I${includedir} @GTEST_HAS_PTHREAD_MACRO@ 10 | -------------------------------------------------------------------------------- /vendor/core/vendor/googletest/googletest/cmake/gtest_main.pc.in: -------------------------------------------------------------------------------- 1 | libdir=@CMAKE_INSTALL_FULL_LIBDIR@ 2 | includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@ 3 | 4 | Name: gtest_main 5 | Description: GoogleTest (with main() function) 6 | Version: @PROJECT_VERSION@ 7 | URL: https://github.com/google/googletest 8 | Requires: gtest = @PROJECT_VERSION@ 9 | Libs: -L${libdir} -lgtest_main @CMAKE_THREAD_LIBS_INIT@ 10 | Cflags: -I${includedir} @GTEST_HAS_PTHREAD_MACRO@ 11 | -------------------------------------------------------------------------------- /vendor/core/vendor/googletest/googletest/cmake/libgtest.la.in: -------------------------------------------------------------------------------- 1 | # libgtest.la - a libtool library file 2 | # Generated by libtool (GNU libtool) 2.4.6 3 | 4 | # Please DO NOT delete this file! 5 | # It is necessary for linking the library. 6 | 7 | # Names of this library. 8 | library_names='libgtest.so' 9 | 10 | # Is this an already installed library? 11 | installed=yes 12 | 13 | # Should we warn about portability when linking against -modules? 14 | shouldnotlink=no 15 | 16 | # Files to dlopen/dlpreopen 17 | dlopen='' 18 | dlpreopen='' 19 | 20 | # Directory that this library needs to be installed in: 21 | libdir='@CMAKE_INSTALL_FULL_LIBDIR@' 22 | -------------------------------------------------------------------------------- /vendor/core/vendor/googletest/googletest/include/gtest/internal/custom/README.md: -------------------------------------------------------------------------------- 1 | # Customization Points 2 | 3 | The custom directory is an injection point for custom user configurations. 4 | 5 | ## Header `gtest.h` 6 | 7 | ### The following macros can be defined: 8 | 9 | * `GTEST_OS_STACK_TRACE_GETTER_` - The name of an implementation of 10 | `OsStackTraceGetterInterface`. 11 | * `GTEST_CUSTOM_TEMPDIR_FUNCTION_` - An override for `testing::TempDir()`. See 12 | `testing::TempDir` for semantics and signature. 13 | 14 | ## Header `gtest-port.h` 15 | 16 | The following macros can be defined: 17 | 18 | ### Logging: 19 | 20 | * `GTEST_LOG_(severity)` 21 | * `GTEST_CHECK_(condition)` 22 | * Functions `LogToStderr()` and `FlushInfoLog()` have to be provided too. 23 | 24 | ### Threading: 25 | 26 | * `GTEST_HAS_NOTIFICATION_` - Enabled if Notification is already provided. 27 | * `GTEST_HAS_MUTEX_AND_THREAD_LOCAL_` - Enabled if `Mutex` and `ThreadLocal` 28 | are already provided. Must also provide `GTEST_DECLARE_STATIC_MUTEX_(mutex)` 29 | and `GTEST_DEFINE_STATIC_MUTEX_(mutex)` 30 | * `GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)` 31 | * `GTEST_LOCK_EXCLUDED_(locks)` 32 | 33 | ### Underlying library support features 34 | 35 | * `GTEST_HAS_CXXABI_H_` 36 | 37 | ### Exporting API symbols: 38 | 39 | * `GTEST_API_` - Specifier for exported symbols. 40 | 41 | ## Header `gtest-printers.h` 42 | 43 | * See documentation at `gtest/gtest-printers.h` for details on how to define a 44 | custom printer. 45 | -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-2019-09/hyper-schema.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2019-09/hyper-schema", 3 | "$id": "https://json-schema.org/draft/2019-09/hyper-schema", 4 | "$vocabulary": { 5 | "https://json-schema.org/draft/2019-09/vocab/core": true, 6 | "https://json-schema.org/draft/2019-09/vocab/applicator": true, 7 | "https://json-schema.org/draft/2019-09/vocab/validation": true, 8 | "https://json-schema.org/draft/2019-09/vocab/meta-data": true, 9 | "https://json-schema.org/draft/2019-09/vocab/format": false, 10 | "https://json-schema.org/draft/2019-09/vocab/content": true, 11 | "https://json-schema.org/draft/2019-09/vocab/hyper-schema": true 12 | }, 13 | "$recursiveAnchor": true, 14 | 15 | "title": "JSON Hyper-Schema", 16 | "allOf": [ 17 | {"$ref": "https://json-schema.org/draft/2019-09/schema"}, 18 | {"$ref": "https://json-schema.org/draft/2019-09/meta/hyper-schema"} 19 | ], 20 | "links": [ 21 | { 22 | "rel": "self", 23 | "href": "{+%24id}" 24 | } 25 | ] 26 | } 27 | -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-2019-09/meta/content.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2019-09/schema", 3 | "$id": "https://json-schema.org/draft/2019-09/meta/content", 4 | "$vocabulary": { 5 | "https://json-schema.org/draft/2019-09/vocab/content": true 6 | }, 7 | "$recursiveAnchor": true, 8 | 9 | "title": "Content vocabulary meta-schema", 10 | 11 | "type": ["object", "boolean"], 12 | "properties": { 13 | "contentMediaType": { "type": "string" }, 14 | "contentEncoding": { "type": "string" }, 15 | "contentSchema": { "$recursiveRef": "#" } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-2019-09/meta/format.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2019-09/schema", 3 | "$id": "https://json-schema.org/draft/2019-09/meta/format", 4 | "$vocabulary": { 5 | "https://json-schema.org/draft/2019-09/vocab/format": true 6 | }, 7 | "$recursiveAnchor": true, 8 | 9 | "title": "Format vocabulary meta-schema", 10 | "type": ["object", "boolean"], 11 | "properties": { 12 | "format": { "type": "string" } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-2019-09/meta/hyper-schema.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2019-09/hyper-schema", 3 | "$id": "https://json-schema.org/draft/2019-09/meta/hyper-schema", 4 | "$vocabulary": { 5 | "https://json-schema.org/draft/2019-09/vocab/hyper-schema": true 6 | }, 7 | "$recursiveAnchor": true, 8 | 9 | "title": "JSON Hyper-Schema Vocabulary Schema", 10 | "type": ["object", "boolean"], 11 | "properties": { 12 | "base": { 13 | "type": "string", 14 | "format": "uri-template" 15 | }, 16 | "links": { 17 | "type": "array", 18 | "items": { 19 | "$ref": "https://json-schema.org/draft/2019-09/links" 20 | } 21 | } 22 | }, 23 | "links": [ 24 | { 25 | "rel": "self", 26 | "href": "{+%24id}" 27 | } 28 | ] 29 | } 30 | -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-2019-09/meta/meta-data.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2019-09/schema", 3 | "$id": "https://json-schema.org/draft/2019-09/meta/meta-data", 4 | "$vocabulary": { 5 | "https://json-schema.org/draft/2019-09/vocab/meta-data": true 6 | }, 7 | "$recursiveAnchor": true, 8 | 9 | "title": "Meta-data vocabulary meta-schema", 10 | 11 | "type": ["object", "boolean"], 12 | "properties": { 13 | "title": { 14 | "type": "string" 15 | }, 16 | "description": { 17 | "type": "string" 18 | }, 19 | "default": true, 20 | "deprecated": { 21 | "type": "boolean", 22 | "default": false 23 | }, 24 | "readOnly": { 25 | "type": "boolean", 26 | "default": false 27 | }, 28 | "writeOnly": { 29 | "type": "boolean", 30 | "default": false 31 | }, 32 | "examples": { 33 | "type": "array", 34 | "items": true 35 | } 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-2020-12/hyper-schema.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2020-12/hyper-schema", 3 | "$id": "https://json-schema.org/draft/2020-12/hyper-schema", 4 | "$vocabulary": { 5 | "https://json-schema.org/draft/2020-12/vocab/core": true, 6 | "https://json-schema.org/draft/2020-12/vocab/applicator": true, 7 | "https://json-schema.org/draft/2020-12/vocab/unevaluated": true, 8 | "https://json-schema.org/draft/2020-12/vocab/validation": true, 9 | "https://json-schema.org/draft/2020-12/vocab/meta-data": true, 10 | "https://json-schema.org/draft/2020-12/vocab/format-annotation": true, 11 | "https://json-schema.org/draft/2020-12/vocab/content": true, 12 | "https://json-schema.org/draft/2019-09/vocab/hyper-schema": true 13 | }, 14 | "$dynamicAnchor": "meta", 15 | 16 | "title": "JSON Hyper-Schema", 17 | "allOf": [ 18 | { "$ref": "https://json-schema.org/draft/2020-12/schema" }, 19 | { "$ref": "https://json-schema.org/draft/2020-12/meta/hyper-schema" } 20 | ], 21 | "links": [ 22 | { 23 | "rel": "self", 24 | "href": "{+%24id}" 25 | } 26 | ] 27 | } 28 | -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-2020-12/meta/content.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2020-12/schema", 3 | "$id": "https://json-schema.org/draft/2020-12/meta/content", 4 | "$vocabulary": { 5 | "https://json-schema.org/draft/2020-12/vocab/content": true 6 | }, 7 | "$dynamicAnchor": "meta", 8 | 9 | "title": "Content vocabulary meta-schema", 10 | 11 | "type": ["object", "boolean"], 12 | "properties": { 13 | "contentEncoding": { "type": "string" }, 14 | "contentMediaType": { "type": "string" }, 15 | "contentSchema": { "$dynamicRef": "#meta" } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-2020-12/meta/format-annotation.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2020-12/schema", 3 | "$id": "https://json-schema.org/draft/2020-12/meta/format-annotation", 4 | "$vocabulary": { 5 | "https://json-schema.org/draft/2020-12/vocab/format-annotation": true 6 | }, 7 | "$dynamicAnchor": "meta", 8 | 9 | "title": "Format vocabulary meta-schema for annotation results", 10 | "type": ["object", "boolean"], 11 | "properties": { 12 | "format": { "type": "string" } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-2020-12/meta/format-assertion.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2020-12/schema", 3 | "$id": "https://json-schema.org/draft/2020-12/meta/format-assertion", 4 | "$vocabulary": { 5 | "https://json-schema.org/draft/2020-12/vocab/format-assertion": true 6 | }, 7 | "$dynamicAnchor": "meta", 8 | 9 | "title": "Format vocabulary meta-schema for assertion results", 10 | "type": ["object", "boolean"], 11 | "properties": { 12 | "format": { "type": "string" } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-2020-12/meta/hyper-schema.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2020-12/hyper-schema", 3 | "$id": "https://json-schema.org/draft/2020-12/meta/hyper-schema", 4 | "$vocabulary": { 5 | "https://json-schema.org/draft/2019-09/vocab/hyper-schema": true 6 | }, 7 | "$dynamicAnchor": "meta", 8 | 9 | "title": "JSON Hyper-Schema Vocabulary Schema", 10 | "type": ["object", "boolean"], 11 | "properties": { 12 | "base": { 13 | "type": "string", 14 | "format": "uri-template" 15 | }, 16 | "links": { 17 | "type": "array", 18 | "items": { 19 | "$ref": "https://json-schema.org/draft/2020-12/links" 20 | } 21 | } 22 | }, 23 | "links": [ 24 | { 25 | "rel": "self", 26 | "href": "{+%24id}" 27 | } 28 | ] 29 | } 30 | -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-2020-12/meta/meta-data.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2020-12/schema", 3 | "$id": "https://json-schema.org/draft/2020-12/meta/meta-data", 4 | "$vocabulary": { 5 | "https://json-schema.org/draft/2020-12/vocab/meta-data": true 6 | }, 7 | "$dynamicAnchor": "meta", 8 | 9 | "title": "Meta-data vocabulary meta-schema", 10 | 11 | "type": ["object", "boolean"], 12 | "properties": { 13 | "title": { 14 | "type": "string" 15 | }, 16 | "description": { 17 | "type": "string" 18 | }, 19 | "default": true, 20 | "deprecated": { 21 | "type": "boolean", 22 | "default": false 23 | }, 24 | "readOnly": { 25 | "type": "boolean", 26 | "default": false 27 | }, 28 | "writeOnly": { 29 | "type": "boolean", 30 | "default": false 31 | }, 32 | "examples": { 33 | "type": "array", 34 | "items": true 35 | } 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-2020-12/meta/unevaluated.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2020-12/schema", 3 | "$id": "https://json-schema.org/draft/2020-12/meta/unevaluated", 4 | "$vocabulary": { 5 | "https://json-schema.org/draft/2020-12/vocab/unevaluated": true 6 | }, 7 | "$dynamicAnchor": "meta", 8 | 9 | "title": "Unevaluated applicator vocabulary meta-schema", 10 | "type": ["object", "boolean"], 11 | "properties": { 12 | "unevaluatedItems": { "$dynamicRef": "#meta" }, 13 | "unevaluatedProperties": { "$dynamicRef": "#meta" } 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-draft0/hyper-schema.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema" : "http://json-schema.org/draft-00/hyper-schema#", 3 | "id" : "http://json-schema.org/draft-00/hyper-schema#", 4 | 5 | "properties" : { 6 | "links" : { 7 | "type" : "array", 8 | "items" : {"$ref" : "http://json-schema.org/draft-00/links#"}, 9 | "optional" : true 10 | }, 11 | 12 | "fragmentResolution" : { 13 | "type" : "string", 14 | "optional" : true, 15 | "default" : "dot-delimited" 16 | }, 17 | 18 | "root" : { 19 | "type" : "boolean", 20 | "optional" : true, 21 | "default" : false 22 | }, 23 | 24 | "readonly" : { 25 | "type" : "boolean", 26 | "optional" : true, 27 | "default" : false 28 | }, 29 | 30 | "pathStart" : { 31 | "type" : "string", 32 | "optional" : true, 33 | "format" : "uri" 34 | }, 35 | 36 | "mediaType" : { 37 | "type" : "string", 38 | "optional" : true, 39 | "format" : "media-type" 40 | }, 41 | 42 | "alternate" : { 43 | "type" : "array", 44 | "items" : {"$ref" : "#"}, 45 | "optional" : true 46 | } 47 | }, 48 | 49 | "links" : [ 50 | { 51 | "href" : "{$ref}", 52 | "rel" : "full" 53 | }, 54 | 55 | { 56 | "href" : "{$schema}", 57 | "rel" : "describedby" 58 | }, 59 | 60 | { 61 | "href" : "{id}", 62 | "rel" : "self" 63 | } 64 | ], 65 | 66 | "fragmentResolution" : "dot-delimited", 67 | "extends" : {"$ref" : "http://json-schema.org/draft-00/schema#"} 68 | } -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-draft0/json-ref.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema" : "http://json-schema.org/draft-00/hyper-schema#", 3 | "id" : "http://json-schema.org/draft-00/json-ref#", 4 | 5 | "items" : {"$ref" : "#"}, 6 | "additionalProperties" : {"$ref" : "#"}, 7 | 8 | "links" : [ 9 | { 10 | "href" : "{$ref}", 11 | "rel" : "full" 12 | }, 13 | 14 | { 15 | "href" : "{$schema}", 16 | "rel" : "describedby" 17 | }, 18 | 19 | { 20 | "href" : "{id}", 21 | "rel" : "self" 22 | } 23 | ], 24 | 25 | "fragmentResolution" : "dot-delimited" 26 | } -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-draft0/links.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema" : "http://json-schema.org/draft-00/hyper-schema#", 3 | "id" : "http://json-schema.org/draft-00/links#", 4 | "type" : "object", 5 | 6 | "properties" : { 7 | "href" : { 8 | "type" : "string" 9 | }, 10 | 11 | "rel" : { 12 | "type" : "string" 13 | }, 14 | 15 | "method" : { 16 | "type" : "string", 17 | "default" : "GET", 18 | "optional" : true 19 | }, 20 | 21 | "enctype" : { 22 | "type" : "string", 23 | "requires" : "method", 24 | "optional" : true 25 | }, 26 | 27 | "properties" : { 28 | "type" : "object", 29 | "additionalProperties" : {"$ref" : "http://json-schema.org/draft-00/hyper-schema#"}, 30 | "optional" : true 31 | } 32 | } 33 | } -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-draft1/hyper-schema.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema" : "http://json-schema.org/draft-01/hyper-schema#", 3 | "id" : "http://json-schema.org/draft-01/hyper-schema#", 4 | 5 | "properties" : { 6 | "links" : { 7 | "type" : "array", 8 | "items" : {"$ref" : "http://json-schema.org/draft-01/links#"}, 9 | "optional" : true 10 | }, 11 | 12 | "fragmentResolution" : { 13 | "type" : "string", 14 | "optional" : true, 15 | "default" : "dot-delimited" 16 | }, 17 | 18 | "root" : { 19 | "type" : "boolean", 20 | "optional" : true, 21 | "default" : false 22 | }, 23 | 24 | "readonly" : { 25 | "type" : "boolean", 26 | "optional" : true, 27 | "default" : false 28 | }, 29 | 30 | "pathStart" : { 31 | "type" : "string", 32 | "optional" : true, 33 | "format" : "uri" 34 | }, 35 | 36 | "mediaType" : { 37 | "type" : "string", 38 | "optional" : true, 39 | "format" : "media-type" 40 | }, 41 | 42 | "alternate" : { 43 | "type" : "array", 44 | "items" : {"$ref" : "#"}, 45 | "optional" : true 46 | } 47 | }, 48 | 49 | "links" : [ 50 | { 51 | "href" : "{$ref}", 52 | "rel" : "full" 53 | }, 54 | 55 | { 56 | "href" : "{$schema}", 57 | "rel" : "describedby" 58 | }, 59 | 60 | { 61 | "href" : "{id}", 62 | "rel" : "self" 63 | } 64 | ], 65 | 66 | "fragmentResolution" : "dot-delimited", 67 | "extends" : {"$ref" : "http://json-schema.org/draft-01/schema#"} 68 | } -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-draft1/json-ref.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema" : "http://json-schema.org/draft-01/hyper-schema#", 3 | "id" : "http://json-schema.org/draft-01/json-ref#", 4 | 5 | "items" : {"$ref" : "#"}, 6 | "additionalProperties" : {"$ref" : "#"}, 7 | 8 | "links" : [ 9 | { 10 | "href" : "{$ref}", 11 | "rel" : "full" 12 | }, 13 | 14 | { 15 | "href" : "{$schema}", 16 | "rel" : "describedby" 17 | }, 18 | 19 | { 20 | "href" : "{id}", 21 | "rel" : "self" 22 | } 23 | ], 24 | 25 | "fragmentResolution" : "dot-delimited" 26 | } -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-draft1/links.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema" : "http://json-schema.org/draft-01/hyper-schema#", 3 | "id" : "http://json-schema.org/draft-01/links#", 4 | "type" : "object", 5 | 6 | "properties" : { 7 | "href" : { 8 | "type" : "string" 9 | }, 10 | 11 | "rel" : { 12 | "type" : "string" 13 | }, 14 | 15 | "method" : { 16 | "type" : "string", 17 | "default" : "GET", 18 | "optional" : true 19 | }, 20 | 21 | "enctype" : { 22 | "type" : "string", 23 | "requires" : "method", 24 | "optional" : true 25 | }, 26 | 27 | "properties" : { 28 | "type" : "object", 29 | "additionalProperties" : {"$ref" : "http://json-schema.org/draft-01/hyper-schema#"}, 30 | "optional" : true 31 | } 32 | } 33 | } -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-draft2/hyper-schema.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema" : "http://json-schema.org/draft-02/hyper-schema#", 3 | "id" : "http://json-schema.org/draft-02/hyper-schema#", 4 | 5 | "properties" : { 6 | "links" : { 7 | "type" : "array", 8 | "items" : {"$ref" : "http://json-schema.org/draft-02/links#"}, 9 | "optional" : true 10 | }, 11 | 12 | "fragmentResolution" : { 13 | "type" : "string", 14 | "optional" : true, 15 | "default" : "slash-delimited" 16 | }, 17 | 18 | "root" : { 19 | "type" : "boolean", 20 | "optional" : true, 21 | "default" : false 22 | }, 23 | 24 | "readonly" : { 25 | "type" : "boolean", 26 | "optional" : true, 27 | "default" : false 28 | }, 29 | 30 | "pathStart" : { 31 | "type" : "string", 32 | "optional" : true, 33 | "format" : "uri" 34 | }, 35 | 36 | "mediaType" : { 37 | "type" : "string", 38 | "optional" : true, 39 | "format" : "media-type" 40 | }, 41 | 42 | "alternate" : { 43 | "type" : "array", 44 | "items" : {"$ref" : "#"}, 45 | "optional" : true 46 | } 47 | }, 48 | 49 | "links" : [ 50 | { 51 | "href" : "{$ref}", 52 | "rel" : "full" 53 | }, 54 | 55 | { 56 | "href" : "{$schema}", 57 | "rel" : "describedby" 58 | }, 59 | 60 | { 61 | "href" : "{id}", 62 | "rel" : "self" 63 | } 64 | ], 65 | 66 | "fragmentResolution" : "slash-delimited", 67 | "extends" : {"$ref" : "http://json-schema.org/draft-02/schema#"} 68 | } -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-draft2/json-ref.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema" : "http://json-schema.org/draft-02/hyper-schema#", 3 | "id" : "http://json-schema.org/draft-02/json-ref#", 4 | 5 | "items" : {"$ref" : "#"}, 6 | "additionalProperties" : {"$ref" : "#"}, 7 | 8 | "links" : [ 9 | { 10 | "href" : "{$ref}", 11 | "rel" : "full" 12 | }, 13 | 14 | { 15 | "href" : "{$schema}", 16 | "rel" : "describedby" 17 | }, 18 | 19 | { 20 | "href" : "{id}", 21 | "rel" : "self" 22 | } 23 | ], 24 | 25 | "fragmentResolution" : "dot-delimited" 26 | } -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-draft2/links.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema" : "http://json-schema.org/draft-02/hyper-schema#", 3 | "id" : "http://json-schema.org/draft-02/links#", 4 | "type" : "object", 5 | 6 | "properties" : { 7 | "href" : { 8 | "type" : "string" 9 | }, 10 | 11 | "rel" : { 12 | "type" : "string" 13 | }, 14 | 15 | "targetSchema" : {"$ref" : "http://json-schema.org/draft-02/hyper-schema#"}, 16 | 17 | "method" : { 18 | "type" : "string", 19 | "default" : "GET", 20 | "optional" : true 21 | }, 22 | 23 | "enctype" : { 24 | "type" : "string", 25 | "requires" : "method", 26 | "optional" : true 27 | }, 28 | 29 | "properties" : { 30 | "type" : "object", 31 | "additionalProperties" : {"$ref" : "http://json-schema.org/draft-02/hyper-schema#"}, 32 | "optional" : true 33 | } 34 | } 35 | } -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-draft3/hyper-schema.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema" : "http://json-schema.org/draft-03/hyper-schema#", 3 | "extends" : {"$ref" : "http://json-schema.org/draft-03/schema#"}, 4 | "id" : "http://json-schema.org/draft-03/hyper-schema#", 5 | 6 | "properties" : { 7 | "links" : { 8 | "type" : "array", 9 | "items" : {"$ref" : "http://json-schema.org/draft-03/links#"} 10 | }, 11 | 12 | "fragmentResolution" : { 13 | "type" : "string", 14 | "default" : "slash-delimited" 15 | }, 16 | 17 | "root" : { 18 | "type" : "boolean", 19 | "default" : false 20 | }, 21 | 22 | "readonly" : { 23 | "type" : "boolean", 24 | "default" : false 25 | }, 26 | 27 | "contentEncoding" : { 28 | "type" : "string" 29 | }, 30 | 31 | "pathStart" : { 32 | "type" : "string", 33 | "format" : "uri" 34 | }, 35 | 36 | "mediaType" : { 37 | "type" : "string", 38 | "format" : "media-type" 39 | } 40 | }, 41 | 42 | "links" : [ 43 | { 44 | "href" : "{id}", 45 | "rel" : "self" 46 | }, 47 | 48 | { 49 | "href" : "{$ref}", 50 | "rel" : "full" 51 | }, 52 | 53 | { 54 | "href" : "{$schema}", 55 | "rel" : "describedby" 56 | } 57 | ], 58 | 59 | "fragmentResolution" : "slash-delimited" 60 | } 61 | -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-draft3/json-ref.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema" : "http://json-schema.org/draft-03/hyper-schema#", 3 | "id" : "http://json-schema.org/draft-03/json-ref#", 4 | 5 | "additionalItems" : {"$ref" : "#"}, 6 | "additionalProperties" : {"$ref" : "#"}, 7 | 8 | "links" : [ 9 | { 10 | "href" : "{id}", 11 | "rel" : "self" 12 | }, 13 | 14 | { 15 | "href" : "{$ref}", 16 | "rel" : "full" 17 | }, 18 | 19 | { 20 | "href" : "{$schema}", 21 | "rel" : "describedby" 22 | } 23 | ], 24 | 25 | "fragmentResolution" : "dot-delimited" 26 | } -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-draft3/links.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema" : "http://json-schema.org/draft-03/hyper-schema#", 3 | "id" : "http://json-schema.org/draft-03/links#", 4 | "type" : "object", 5 | 6 | "properties" : { 7 | "href" : { 8 | "type" : "string", 9 | "required" : true, 10 | "format" : "link-description-object-template" 11 | }, 12 | 13 | "rel" : { 14 | "type" : "string", 15 | "required" : true 16 | }, 17 | 18 | "targetSchema" : {"$ref" : "http://json-schema.org/draft-03/hyper-schema#"}, 19 | 20 | "method" : { 21 | "type" : "string", 22 | "default" : "GET" 23 | }, 24 | 25 | "enctype" : { 26 | "type" : "string", 27 | "requires" : "method" 28 | }, 29 | 30 | "properties" : { 31 | "type" : "object", 32 | "additionalProperties" : {"$ref" : "http://json-schema.org/draft-03/hyper-schema#"} 33 | } 34 | } 35 | } -------------------------------------------------------------------------------- /vendor/core/vendor/jsonschema-draft4/links.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema" : "http://json-schema.org/draft-04/hyper-schema#", 3 | "id" : "http://json-schema.org/draft-04/links#", 4 | "type" : "object", 5 | 6 | "properties" : { 7 | "rel" : { 8 | "type" : "string" 9 | }, 10 | 11 | "href" : { 12 | "type" : "string" 13 | }, 14 | 15 | "template" : { 16 | "type" : "string" 17 | }, 18 | 19 | "targetSchema" : {"$ref" : "http://json-schema.org/draft-04/hyper-schema#"}, 20 | 21 | "method" : { 22 | "type" : "string", 23 | "default" : "GET" 24 | }, 25 | 26 | "enctype" : { 27 | "type" : "string" 28 | }, 29 | 30 | "properties" : { 31 | "type" : "object", 32 | "additionalProperties" : {"$ref" : "http://json-schema.org/draft-04/hyper-schema#"} 33 | } 34 | }, 35 | 36 | "required" : ["rel", "href"], 37 | 38 | "dependencies" : { 39 | "enctype" : ["method"] 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /vendor/core/vendor/yaml.mask: -------------------------------------------------------------------------------- 1 | cmake/ 2 | doc/ 3 | docker/ 4 | examples/ 5 | include/Makefile.am 6 | regression-inputs/ 7 | src/Makefile.am 8 | tests/ 9 | .appveyor.yml 10 | .indent.pro 11 | .makefile 12 | .travis.yml 13 | announcement.msg 14 | bootstrap 15 | Changes 16 | CMakeLists.txt 17 | configure.ac 18 | Makefile.am 19 | ReadMe.md 20 | yaml-0.1.pc.in 21 | yamlConfig.cmake.in 22 | -------------------------------------------------------------------------------- /vendor/core/vendor/yaml/License: -------------------------------------------------------------------------------- 1 | Copyright (c) 2017-2020 Ingy döt Net 2 | Copyright (c) 2006-2016 Kirill Simonov 3 | 4 | Permission is hereby granted, free of charge, to any person obtaining a copy of 5 | this software and associated documentation files (the "Software"), to deal in 6 | the Software without restriction, including without limitation the rights to 7 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 8 | of the Software, and to permit persons to whom the Software is furnished to do 9 | so, subject to the following conditions: 10 | 11 | The above copyright notice and this permission notice shall be included in all 12 | copies or substantial portions of the Software. 13 | 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 17 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 18 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 19 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 20 | SOFTWARE. 21 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite.mask: -------------------------------------------------------------------------------- 1 | bin 2 | output-tests 3 | .editorconfig 4 | CONTRIBUTING.md 5 | output-test-schema.json 6 | package.json 7 | README.md 8 | test-schema.json 9 | tox.ini 10 | tests/latest 11 | tests/draft-next 12 | tests/draft3 13 | remotes/draft-next 14 | remotes/locationIndependentIdentifier.json 15 | remotes/name-defs.json 16 | remotes/ref-and-defs.json 17 | remotes/tree.json 18 | remotes/extendible-dynamic-ref.json 19 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2012 Julian Berman 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining a copy 4 | of this software and associated documentation files (the "Software"), to deal 5 | in the Software without restriction, including without limitation the rights 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 7 | copies of the Software, and to permit persons to whom the Software is 8 | furnished to do so, subject to the following conditions: 9 | 10 | The above copyright notice and this permission notice shall be included in 11 | all copies or substantial portions of the Software. 12 | 13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 19 | THE SOFTWARE. 20 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/baseUriChange/folderInteger.json: -------------------------------------------------------------------------------- 1 | { 2 | "type": "integer" 3 | } 4 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/baseUriChangeFolder/folderInteger.json: -------------------------------------------------------------------------------- 1 | { 2 | "type": "integer" 3 | } 4 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/baseUriChangeFolderInSubschema/folderInteger.json: -------------------------------------------------------------------------------- 1 | { 2 | "type": "integer" 3 | } 4 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/different-id-ref-string.json: -------------------------------------------------------------------------------- 1 | { 2 | "$id": "http://localhost:1234/real-id-ref-string.json", 3 | "$defs": {"bar": {"type": "string"}}, 4 | "$ref": "#/$defs/bar" 5 | } 6 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2019-09/baseUriChange/folderInteger.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2019-09/schema", 3 | "type": "integer" 4 | } 5 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2019-09/baseUriChangeFolder/folderInteger.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2019-09/schema", 3 | "type": "integer" 4 | } 5 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2019-09/baseUriChangeFolderInSubschema/folderInteger.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2019-09/schema", 3 | "type": "integer" 4 | } 5 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2019-09/dependentRequired.json: -------------------------------------------------------------------------------- 1 | { 2 | "$id": "http://localhost:1234/draft2019-09/dependentRequired.json", 3 | "$schema": "https://json-schema.org/draft/2019-09/schema", 4 | "dependentRequired": { 5 | "foo": ["bar"] 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2019-09/detached-ref.json: -------------------------------------------------------------------------------- 1 | { 2 | "$id": "http://localhost:1234/draft2019-09/detached-ref.json", 3 | "$schema": "https://json-schema.org/draft/2019-09/schema", 4 | "$defs": { 5 | "foo": { 6 | "$ref": "#detached" 7 | }, 8 | "detached": { 9 | "$anchor": "detached", 10 | "type": "integer" 11 | } 12 | } 13 | } -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2019-09/extendible-dynamic-ref.json: -------------------------------------------------------------------------------- 1 | { 2 | "description": "extendible array", 3 | "$schema": "https://json-schema.org/draft/2019-09/schema", 4 | "$id": "http://localhost:1234/draft2019-09/extendible-dynamic-ref.json", 5 | "type": "object", 6 | "properties": { 7 | "elements": { 8 | "type": "array", 9 | "items": { 10 | "$dynamicRef": "#elements" 11 | } 12 | } 13 | }, 14 | "required": ["elements"], 15 | "additionalProperties": false, 16 | "$defs": { 17 | "elements": { 18 | "$dynamicAnchor": "elements" 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2019-09/ignore-prefixItems.json: -------------------------------------------------------------------------------- 1 | { 2 | "$id": "http://localhost:1234/draft2019-09/ignore-prefixItems.json", 3 | "$schema": "https://json-schema.org/draft/2019-09/schema", 4 | "prefixItems": [ 5 | {"type": "string"} 6 | ] 7 | } 8 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2019-09/integer.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2019-09/schema", 3 | "type": "integer" 4 | } 5 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2019-09/locationIndependentIdentifier.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2019-09/schema", 3 | "$defs": { 4 | "refToInteger": { 5 | "$ref": "#foo" 6 | }, 7 | "A": { 8 | "$anchor": "foo", 9 | "type": "integer" 10 | } 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2019-09/metaschema-no-validation.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2019-09/schema", 3 | "$id": "http://localhost:1234/draft2019-09/metaschema-no-validation.json", 4 | "$vocabulary": { 5 | "https://json-schema.org/draft/2019-09/vocab/applicator": true, 6 | "https://json-schema.org/draft/2019-09/vocab/core": true 7 | }, 8 | "$recursiveAnchor": true, 9 | "allOf": [ 10 | { "$ref": "https://json-schema.org/draft/2019-09/meta/applicator" }, 11 | { "$ref": "https://json-schema.org/draft/2019-09/meta/core" } 12 | ] 13 | } 14 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2019-09/metaschema-optional-vocabulary.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2019-09/schema", 3 | "$id": "http://localhost:1234/draft2019-09/metaschema-optional-vocabulary.json", 4 | "$vocabulary": { 5 | "https://json-schema.org/draft/2019-09/vocab/validation": true, 6 | "https://json-schema.org/draft/2019-09/vocab/core": true, 7 | "http://localhost:1234/draft/2019-09/vocab/custom": false 8 | }, 9 | "$recursiveAnchor": true, 10 | "allOf": [ 11 | { "$ref": "https://json-schema.org/draft/2019-09/meta/validation" }, 12 | { "$ref": "https://json-schema.org/draft/2019-09/meta/core" } 13 | ] 14 | } 15 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2019-09/name-defs.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2019-09/schema", 3 | "$defs": { 4 | "orNull": { 5 | "anyOf": [ 6 | { 7 | "type": "null" 8 | }, 9 | { 10 | "$ref": "#" 11 | } 12 | ] 13 | } 14 | }, 15 | "type": "string" 16 | } 17 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2019-09/nested/foo-ref-string.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2019-09/schema", 3 | "type": "object", 4 | "properties": { 5 | "foo": {"$ref": "string.json"} 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2019-09/nested/string.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2019-09/schema", 3 | "type": "string" 4 | } 5 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2019-09/ref-and-defs.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2019-09/schema", 3 | "$id": "http://localhost:1234/draft2019-09/ref-and-defs.json", 4 | "$defs": { 5 | "inner": { 6 | "properties": { 7 | "bar": { "type": "string" } 8 | } 9 | } 10 | }, 11 | "$ref": "#/$defs/inner" 12 | } 13 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2019-09/subSchemas.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2019-09/schema", 3 | "$defs": { 4 | "integer": { 5 | "type": "integer" 6 | }, 7 | "refToInteger": { 8 | "$ref": "#/$defs/integer" 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2019-09/tree.json: -------------------------------------------------------------------------------- 1 | { 2 | "description": "tree schema, extensible", 3 | "$schema": "https://json-schema.org/draft/2019-09/schema", 4 | "$id": "http://localhost:1234/draft2019-09/tree.json", 5 | "$dynamicAnchor": "node", 6 | 7 | "type": "object", 8 | "properties": { 9 | "data": true, 10 | "children": { 11 | "type": "array", 12 | "items": { 13 | "$dynamicRef": "#node" 14 | } 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2020-12/baseUriChange/folderInteger.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2020-12/schema", 3 | "type": "integer" 4 | } 5 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2020-12/baseUriChangeFolder/folderInteger.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2020-12/schema", 3 | "type": "integer" 4 | } 5 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2020-12/baseUriChangeFolderInSubschema/folderInteger.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2020-12/schema", 3 | "type": "integer" 4 | } 5 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2020-12/detached-dynamicref.json: -------------------------------------------------------------------------------- 1 | { 2 | "$id": "http://localhost:1234/draft2020-12/detached-dynamicref.json", 3 | "$schema": "https://json-schema.org/draft/2020-12/schema", 4 | "$defs": { 5 | "foo": { 6 | "$dynamicRef": "#detached" 7 | }, 8 | "detached": { 9 | "$dynamicAnchor": "detached", 10 | "type": "integer" 11 | } 12 | } 13 | } -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2020-12/detached-ref.json: -------------------------------------------------------------------------------- 1 | { 2 | "$id": "http://localhost:1234/draft2020-12/detached-ref.json", 3 | "$schema": "https://json-schema.org/draft/2020-12/schema", 4 | "$defs": { 5 | "foo": { 6 | "$ref": "#detached" 7 | }, 8 | "detached": { 9 | "$anchor": "detached", 10 | "type": "integer" 11 | } 12 | } 13 | } -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2020-12/extendible-dynamic-ref.json: -------------------------------------------------------------------------------- 1 | { 2 | "description": "extendible array", 3 | "$schema": "https://json-schema.org/draft/2020-12/schema", 4 | "$id": "http://localhost:1234/draft2020-12/extendible-dynamic-ref.json", 5 | "type": "object", 6 | "properties": { 7 | "elements": { 8 | "type": "array", 9 | "items": { 10 | "$dynamicRef": "#elements" 11 | } 12 | } 13 | }, 14 | "required": ["elements"], 15 | "additionalProperties": false, 16 | "$defs": { 17 | "elements": { 18 | "$dynamicAnchor": "elements" 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2020-12/format-assertion-false.json: -------------------------------------------------------------------------------- 1 | { 2 | "$id": "http://localhost:1234/draft2020-12/format-assertion-false.json", 3 | "$schema": "https://json-schema.org/draft/2020-12/schema", 4 | "$vocabulary": { 5 | "https://json-schema.org/draft/2020-12/vocab/core": true, 6 | "https://json-schema.org/draft/2020-12/vocab/format-assertion": false 7 | }, 8 | "$dynamicAnchor": "meta", 9 | "allOf": [ 10 | { "$ref": "https://json-schema.org/draft/2020-12/meta/core" }, 11 | { "$ref": "https://json-schema.org/draft/2020-12/meta/format-assertion" } 12 | ] 13 | } 14 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2020-12/format-assertion-true.json: -------------------------------------------------------------------------------- 1 | { 2 | "$id": "http://localhost:1234/draft2020-12/format-assertion-true.json", 3 | "$schema": "https://json-schema.org/draft/2020-12/schema", 4 | "$vocabulary": { 5 | "https://json-schema.org/draft/2020-12/vocab/core": true, 6 | "https://json-schema.org/draft/2020-12/vocab/format-assertion": true 7 | }, 8 | "$dynamicAnchor": "meta", 9 | "allOf": [ 10 | { "$ref": "https://json-schema.org/draft/2020-12/meta/core" }, 11 | { "$ref": "https://json-schema.org/draft/2020-12/meta/format-assertion" } 12 | ] 13 | } 14 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2020-12/integer.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2020-12/schema", 3 | "type": "integer" 4 | } 5 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2020-12/locationIndependentIdentifier.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2020-12/schema", 3 | "$defs": { 4 | "refToInteger": { 5 | "$ref": "#foo" 6 | }, 7 | "A": { 8 | "$anchor": "foo", 9 | "type": "integer" 10 | } 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2020-12/metaschema-no-validation.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2020-12/schema", 3 | "$id": "http://localhost:1234/draft2020-12/metaschema-no-validation.json", 4 | "$vocabulary": { 5 | "https://json-schema.org/draft/2020-12/vocab/applicator": true, 6 | "https://json-schema.org/draft/2020-12/vocab/core": true 7 | }, 8 | "$dynamicAnchor": "meta", 9 | "allOf": [ 10 | { "$ref": "https://json-schema.org/draft/2020-12/meta/applicator" }, 11 | { "$ref": "https://json-schema.org/draft/2020-12/meta/core" } 12 | ] 13 | } 14 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2020-12/metaschema-optional-vocabulary.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2020-12/schema", 3 | "$id": "http://localhost:1234/draft2020-12/metaschema-optional-vocabulary.json", 4 | "$vocabulary": { 5 | "https://json-schema.org/draft/2020-12/vocab/validation": true, 6 | "https://json-schema.org/draft/2020-12/vocab/core": true, 7 | "http://localhost:1234/draft/2020-12/vocab/custom": false 8 | }, 9 | "$dynamicAnchor": "meta", 10 | "allOf": [ 11 | { "$ref": "https://json-schema.org/draft/2020-12/meta/validation" }, 12 | { "$ref": "https://json-schema.org/draft/2020-12/meta/core" } 13 | ] 14 | } 15 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2020-12/name-defs.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2020-12/schema", 3 | "$defs": { 4 | "orNull": { 5 | "anyOf": [ 6 | { 7 | "type": "null" 8 | }, 9 | { 10 | "$ref": "#" 11 | } 12 | ] 13 | } 14 | }, 15 | "type": "string" 16 | } 17 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2020-12/nested/foo-ref-string.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2020-12/schema", 3 | "type": "object", 4 | "properties": { 5 | "foo": {"$ref": "string.json"} 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2020-12/nested/string.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2020-12/schema", 3 | "type": "string" 4 | } 5 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2020-12/prefixItems.json: -------------------------------------------------------------------------------- 1 | { 2 | "$id": "http://localhost:1234/draft2020-12/prefixItems.json", 3 | "$schema": "https://json-schema.org/draft/2020-12/schema", 4 | "prefixItems": [ 5 | {"type": "string"} 6 | ] 7 | } 8 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2020-12/ref-and-defs.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2020-12/schema", 3 | "$id": "http://localhost:1234/draft2020-12/ref-and-defs.json", 4 | "$defs": { 5 | "inner": { 6 | "properties": { 7 | "bar": { "type": "string" } 8 | } 9 | } 10 | }, 11 | "$ref": "#/$defs/inner" 12 | } 13 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2020-12/subSchemas.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://json-schema.org/draft/2020-12/schema", 3 | "$defs": { 4 | "integer": { 5 | "type": "integer" 6 | }, 7 | "refToInteger": { 8 | "$ref": "#/$defs/integer" 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft2020-12/tree.json: -------------------------------------------------------------------------------- 1 | { 2 | "description": "tree schema, extensible", 3 | "$schema": "https://json-schema.org/draft/2020-12/schema", 4 | "$id": "http://localhost:1234/draft2020-12/tree.json", 5 | "$dynamicAnchor": "node", 6 | 7 | "type": "object", 8 | "properties": { 9 | "data": true, 10 | "children": { 11 | "type": "array", 12 | "items": { 13 | "$dynamicRef": "#node" 14 | } 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft3/subSchemas.json: -------------------------------------------------------------------------------- 1 | { 2 | "definitions": { 3 | "integer": { 4 | "type": "integer" 5 | }, 6 | "refToInteger": { 7 | "$ref": "#/definitions/integer" 8 | } 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft4/locationIndependentIdentifier.json: -------------------------------------------------------------------------------- 1 | { 2 | "definitions": { 3 | "refToInteger": { 4 | "$ref": "#foo" 5 | }, 6 | "A": { 7 | "id": "#foo", 8 | "type": "integer" 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft4/name.json: -------------------------------------------------------------------------------- 1 | { 2 | "definitions": { 3 | "orNull": { 4 | "anyOf": [ 5 | { 6 | "type": "null" 7 | }, 8 | { 9 | "$ref": "#" 10 | } 11 | ] 12 | } 13 | }, 14 | "type": "string" 15 | } 16 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft4/subSchemas.json: -------------------------------------------------------------------------------- 1 | { 2 | "definitions": { 3 | "integer": { 4 | "type": "integer" 5 | }, 6 | "refToInteger": { 7 | "$ref": "#/definitions/integer" 8 | } 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft6/detached-ref.json: -------------------------------------------------------------------------------- 1 | { 2 | "$id": "http://localhost:1234/draft6/detached-ref.json", 3 | "$schema": "http://json-schema.org/draft-06/schema#", 4 | "definitions": { 5 | "foo": { 6 | "$ref": "#detached" 7 | }, 8 | "detached": { 9 | "$id": "#detached", 10 | "type": "integer" 11 | } 12 | } 13 | } -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft6/locationIndependentIdentifier.json: -------------------------------------------------------------------------------- 1 | { 2 | "definitions": { 3 | "refToInteger": { 4 | "$ref": "#foo" 5 | }, 6 | "A": { 7 | "$id": "#foo", 8 | "type": "integer" 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft6/name.json: -------------------------------------------------------------------------------- 1 | { 2 | "definitions": { 3 | "orNull": { 4 | "anyOf": [ 5 | { 6 | "type": "null" 7 | }, 8 | { 9 | "$ref": "#" 10 | } 11 | ] 12 | } 13 | }, 14 | "type": "string" 15 | } 16 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft6/ref-and-definitions.json: -------------------------------------------------------------------------------- 1 | { 2 | "$id": "http://localhost:1234/draft6/ref-and-definitions.json", 3 | "definitions": { 4 | "inner": { 5 | "properties": { 6 | "bar": { "type": "string" } 7 | } 8 | } 9 | }, 10 | "allOf": [ { "$ref": "#/definitions/inner" } ] 11 | } 12 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft6/subSchemas.json: -------------------------------------------------------------------------------- 1 | { 2 | "definitions": { 3 | "integer": { 4 | "type": "integer" 5 | }, 6 | "refToInteger": { 7 | "$ref": "#/definitions/integer" 8 | } 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft7/detached-ref.json: -------------------------------------------------------------------------------- 1 | { 2 | "$id": "http://localhost:1234/draft7/detached-ref.json", 3 | "$schema": "http://json-schema.org/draft-07/schema#", 4 | "definitions": { 5 | "foo": { 6 | "$ref": "#detached" 7 | }, 8 | "detached": { 9 | "$id": "#detached", 10 | "type": "integer" 11 | } 12 | } 13 | } -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft7/ignore-dependentRequired.json: -------------------------------------------------------------------------------- 1 | { 2 | "$id": "http://localhost:1234/draft7/integer.json", 3 | "$schema": "http://json-schema.org/draft-07/schema#", 4 | "dependentRequired": { 5 | "foo": ["bar"] 6 | } 7 | } -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft7/locationIndependentIdentifier.json: -------------------------------------------------------------------------------- 1 | { 2 | "definitions": { 3 | "refToInteger": { 4 | "$ref": "#foo" 5 | }, 6 | "A": { 7 | "$id": "#foo", 8 | "type": "integer" 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft7/name.json: -------------------------------------------------------------------------------- 1 | { 2 | "definitions": { 3 | "orNull": { 4 | "anyOf": [ 5 | { 6 | "type": "null" 7 | }, 8 | { 9 | "$ref": "#" 10 | } 11 | ] 12 | } 13 | }, 14 | "type": "string" 15 | } 16 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft7/ref-and-definitions.json: -------------------------------------------------------------------------------- 1 | { 2 | "$id": "http://localhost:1234/draft7/ref-and-definitions.json", 3 | "definitions": { 4 | "inner": { 5 | "properties": { 6 | "bar": { "type": "string" } 7 | } 8 | } 9 | }, 10 | "allOf": [ { "$ref": "#/definitions/inner" } ] 11 | } 12 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/draft7/subSchemas.json: -------------------------------------------------------------------------------- 1 | { 2 | "definitions": { 3 | "integer": { 4 | "type": "integer" 5 | }, 6 | "refToInteger": { 7 | "$ref": "#/definitions/integer" 8 | } 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/integer.json: -------------------------------------------------------------------------------- 1 | { 2 | "type": "integer" 3 | } 4 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/nested-absolute-ref-to-string.json: -------------------------------------------------------------------------------- 1 | { 2 | "$defs": { 3 | "bar": { 4 | "$id": "http://localhost:1234/the-nested-id.json", 5 | "type": "string" 6 | } 7 | }, 8 | "$ref": "http://localhost:1234/the-nested-id.json" 9 | } 10 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/nested/foo-ref-string.json: -------------------------------------------------------------------------------- 1 | { 2 | "type": "object", 3 | "properties": { 4 | "foo": {"$ref": "string.json"} 5 | } 6 | } 7 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/nested/string.json: -------------------------------------------------------------------------------- 1 | { 2 | "type": "string" 3 | } 4 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/remotes/urn-ref-string.json: -------------------------------------------------------------------------------- 1 | { 2 | "$id": "urn:uuid:feebdaed-ffff-0000-ffff-0000deadbeef", 3 | "$defs": {"bar": {"type": "string"}}, 4 | "$ref": "#/$defs/bar" 5 | } 6 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2019-09/defs.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "validate definition against metaschema", 4 | "schema": { 5 | "$schema": "https://json-schema.org/draft/2019-09/schema", 6 | "$ref": "https://json-schema.org/draft/2019-09/schema" 7 | }, 8 | "tests": [ 9 | { 10 | "description": "valid definition schema", 11 | "data": {"$defs": {"foo": {"type": "integer"}}}, 12 | "valid": true 13 | }, 14 | { 15 | "description": "invalid definition schema", 16 | "data": {"$defs": {"foo": {"type": 1}}}, 17 | "valid": false 18 | } 19 | ] 20 | } 21 | ] 22 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2019-09/exclusiveMaximum.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "exclusiveMaximum validation", 4 | "schema": { 5 | "$schema": "https://json-schema.org/draft/2019-09/schema", 6 | "exclusiveMaximum": 3.0 7 | }, 8 | "tests": [ 9 | { 10 | "description": "below the exclusiveMaximum is valid", 11 | "data": 2.2, 12 | "valid": true 13 | }, 14 | { 15 | "description": "boundary point is invalid", 16 | "data": 3.0, 17 | "valid": false 18 | }, 19 | { 20 | "description": "above the exclusiveMaximum is invalid", 21 | "data": 3.5, 22 | "valid": false 23 | }, 24 | { 25 | "description": "ignores non-numbers", 26 | "data": "x", 27 | "valid": true 28 | } 29 | ] 30 | } 31 | ] 32 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2019-09/exclusiveMinimum.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "exclusiveMinimum validation", 4 | "schema": { 5 | "$schema": "https://json-schema.org/draft/2019-09/schema", 6 | "exclusiveMinimum": 1.1 7 | }, 8 | "tests": [ 9 | { 10 | "description": "above the exclusiveMinimum is valid", 11 | "data": 1.2, 12 | "valid": true 13 | }, 14 | { 15 | "description": "boundary point is invalid", 16 | "data": 1.1, 17 | "valid": false 18 | }, 19 | { 20 | "description": "below the exclusiveMinimum is invalid", 21 | "data": 0.6, 22 | "valid": false 23 | }, 24 | { 25 | "description": "ignores non-numbers", 26 | "data": "x", 27 | "valid": true 28 | } 29 | ] 30 | } 31 | ] 32 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2019-09/infinite-loop-detection.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "evaluating the same schema location against the same data location twice is not a sign of an infinite loop", 4 | "schema": { 5 | "$schema": "https://json-schema.org/draft/2019-09/schema", 6 | "$defs": { 7 | "int": { "type": "integer" } 8 | }, 9 | "allOf": [ 10 | { 11 | "properties": { 12 | "foo": { 13 | "$ref": "#/$defs/int" 14 | } 15 | } 16 | }, 17 | { 18 | "additionalProperties": { 19 | "$ref": "#/$defs/int" 20 | } 21 | } 22 | ] 23 | }, 24 | "tests": [ 25 | { 26 | "description": "passing case", 27 | "data": { "foo": 1 }, 28 | "valid": true 29 | }, 30 | { 31 | "description": "failing case", 32 | "data": { "foo": "a string" }, 33 | "valid": false 34 | } 35 | ] 36 | } 37 | ] 38 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2019-09/maxItems.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "maxItems validation", 4 | "schema": { 5 | "$schema": "https://json-schema.org/draft/2019-09/schema", 6 | "maxItems": 2 7 | }, 8 | "tests": [ 9 | { 10 | "description": "shorter is valid", 11 | "data": [1], 12 | "valid": true 13 | }, 14 | { 15 | "description": "exact length is valid", 16 | "data": [1, 2], 17 | "valid": true 18 | }, 19 | { 20 | "description": "too long is invalid", 21 | "data": [1, 2, 3], 22 | "valid": false 23 | }, 24 | { 25 | "description": "ignores non-arrays", 26 | "data": "foobar", 27 | "valid": true 28 | } 29 | ] 30 | }, 31 | { 32 | "description": "maxItems validation with a decimal", 33 | "schema": { 34 | "$schema": "https://json-schema.org/draft/2019-09/schema", 35 | "maxItems": 2.0 36 | }, 37 | "tests": [ 38 | { 39 | "description": "shorter is valid", 40 | "data": [1], 41 | "valid": true 42 | }, 43 | { 44 | "description": "too long is invalid", 45 | "data": [1, 2, 3], 46 | "valid": false 47 | } 48 | ] 49 | } 50 | ] 51 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2019-09/minItems.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "minItems validation", 4 | "schema": { 5 | "$schema": "https://json-schema.org/draft/2019-09/schema", 6 | "minItems": 1 7 | }, 8 | "tests": [ 9 | { 10 | "description": "longer is valid", 11 | "data": [1, 2], 12 | "valid": true 13 | }, 14 | { 15 | "description": "exact length is valid", 16 | "data": [1], 17 | "valid": true 18 | }, 19 | { 20 | "description": "too short is invalid", 21 | "data": [], 22 | "valid": false 23 | }, 24 | { 25 | "description": "ignores non-arrays", 26 | "data": "", 27 | "valid": true 28 | } 29 | ] 30 | }, 31 | { 32 | "description": "minItems validation with a decimal", 33 | "schema": { 34 | "$schema": "https://json-schema.org/draft/2019-09/schema", 35 | "minItems": 1.0 36 | }, 37 | "tests": [ 38 | { 39 | "description": "longer is valid", 40 | "data": [1, 2], 41 | "valid": true 42 | }, 43 | { 44 | "description": "too short is invalid", 45 | "data": [], 46 | "valid": false 47 | } 48 | ] 49 | } 50 | ] 51 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2019-09/optional/float-overflow.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "all integers are multiples of 0.5, if overflow is handled", 4 | "schema": { 5 | "$schema": "https://json-schema.org/draft/2019-09/schema", 6 | "type": "integer", "multipleOf": 0.5 7 | }, 8 | "tests": [ 9 | { 10 | "description": "valid if optional overflow handling is implemented", 11 | "data": 1e308, 12 | "valid": true 13 | } 14 | ] 15 | } 16 | ] 17 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2019-09/optional/format/unknown.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "unknown format", 4 | "schema": { 5 | "$schema": "https://json-schema.org/draft/2019-09/schema", 6 | "format": "unknown" 7 | }, 8 | "tests": [ 9 | { 10 | "description": "unknown formats ignore integers", 11 | "data": 12, 12 | "valid": true 13 | }, 14 | { 15 | "description": "unknown formats ignore floats", 16 | "data": 13.7, 17 | "valid": true 18 | }, 19 | { 20 | "description": "unknown formats ignore objects", 21 | "data": {}, 22 | "valid": true 23 | }, 24 | { 25 | "description": "unknown formats ignore arrays", 26 | "data": [], 27 | "valid": true 28 | }, 29 | { 30 | "description": "unknown formats ignore booleans", 31 | "data": false, 32 | "valid": true 33 | }, 34 | { 35 | "description": "unknown formats ignore nulls", 36 | "data": null, 37 | "valid": true 38 | }, 39 | { 40 | "description": "unknown formats ignore strings", 41 | "data": "string", 42 | "valid": true 43 | } 44 | ] 45 | } 46 | ] 47 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2019-09/optional/no-schema.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "validation without $schema", 4 | "comment": "minLength is the same across all drafts", 5 | "schema": { 6 | "minLength": 2 7 | }, 8 | "tests": [ 9 | { 10 | "description": "a 3-character string is valid", 11 | "data": "foo", 12 | "valid": true 13 | }, 14 | { 15 | "description": "a 1-character string is not valid", 16 | "data": "a", 17 | "valid": false 18 | }, 19 | { 20 | "description": "a non-string is valid", 21 | "data": 5, 22 | "valid": true 23 | } 24 | ] 25 | } 26 | ] 27 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2020-12/defs.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "validate definition against metaschema", 4 | "schema": { 5 | "$schema": "https://json-schema.org/draft/2020-12/schema", 6 | "$ref": "https://json-schema.org/draft/2020-12/schema" 7 | }, 8 | "tests": [ 9 | { 10 | "description": "valid definition schema", 11 | "data": {"$defs": {"foo": {"type": "integer"}}}, 12 | "valid": true 13 | }, 14 | { 15 | "description": "invalid definition schema", 16 | "data": {"$defs": {"foo": {"type": 1}}}, 17 | "valid": false 18 | } 19 | ] 20 | } 21 | ] 22 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2020-12/exclusiveMaximum.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "exclusiveMaximum validation", 4 | "schema": { 5 | "$schema": "https://json-schema.org/draft/2020-12/schema", 6 | "exclusiveMaximum": 3.0 7 | }, 8 | "tests": [ 9 | { 10 | "description": "below the exclusiveMaximum is valid", 11 | "data": 2.2, 12 | "valid": true 13 | }, 14 | { 15 | "description": "boundary point is invalid", 16 | "data": 3.0, 17 | "valid": false 18 | }, 19 | { 20 | "description": "above the exclusiveMaximum is invalid", 21 | "data": 3.5, 22 | "valid": false 23 | }, 24 | { 25 | "description": "ignores non-numbers", 26 | "data": "x", 27 | "valid": true 28 | } 29 | ] 30 | } 31 | ] 32 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2020-12/exclusiveMinimum.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "exclusiveMinimum validation", 4 | "schema": { 5 | "$schema": "https://json-schema.org/draft/2020-12/schema", 6 | "exclusiveMinimum": 1.1 7 | }, 8 | "tests": [ 9 | { 10 | "description": "above the exclusiveMinimum is valid", 11 | "data": 1.2, 12 | "valid": true 13 | }, 14 | { 15 | "description": "boundary point is invalid", 16 | "data": 1.1, 17 | "valid": false 18 | }, 19 | { 20 | "description": "below the exclusiveMinimum is invalid", 21 | "data": 0.6, 22 | "valid": false 23 | }, 24 | { 25 | "description": "ignores non-numbers", 26 | "data": "x", 27 | "valid": true 28 | } 29 | ] 30 | } 31 | ] 32 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2020-12/infinite-loop-detection.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "evaluating the same schema location against the same data location twice is not a sign of an infinite loop", 4 | "schema": { 5 | "$schema": "https://json-schema.org/draft/2020-12/schema", 6 | "$defs": { 7 | "int": { "type": "integer" } 8 | }, 9 | "allOf": [ 10 | { 11 | "properties": { 12 | "foo": { 13 | "$ref": "#/$defs/int" 14 | } 15 | } 16 | }, 17 | { 18 | "additionalProperties": { 19 | "$ref": "#/$defs/int" 20 | } 21 | } 22 | ] 23 | }, 24 | "tests": [ 25 | { 26 | "description": "passing case", 27 | "data": { "foo": 1 }, 28 | "valid": true 29 | }, 30 | { 31 | "description": "failing case", 32 | "data": { "foo": "a string" }, 33 | "valid": false 34 | } 35 | ] 36 | } 37 | ] 38 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2020-12/maxItems.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "maxItems validation", 4 | "schema": { 5 | "$schema": "https://json-schema.org/draft/2020-12/schema", 6 | "maxItems": 2 7 | }, 8 | "tests": [ 9 | { 10 | "description": "shorter is valid", 11 | "data": [1], 12 | "valid": true 13 | }, 14 | { 15 | "description": "exact length is valid", 16 | "data": [1, 2], 17 | "valid": true 18 | }, 19 | { 20 | "description": "too long is invalid", 21 | "data": [1, 2, 3], 22 | "valid": false 23 | }, 24 | { 25 | "description": "ignores non-arrays", 26 | "data": "foobar", 27 | "valid": true 28 | } 29 | ] 30 | }, 31 | { 32 | "description": "maxItems validation with a decimal", 33 | "schema": { 34 | "$schema": "https://json-schema.org/draft/2020-12/schema", 35 | "maxItems": 2.0 36 | }, 37 | "tests": [ 38 | { 39 | "description": "shorter is valid", 40 | "data": [1], 41 | "valid": true 42 | }, 43 | { 44 | "description": "too long is invalid", 45 | "data": [1, 2, 3], 46 | "valid": false 47 | } 48 | ] 49 | } 50 | ] 51 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2020-12/minItems.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "minItems validation", 4 | "schema": { 5 | "$schema": "https://json-schema.org/draft/2020-12/schema", 6 | "minItems": 1 7 | }, 8 | "tests": [ 9 | { 10 | "description": "longer is valid", 11 | "data": [1, 2], 12 | "valid": true 13 | }, 14 | { 15 | "description": "exact length is valid", 16 | "data": [1], 17 | "valid": true 18 | }, 19 | { 20 | "description": "too short is invalid", 21 | "data": [], 22 | "valid": false 23 | }, 24 | { 25 | "description": "ignores non-arrays", 26 | "data": "", 27 | "valid": true 28 | } 29 | ] 30 | }, 31 | { 32 | "description": "minItems validation with a decimal", 33 | "schema": { 34 | "$schema": "https://json-schema.org/draft/2020-12/schema", 35 | "minItems": 1.0 36 | }, 37 | "tests": [ 38 | { 39 | "description": "longer is valid", 40 | "data": [1, 2], 41 | "valid": true 42 | }, 43 | { 44 | "description": "too short is invalid", 45 | "data": [], 46 | "valid": false 47 | } 48 | ] 49 | } 50 | ] 51 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2020-12/optional/cross-draft.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "refs to historic drafts are processed as historic drafts", 4 | "schema": { 5 | "$schema": "https://json-schema.org/draft/2020-12/schema", 6 | "type": "array", 7 | "$ref": "http://localhost:1234/draft2019-09/ignore-prefixItems.json" 8 | }, 9 | "tests": [ 10 | { 11 | "description": "first item not a string is valid", 12 | "comment": "if the implementation is not processing the $ref as a 2019-09 schema, this test will fail", 13 | "data": [1, 2, 3], 14 | "valid": true 15 | } 16 | ] 17 | } 18 | ] 19 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2020-12/optional/float-overflow.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "all integers are multiples of 0.5, if overflow is handled", 4 | "schema": { 5 | "$schema": "https://json-schema.org/draft/2020-12/schema", 6 | "type": "integer", 7 | "multipleOf": 0.5 8 | }, 9 | "tests": [ 10 | { 11 | "description": "valid if optional overflow handling is implemented", 12 | "data": 1e308, 13 | "valid": true 14 | } 15 | ] 16 | } 17 | ] 18 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2020-12/optional/format-assertion.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "schema that uses custom metaschema with format-assertion: false", 4 | "schema": { 5 | "$id": "https://schema/using/format-assertion/false", 6 | "$schema": "http://localhost:1234/draft2020-12/format-assertion-false.json", 7 | "format": "ipv4" 8 | }, 9 | "tests": [ 10 | { 11 | "description": "format-assertion: false: valid string", 12 | "data": "127.0.0.1", 13 | "valid": true 14 | }, 15 | { 16 | "description": "format-assertion: false: invalid string", 17 | "data": "not-an-ipv4", 18 | "valid": false 19 | } 20 | ] 21 | }, 22 | { 23 | "description": "schema that uses custom metaschema with format-assertion: true", 24 | "schema": { 25 | "$id": "https://schema/using/format-assertion/true", 26 | "$schema": "http://localhost:1234/draft2020-12/format-assertion-true.json", 27 | "format": "ipv4" 28 | }, 29 | "tests": [ 30 | { 31 | "description": "format-assertion: true: valid string", 32 | "data": "127.0.0.1", 33 | "valid": true 34 | }, 35 | { 36 | "description": "format-assertion: true: invalid string", 37 | "data": "not-an-ipv4", 38 | "valid": false 39 | } 40 | ] 41 | } 42 | ] 43 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2020-12/optional/format/ecmascript-regex.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "\\a is not an ECMA 262 control escape", 4 | "schema": { 5 | "$schema": "https://json-schema.org/draft/2020-12/schema", 6 | "format": "regex" 7 | }, 8 | "tests": [ 9 | { 10 | "description": "when used as a pattern", 11 | "data": "\\a", 12 | "valid": false 13 | } 14 | ] 15 | } 16 | ] -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2020-12/optional/format/unknown.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "unknown format", 4 | "schema": { 5 | "$schema": "https://json-schema.org/draft/2020-12/schema", 6 | "format": "unknown" 7 | }, 8 | "tests": [ 9 | { 10 | "description": "unknown formats ignore integers", 11 | "data": 12, 12 | "valid": true 13 | }, 14 | { 15 | "description": "unknown formats ignore floats", 16 | "data": 13.7, 17 | "valid": true 18 | }, 19 | { 20 | "description": "unknown formats ignore objects", 21 | "data": {}, 22 | "valid": true 23 | }, 24 | { 25 | "description": "unknown formats ignore arrays", 26 | "data": [], 27 | "valid": true 28 | }, 29 | { 30 | "description": "unknown formats ignore booleans", 31 | "data": false, 32 | "valid": true 33 | }, 34 | { 35 | "description": "unknown formats ignore nulls", 36 | "data": null, 37 | "valid": true 38 | }, 39 | { 40 | "description": "unknown formats ignore strings", 41 | "data": "string", 42 | "valid": true 43 | } 44 | ] 45 | } 46 | ] 47 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft2020-12/optional/no-schema.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "validation without $schema", 4 | "comment": "minLength is the same across all drafts", 5 | "schema": { 6 | "minLength": 2 7 | }, 8 | "tests": [ 9 | { 10 | "description": "a 3-character string is valid", 11 | "data": "foo", 12 | "valid": true 13 | }, 14 | { 15 | "description": "a 1-character string is not valid", 16 | "data": "a", 17 | "valid": false 18 | }, 19 | { 20 | "description": "a non-string is valid", 21 | "data": 5, 22 | "valid": true 23 | } 24 | ] 25 | } 26 | ] 27 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft4/definitions.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "validate definition against metaschema", 4 | "schema": {"$ref": "http://json-schema.org/draft-04/schema#"}, 5 | "tests": [ 6 | { 7 | "description": "valid definition schema", 8 | "data": { 9 | "definitions": { 10 | "foo": {"type": "integer"} 11 | } 12 | }, 13 | "valid": true 14 | }, 15 | { 16 | "description": "invalid definition schema", 17 | "data": { 18 | "definitions": { 19 | "foo": {"type": 1} 20 | } 21 | }, 22 | "valid": false 23 | } 24 | ] 25 | } 26 | ] 27 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft4/infinite-loop-detection.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "evaluating the same schema location against the same data location twice is not a sign of an infinite loop", 4 | "schema": { 5 | "definitions": { 6 | "int": { "type": "integer" } 7 | }, 8 | "allOf": [ 9 | { 10 | "properties": { 11 | "foo": { 12 | "$ref": "#/definitions/int" 13 | } 14 | } 15 | }, 16 | { 17 | "additionalProperties": { 18 | "$ref": "#/definitions/int" 19 | } 20 | } 21 | ] 22 | }, 23 | "tests": [ 24 | { 25 | "description": "passing case", 26 | "data": { "foo": 1 }, 27 | "valid": true 28 | }, 29 | { 30 | "description": "failing case", 31 | "data": { "foo": "a string" }, 32 | "valid": false 33 | } 34 | ] 35 | } 36 | ] 37 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft4/maxItems.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "maxItems validation", 4 | "schema": {"maxItems": 2}, 5 | "tests": [ 6 | { 7 | "description": "shorter is valid", 8 | "data": [1], 9 | "valid": true 10 | }, 11 | { 12 | "description": "exact length is valid", 13 | "data": [1, 2], 14 | "valid": true 15 | }, 16 | { 17 | "description": "too long is invalid", 18 | "data": [1, 2, 3], 19 | "valid": false 20 | }, 21 | { 22 | "description": "ignores non-arrays", 23 | "data": "foobar", 24 | "valid": true 25 | } 26 | ] 27 | } 28 | ] 29 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft4/maxLength.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "maxLength validation", 4 | "schema": {"maxLength": 2}, 5 | "tests": [ 6 | { 7 | "description": "shorter is valid", 8 | "data": "f", 9 | "valid": true 10 | }, 11 | { 12 | "description": "exact length is valid", 13 | "data": "fo", 14 | "valid": true 15 | }, 16 | { 17 | "description": "too long is invalid", 18 | "data": "foo", 19 | "valid": false 20 | }, 21 | { 22 | "description": "ignores non-strings", 23 | "data": 100, 24 | "valid": true 25 | }, 26 | { 27 | "description": "two graphemes is long enough", 28 | "data": "\uD83D\uDCA9\uD83D\uDCA9", 29 | "valid": true 30 | } 31 | ] 32 | } 33 | ] 34 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft4/minItems.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "minItems validation", 4 | "schema": {"minItems": 1}, 5 | "tests": [ 6 | { 7 | "description": "longer is valid", 8 | "data": [1, 2], 9 | "valid": true 10 | }, 11 | { 12 | "description": "exact length is valid", 13 | "data": [1], 14 | "valid": true 15 | }, 16 | { 17 | "description": "too short is invalid", 18 | "data": [], 19 | "valid": false 20 | }, 21 | { 22 | "description": "ignores non-arrays", 23 | "data": "", 24 | "valid": true 25 | } 26 | ] 27 | } 28 | ] 29 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft4/minLength.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "minLength validation", 4 | "schema": {"minLength": 2}, 5 | "tests": [ 6 | { 7 | "description": "longer is valid", 8 | "data": "foo", 9 | "valid": true 10 | }, 11 | { 12 | "description": "exact length is valid", 13 | "data": "fo", 14 | "valid": true 15 | }, 16 | { 17 | "description": "too short is invalid", 18 | "data": "f", 19 | "valid": false 20 | }, 21 | { 22 | "description": "ignores non-strings", 23 | "data": 1, 24 | "valid": true 25 | }, 26 | { 27 | "description": "one grapheme is not long enough", 28 | "data": "\uD83D\uDCA9", 29 | "valid": false 30 | } 31 | ] 32 | } 33 | ] 34 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft4/minProperties.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "minProperties validation", 4 | "schema": {"minProperties": 1}, 5 | "tests": [ 6 | { 7 | "description": "longer is valid", 8 | "data": {"foo": 1, "bar": 2}, 9 | "valid": true 10 | }, 11 | { 12 | "description": "exact length is valid", 13 | "data": {"foo": 1}, 14 | "valid": true 15 | }, 16 | { 17 | "description": "too short is invalid", 18 | "data": {}, 19 | "valid": false 20 | }, 21 | { 22 | "description": "ignores arrays", 23 | "data": [], 24 | "valid": true 25 | }, 26 | { 27 | "description": "ignores strings", 28 | "data": "", 29 | "valid": true 30 | }, 31 | { 32 | "description": "ignores other non-objects", 33 | "data": 12, 34 | "valid": true 35 | } 36 | ] 37 | } 38 | ] 39 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft4/optional/float-overflow.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "all integers are multiples of 0.5, if overflow is handled", 4 | "schema": {"type": "number", "multipleOf": 0.5}, 5 | "tests": [ 6 | { 7 | "description": "valid if optional overflow handling is implemented", 8 | "data": 1e308, 9 | "valid": true 10 | } 11 | ] 12 | } 13 | ] 14 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft4/optional/format/unknown.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "unknown format", 4 | "schema": { "format": "unknown" }, 5 | "tests": [ 6 | { 7 | "description": "unknown formats ignore integers", 8 | "data": 12, 9 | "valid": true 10 | }, 11 | { 12 | "description": "unknown formats ignore floats", 13 | "data": 13.7, 14 | "valid": true 15 | }, 16 | { 17 | "description": "unknown formats ignore objects", 18 | "data": {}, 19 | "valid": true 20 | }, 21 | { 22 | "description": "unknown formats ignore arrays", 23 | "data": [], 24 | "valid": true 25 | }, 26 | { 27 | "description": "unknown formats ignore booleans", 28 | "data": false, 29 | "valid": true 30 | }, 31 | { 32 | "description": "unknown formats ignore nulls", 33 | "data": null, 34 | "valid": true 35 | }, 36 | { 37 | "description": "unknown formats ignore strings", 38 | "data": "string", 39 | "valid": true 40 | } 41 | ] 42 | } 43 | ] 44 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft4/optional/zeroTerminatedFloats.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "some languages do not distinguish between different types of numeric value", 4 | "schema": { 5 | "type": "integer" 6 | }, 7 | "tests": [ 8 | { 9 | "description": "a float is not an integer even without fractional part", 10 | "data": 1.0, 11 | "valid": false 12 | } 13 | ] 14 | } 15 | ] 16 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft6/definitions.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "validate definition against metaschema", 4 | "schema": {"$ref": "http://json-schema.org/draft-06/schema#"}, 5 | "tests": [ 6 | { 7 | "description": "valid definition schema", 8 | "data": { 9 | "definitions": { 10 | "foo": {"type": "integer"} 11 | } 12 | }, 13 | "valid": true 14 | }, 15 | { 16 | "description": "invalid definition schema", 17 | "data": { 18 | "definitions": { 19 | "foo": {"type": 1} 20 | } 21 | }, 22 | "valid": false 23 | } 24 | ] 25 | } 26 | ] 27 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft6/exclusiveMaximum.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "exclusiveMaximum validation", 4 | "schema": { 5 | "exclusiveMaximum": 3.0 6 | }, 7 | "tests": [ 8 | { 9 | "description": "below the exclusiveMaximum is valid", 10 | "data": 2.2, 11 | "valid": true 12 | }, 13 | { 14 | "description": "boundary point is invalid", 15 | "data": 3.0, 16 | "valid": false 17 | }, 18 | { 19 | "description": "above the exclusiveMaximum is invalid", 20 | "data": 3.5, 21 | "valid": false 22 | }, 23 | { 24 | "description": "ignores non-numbers", 25 | "data": "x", 26 | "valid": true 27 | } 28 | ] 29 | } 30 | ] 31 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft6/exclusiveMinimum.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "exclusiveMinimum validation", 4 | "schema": { 5 | "exclusiveMinimum": 1.1 6 | }, 7 | "tests": [ 8 | { 9 | "description": "above the exclusiveMinimum is valid", 10 | "data": 1.2, 11 | "valid": true 12 | }, 13 | { 14 | "description": "boundary point is invalid", 15 | "data": 1.1, 16 | "valid": false 17 | }, 18 | { 19 | "description": "below the exclusiveMinimum is invalid", 20 | "data": 0.6, 21 | "valid": false 22 | }, 23 | { 24 | "description": "ignores non-numbers", 25 | "data": "x", 26 | "valid": true 27 | } 28 | ] 29 | } 30 | ] 31 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft6/infinite-loop-detection.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "evaluating the same schema location against the same data location twice is not a sign of an infinite loop", 4 | "schema": { 5 | "definitions": { 6 | "int": { "type": "integer" } 7 | }, 8 | "allOf": [ 9 | { 10 | "properties": { 11 | "foo": { 12 | "$ref": "#/definitions/int" 13 | } 14 | } 15 | }, 16 | { 17 | "additionalProperties": { 18 | "$ref": "#/definitions/int" 19 | } 20 | } 21 | ] 22 | }, 23 | "tests": [ 24 | { 25 | "description": "passing case", 26 | "data": { "foo": 1 }, 27 | "valid": true 28 | }, 29 | { 30 | "description": "failing case", 31 | "data": { "foo": "a string" }, 32 | "valid": false 33 | } 34 | ] 35 | } 36 | ] 37 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft6/maxItems.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "maxItems validation", 4 | "schema": {"maxItems": 2}, 5 | "tests": [ 6 | { 7 | "description": "shorter is valid", 8 | "data": [1], 9 | "valid": true 10 | }, 11 | { 12 | "description": "exact length is valid", 13 | "data": [1, 2], 14 | "valid": true 15 | }, 16 | { 17 | "description": "too long is invalid", 18 | "data": [1, 2, 3], 19 | "valid": false 20 | }, 21 | { 22 | "description": "ignores non-arrays", 23 | "data": "foobar", 24 | "valid": true 25 | } 26 | ] 27 | }, 28 | { 29 | "description": "maxItems validation with a decimal", 30 | "schema": {"maxItems": 2.0}, 31 | "tests": [ 32 | { 33 | "description": "shorter is valid", 34 | "data": [1], 35 | "valid": true 36 | }, 37 | { 38 | "description": "too long is invalid", 39 | "data": [1, 2, 3], 40 | "valid": false 41 | } 42 | ] 43 | } 44 | ] 45 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft6/maxLength.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "maxLength validation", 4 | "schema": {"maxLength": 2}, 5 | "tests": [ 6 | { 7 | "description": "shorter is valid", 8 | "data": "f", 9 | "valid": true 10 | }, 11 | { 12 | "description": "exact length is valid", 13 | "data": "fo", 14 | "valid": true 15 | }, 16 | { 17 | "description": "too long is invalid", 18 | "data": "foo", 19 | "valid": false 20 | }, 21 | { 22 | "description": "ignores non-strings", 23 | "data": 100, 24 | "valid": true 25 | }, 26 | { 27 | "description": "two graphemes is long enough", 28 | "data": "\uD83D\uDCA9\uD83D\uDCA9", 29 | "valid": true 30 | } 31 | ] 32 | }, 33 | { 34 | "description": "maxLength validation with a decimal", 35 | "schema": {"maxLength": 2.0}, 36 | "tests": [ 37 | { 38 | "description": "shorter is valid", 39 | "data": "f", 40 | "valid": true 41 | }, 42 | { 43 | "description": "too long is invalid", 44 | "data": "foo", 45 | "valid": false 46 | } 47 | ] 48 | } 49 | ] 50 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft6/minItems.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "minItems validation", 4 | "schema": {"minItems": 1}, 5 | "tests": [ 6 | { 7 | "description": "longer is valid", 8 | "data": [1, 2], 9 | "valid": true 10 | }, 11 | { 12 | "description": "exact length is valid", 13 | "data": [1], 14 | "valid": true 15 | }, 16 | { 17 | "description": "too short is invalid", 18 | "data": [], 19 | "valid": false 20 | }, 21 | { 22 | "description": "ignores non-arrays", 23 | "data": "", 24 | "valid": true 25 | } 26 | ] 27 | }, 28 | { 29 | "description": "minItems validation with a decimal", 30 | "schema": {"minItems": 1.0}, 31 | "tests": [ 32 | { 33 | "description": "longer is valid", 34 | "data": [1, 2], 35 | "valid": true 36 | }, 37 | { 38 | "description": "too short is invalid", 39 | "data": [], 40 | "valid": false 41 | } 42 | ] 43 | } 44 | ] 45 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft6/minLength.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "minLength validation", 4 | "schema": {"minLength": 2}, 5 | "tests": [ 6 | { 7 | "description": "longer is valid", 8 | "data": "foo", 9 | "valid": true 10 | }, 11 | { 12 | "description": "exact length is valid", 13 | "data": "fo", 14 | "valid": true 15 | }, 16 | { 17 | "description": "too short is invalid", 18 | "data": "f", 19 | "valid": false 20 | }, 21 | { 22 | "description": "ignores non-strings", 23 | "data": 1, 24 | "valid": true 25 | }, 26 | { 27 | "description": "one grapheme is not long enough", 28 | "data": "\uD83D\uDCA9", 29 | "valid": false 30 | } 31 | ] 32 | }, 33 | { 34 | "description": "minLength validation with a decimal", 35 | "schema": {"minLength": 2.0}, 36 | "tests": [ 37 | { 38 | "description": "longer is valid", 39 | "data": "foo", 40 | "valid": true 41 | }, 42 | { 43 | "description": "too short is invalid", 44 | "data": "f", 45 | "valid": false 46 | } 47 | ] 48 | } 49 | ] 50 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft6/optional/float-overflow.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "all integers are multiples of 0.5, if overflow is handled", 4 | "schema": {"type": "integer", "multipleOf": 0.5}, 5 | "tests": [ 6 | { 7 | "description": "valid if optional overflow handling is implemented", 8 | "data": 1e308, 9 | "valid": true 10 | } 11 | ] 12 | } 13 | ] 14 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft6/optional/format/unknown.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "unknown format", 4 | "schema": { "format": "unknown" }, 5 | "tests": [ 6 | { 7 | "description": "unknown formats ignore integers", 8 | "data": 12, 9 | "valid": true 10 | }, 11 | { 12 | "description": "unknown formats ignore floats", 13 | "data": 13.7, 14 | "valid": true 15 | }, 16 | { 17 | "description": "unknown formats ignore objects", 18 | "data": {}, 19 | "valid": true 20 | }, 21 | { 22 | "description": "unknown formats ignore arrays", 23 | "data": [], 24 | "valid": true 25 | }, 26 | { 27 | "description": "unknown formats ignore booleans", 28 | "data": false, 29 | "valid": true 30 | }, 31 | { 32 | "description": "unknown formats ignore nulls", 33 | "data": null, 34 | "valid": true 35 | }, 36 | { 37 | "description": "unknown formats ignore strings", 38 | "data": "string", 39 | "valid": true 40 | } 41 | ] 42 | } 43 | ] 44 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft7/definitions.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "validate definition against metaschema", 4 | "schema": {"$ref": "http://json-schema.org/draft-07/schema#"}, 5 | "tests": [ 6 | { 7 | "description": "valid definition schema", 8 | "data": { 9 | "definitions": { 10 | "foo": {"type": "integer"} 11 | } 12 | }, 13 | "valid": true 14 | }, 15 | { 16 | "description": "invalid definition schema", 17 | "data": { 18 | "definitions": { 19 | "foo": {"type": 1} 20 | } 21 | }, 22 | "valid": false 23 | } 24 | ] 25 | } 26 | ] 27 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft7/exclusiveMaximum.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "exclusiveMaximum validation", 4 | "schema": { 5 | "exclusiveMaximum": 3.0 6 | }, 7 | "tests": [ 8 | { 9 | "description": "below the exclusiveMaximum is valid", 10 | "data": 2.2, 11 | "valid": true 12 | }, 13 | { 14 | "description": "boundary point is invalid", 15 | "data": 3.0, 16 | "valid": false 17 | }, 18 | { 19 | "description": "above the exclusiveMaximum is invalid", 20 | "data": 3.5, 21 | "valid": false 22 | }, 23 | { 24 | "description": "ignores non-numbers", 25 | "data": "x", 26 | "valid": true 27 | } 28 | ] 29 | } 30 | ] 31 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft7/exclusiveMinimum.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "exclusiveMinimum validation", 4 | "schema": { 5 | "exclusiveMinimum": 1.1 6 | }, 7 | "tests": [ 8 | { 9 | "description": "above the exclusiveMinimum is valid", 10 | "data": 1.2, 11 | "valid": true 12 | }, 13 | { 14 | "description": "boundary point is invalid", 15 | "data": 1.1, 16 | "valid": false 17 | }, 18 | { 19 | "description": "below the exclusiveMinimum is invalid", 20 | "data": 0.6, 21 | "valid": false 22 | }, 23 | { 24 | "description": "ignores non-numbers", 25 | "data": "x", 26 | "valid": true 27 | } 28 | ] 29 | } 30 | ] 31 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft7/infinite-loop-detection.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "evaluating the same schema location against the same data location twice is not a sign of an infinite loop", 4 | "schema": { 5 | "definitions": { 6 | "int": { "type": "integer" } 7 | }, 8 | "allOf": [ 9 | { 10 | "properties": { 11 | "foo": { 12 | "$ref": "#/definitions/int" 13 | } 14 | } 15 | }, 16 | { 17 | "additionalProperties": { 18 | "$ref": "#/definitions/int" 19 | } 20 | } 21 | ] 22 | }, 23 | "tests": [ 24 | { 25 | "description": "passing case", 26 | "data": { "foo": 1 }, 27 | "valid": true 28 | }, 29 | { 30 | "description": "failing case", 31 | "data": { "foo": "a string" }, 32 | "valid": false 33 | } 34 | ] 35 | } 36 | ] 37 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft7/maxItems.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "maxItems validation", 4 | "schema": {"maxItems": 2}, 5 | "tests": [ 6 | { 7 | "description": "shorter is valid", 8 | "data": [1], 9 | "valid": true 10 | }, 11 | { 12 | "description": "exact length is valid", 13 | "data": [1, 2], 14 | "valid": true 15 | }, 16 | { 17 | "description": "too long is invalid", 18 | "data": [1, 2, 3], 19 | "valid": false 20 | }, 21 | { 22 | "description": "ignores non-arrays", 23 | "data": "foobar", 24 | "valid": true 25 | } 26 | ] 27 | }, 28 | { 29 | "description": "maxItems validation with a decimal", 30 | "schema": {"maxItems": 2.0}, 31 | "tests": [ 32 | { 33 | "description": "shorter is valid", 34 | "data": [1], 35 | "valid": true 36 | }, 37 | { 38 | "description": "too long is invalid", 39 | "data": [1, 2, 3], 40 | "valid": false 41 | } 42 | ] 43 | } 44 | ] 45 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft7/maxLength.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "maxLength validation", 4 | "schema": {"maxLength": 2}, 5 | "tests": [ 6 | { 7 | "description": "shorter is valid", 8 | "data": "f", 9 | "valid": true 10 | }, 11 | { 12 | "description": "exact length is valid", 13 | "data": "fo", 14 | "valid": true 15 | }, 16 | { 17 | "description": "too long is invalid", 18 | "data": "foo", 19 | "valid": false 20 | }, 21 | { 22 | "description": "ignores non-strings", 23 | "data": 100, 24 | "valid": true 25 | }, 26 | { 27 | "description": "two graphemes is long enough", 28 | "data": "\uD83D\uDCA9\uD83D\uDCA9", 29 | "valid": true 30 | } 31 | ] 32 | }, 33 | { 34 | "description": "maxLength validation with a decimal", 35 | "schema": {"maxLength": 2.0}, 36 | "tests": [ 37 | { 38 | "description": "shorter is valid", 39 | "data": "f", 40 | "valid": true 41 | }, 42 | { 43 | "description": "too long is invalid", 44 | "data": "foo", 45 | "valid": false 46 | } 47 | ] 48 | } 49 | ] 50 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft7/minItems.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "minItems validation", 4 | "schema": {"minItems": 1}, 5 | "tests": [ 6 | { 7 | "description": "longer is valid", 8 | "data": [1, 2], 9 | "valid": true 10 | }, 11 | { 12 | "description": "exact length is valid", 13 | "data": [1], 14 | "valid": true 15 | }, 16 | { 17 | "description": "too short is invalid", 18 | "data": [], 19 | "valid": false 20 | }, 21 | { 22 | "description": "ignores non-arrays", 23 | "data": "", 24 | "valid": true 25 | } 26 | ] 27 | }, 28 | { 29 | "description": "minItems validation with a decimal", 30 | "schema": {"minItems": 1.0}, 31 | "tests": [ 32 | { 33 | "description": "longer is valid", 34 | "data": [1, 2], 35 | "valid": true 36 | }, 37 | { 38 | "description": "too short is invalid", 39 | "data": [], 40 | "valid": false 41 | } 42 | ] 43 | } 44 | ] 45 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft7/minLength.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "minLength validation", 4 | "schema": {"minLength": 2}, 5 | "tests": [ 6 | { 7 | "description": "longer is valid", 8 | "data": "foo", 9 | "valid": true 10 | }, 11 | { 12 | "description": "exact length is valid", 13 | "data": "fo", 14 | "valid": true 15 | }, 16 | { 17 | "description": "too short is invalid", 18 | "data": "f", 19 | "valid": false 20 | }, 21 | { 22 | "description": "ignores non-strings", 23 | "data": 1, 24 | "valid": true 25 | }, 26 | { 27 | "description": "one grapheme is not long enough", 28 | "data": "\uD83D\uDCA9", 29 | "valid": false 30 | } 31 | ] 32 | }, 33 | { 34 | "description": "minLength validation with a decimal", 35 | "schema": {"minLength": 2.0}, 36 | "tests": [ 37 | { 38 | "description": "longer is valid", 39 | "data": "foo", 40 | "valid": true 41 | }, 42 | { 43 | "description": "too short is invalid", 44 | "data": "f", 45 | "valid": false 46 | } 47 | ] 48 | } 49 | ] 50 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft7/optional/cross-draft.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "refs to future drafts are processed as future drafts", 4 | "schema": { 5 | "type": "object", 6 | "allOf": [ 7 | { "properties": { "foo": true } }, 8 | { "$ref": "http://localhost:1234/draft2019-09/dependentRequired.json" } 9 | ] 10 | }, 11 | "tests": [ 12 | { 13 | "description": "missing bar is invalid", 14 | "comment": "if the implementation is not processing the $ref as a 2019-09 schema, this test will fail", 15 | "data": {"foo": "any value"}, 16 | "valid": false 17 | }, 18 | { 19 | "description": "present bar is valid", 20 | "data": {"foo": "any value", "bar": "also any value"}, 21 | "valid": true 22 | } 23 | ] 24 | } 25 | ] 26 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft7/optional/float-overflow.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "all integers are multiples of 0.5, if overflow is handled", 4 | "schema": {"type": "integer", "multipleOf": 0.5}, 5 | "tests": [ 6 | { 7 | "description": "valid if optional overflow handling is implemented", 8 | "data": 1e308, 9 | "valid": true 10 | } 11 | ] 12 | } 13 | ] 14 | -------------------------------------------------------------------------------- /vendor/jsonschema-test-suite/tests/draft7/optional/format/unknown.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "description": "unknown format", 4 | "schema": { "format": "unknown" }, 5 | "tests": [ 6 | { 7 | "description": "unknown formats ignore integers", 8 | "data": 12, 9 | "valid": true 10 | }, 11 | { 12 | "description": "unknown formats ignore floats", 13 | "data": 13.7, 14 | "valid": true 15 | }, 16 | { 17 | "description": "unknown formats ignore objects", 18 | "data": {}, 19 | "valid": true 20 | }, 21 | { 22 | "description": "unknown formats ignore arrays", 23 | "data": [], 24 | "valid": true 25 | }, 26 | { 27 | "description": "unknown formats ignore booleans", 28 | "data": false, 29 | "valid": true 30 | }, 31 | { 32 | "description": "unknown formats ignore nulls", 33 | "data": null, 34 | "valid": true 35 | }, 36 | { 37 | "description": "unknown formats ignore strings", 38 | "data": "string", 39 | "valid": true 40 | } 41 | ] 42 | } 43 | ] 44 | -------------------------------------------------------------------------------- /vendorpull.mask: -------------------------------------------------------------------------------- 1 | benchmark 2 | bindings 3 | contrib 4 | doxygen 5 | test 6 | vendor 7 | cmake 8 | .ackrc 9 | .editorconfig 10 | Brewfile 11 | DEPENDENCIES 12 | Makefile 13 | README.markdown 14 | assets 15 | --------------------------------------------------------------------------------