json-schema-ouidou 2.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 229c79fe08ec97502b0d3d7fb9384655af26b050fdc0b545ae4a286684cf130b
+  data.tar.gz: 9e1777a533de9c1abab5bd537f28ef0ed7000da0368558847e314e0f258a18bf
+SHA512:
+  metadata.gz: 1ce322cce67da1ef9094291fc34f537135ce26af2f0c3bd292a9a4775404b6a6d866d846e9a7e982c8589292b9ae4510af3d2ac6b6dd5e148f6a1f0a66b1b818
+  data.tar.gz: c53a0aed220852d9bbe67faf49a5cfd51310eb4b77729a4a5f64899fa66e2895945e46164d3cc64f3f7881c42d46827e0c0de82223b57585a5a5374577198cce

data/LICENSE.md

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

data/README.md

@@ -0,0 +1,496 @@
+# Ruby JSON Schema Validator
+
+[![License](https://img.shields.io/github/license/voxpupuli/json-schema.svg)](https://github.com/voxpupuli/json-schema/blob/master/LICENSE)
+[![Test](https://github.com/voxpupuli/json-schema/actions/workflows/test.yml/badge.svg)](https://github.com/voxpupuli/json-schema/actions/workflows/test.yml)
+[![Release](https://github.com/voxpupuli/json-schema/actions/workflows/release.yml/badge.svg)](https://github.com/voxpupuli/json-schema/actions/workflows/release.yml)
+[![RubyGem Version](https://img.shields.io/gem/v/json-schema.svg)](https://rubygems.org/gems/json-schema)
+[![RubyGem Downloads](https://img.shields.io/gem/dt/json-schema.svg)](https://rubygems.org/gems/json-schema)
+[![Donated by Iain Beeston](https://img.shields.io/badge/donated%20by-Iain%20Beeston-fb7047.svg)](#transfer-notice)
+
+This library is intended to provide Ruby with an interface for validating JSON
+objects against a JSON schema conforming to [JSON Schema Draft
+4](http://tools.ietf.org/html/draft-zyp-json-schema-04). Legacy support for
+[JSON Schema Draft 3](http://tools.ietf.org/html/draft-zyp-json-schema-03),
+[JSON Schema Draft 2](http://tools.ietf.org/html/draft-zyp-json-schema-02), and
+[JSON Schema Draft 1](http://tools.ietf.org/html/draft-zyp-json-schema-01) is
+also included.
+
+Additional Resources
+--------------------
+
+- [Google Groups](https://groups.google.com/forum/#!forum/ruby-json-schema)
+- #ruby-json-schema on chat.freenode.net
+
+Version 2.0.0 Upgrade Notes
+---------------------------
+
+Please be aware that the upgrade to version 2.0.0 will use Draft-04 **by
+default**, so schemas that do not declare a validator using the `$schema`
+keyword will use Draft-04 now instead of Draft-03. This is the reason for the
+major version upgrade.
+
+Installation
+------------
+
+From rubygems.org:
+
+```sh
+gem install json-schema
+```
+
+From the git repo:
+
+```sh
+$ gem build json-schema.gemspec
+$ gem install json-schema-2.5.2.gem
+```
+
+Validation
+-----
+
+Three base validation methods exist:
+
+1. `validate`: returns a boolean on whether a validation attempt passes
+2. `validate!`: throws a `JSON::Schema::ValidationError` with an appropriate message/trace on where the validation failed
+3. `fully_validate`: builds an array of validation errors return when validation is complete
+
+All methods take two arguments, which can be either a JSON string, a file
+containing JSON, or a Ruby object representing JSON data. The first argument to
+these methods is always the schema, the second is always the data to validate.
+An optional third options argument is also accepted; available options are used
+in the examples below.
+
+By default, the validator uses the [JSON Schema Draft
+4](http://tools.ietf.org/html/draft-zyp-json-schema-04) specification for
+validation; however, the user is free to specify additional specifications or
+extend existing ones. Legacy support for Draft 1, Draft 2, and Draft 3 is
+included by either passing an optional `:version` parameter to the `validate`
+method (set either as `:draft1` or `draft2`), or by declaring the `$schema`
+attribute in the schema and referencing the appropriate specification URI. Note
+that the `$schema` attribute takes precedence over the `:version` option during
+parsing and validation.
+
+For further information on json schema itself refer to <a
+href="http://spacetelescope.github.io/understanding-json-schema/">Understanding
+JSON Schema</a>.
+
+Basic Usage
+--------------
+
+```ruby
+require "json-schema"
+
+schema = {
+  "type" => "object",
+  "required" => ["a"],
+  "properties" => {
+    "a" => {"type" => "integer"}
+  }
+}
+
+#
+# validate ruby objects against a ruby schema
+#
+
+# => true
+JSON::Validator.validate(schema, { "a" => 5 })
+# => false
+JSON::Validator.validate(schema, {})
+
+#
+# validate a json string against a json schema file
+#
+
+require "json"
+File.write("schema.json", JSON.dump(schema))
+
+# => true
+JSON::Validator.validate('schema.json', '{ "a": 5 }')
+
+#
+# raise an error when validation fails
+#
+
+# => "The property '#/a' of type String did not match the following type: integer"
+begin
+  JSON::Validator.validate!(schema, { "a" => "taco" })
+rescue JSON::Schema::ValidationError => e
+  e.message
+end
+
+#
+# return an array of error messages when validation fails
+#
+
+# => ["The property '#/a' of type String did not match the following type: integer in schema 18a1ffbb-4681-5b00-bd15-2c76aee4b28f"]
+JSON::Validator.fully_validate(schema, { "a" => "taco" })
+```
+
+Advanced Options
+-----------------
+
+```ruby
+require "json-schema"
+
+schema = {
+  "type"=>"object",
+  "required" => ["a"],
+  "properties" => {
+    "a" => {
+      "type" => "integer",
+      "default" => 42
+    },
+    "b" => {
+      "type" => "object",
+      "properties" => {
+        "x" => {
+          "type" => "integer"
+        }
+      }
+    }
+  }
+}
+
+#
+# with the `:list` option, a list can be validated against a schema that represents the individual objects
+#
+
+# => true
+JSON::Validator.validate(schema, [{"a" => 1}, {"a" => 2}, {"a" => 3}], :list => true)
+# => false
+JSON::Validator.validate(schema, [{"a" => 1}, {"a" => 2}, {"a" => 3}])
+
+#
+# with the `:errors_as_objects` option, `#fully_validate` returns errors as hashes instead of strings
+#
+
+# => [{:schema=>#<Addressable::URI:0x3ffa69cbeed8 URI:18a1ffbb-4681-5b00-bd15-2c76aee4b28f>, :fragment=>"#/a", :message=>"The property '#/a' of type String did not match the following type: integer in schema 18a1ffbb-4681-5b00-bd15-2c76aee4b28f", :failed_attribute=>"TypeV4"}]
+JSON::Validator.fully_validate(schema, { "a" => "taco" }, :errors_as_objects => true)
+
+#
+# with the `:strict` option, all properties are considered to have `"required": true` and all objects `"additionalProperties": false`
+#
+
+# => true
+JSON::Validator.validate(schema, { "a" => 1, "b" => { "x" => 2 } }, :strict => true)
+# => false
+JSON::Validator.validate(schema, { "a" => 1, "b" => { "x" => 2 }, "c" => 3 }, :strict => true)
+# => false
+JSON::Validator.validate(schema, { "a" => 1 }, :strict => true)
+
+#
+# with the `:fragment` option, only a fragment of the schema is used for validation
+#
+
+# => true
+JSON::Validator.validate(schema, { "x" => 1 }, :fragment => "#/properties/b")
+# => false
+JSON::Validator.validate(schema, { "x" => 1 })
+
+#
+# with the `:validate_schema` option, the schema is validated (against the json schema spec) before the json is validated (against the specified schema)
+#
+
+# => true
+JSON::Validator.validate(schema, { "a" => 1 }, :validate_schema => true)
+# => false
+JSON::Validator.validate({ "required" => true }, { "a" => 1 }, :validate_schema => true)
+
+#
+# with the `:insert_defaults` option, any undefined values in the json that have a default in the schema are replaced with the default before validation
+#
+
+# => true
+JSON::Validator.validate(schema, {}, :insert_defaults => true)
+# => false
+JSON::Validator.validate(schema, {})
+
+#
+# with the `:version` option, schemas conforming to older drafts of the json schema spec can be used
+#
+
+v2_schema = {
+  "type" => "object",
+  "properties" => {
+    "a" => {
+      "type" => "integer"
+    }
+  }
+}
+
+# => false
+JSON::Validator.validate(v2_schema, {}, :version => :draft2)
+# => true
+JSON::Validator.validate(v2_schema, {})
+
+#
+# with the `:parse_data` option set to false, the json must be a parsed ruby object (not a json text, a uri or a file path)
+#
+
+# => true
+JSON::Validator.validate(schema, { "a" => 1 }, :parse_data => false)
+# => false
+JSON::Validator.validate(schema, '{ "a": 1 }', :parse_data => false)
+
+#
+# with the `:json` option, the json must be an unparsed json text (not a hash, a uri or a file path)
+#
+
+# => true
+JSON::Validator.validate(schema, '{ "a": 1 }', :json => true)
+# => "no implicit conversion of Hash into String"
+begin
+  JSON::Validator.validate(schema, { "a" => 1 }, :json => true)
+rescue TypeError => e
+  e.message
+end
+
+#
+# with the `:uri` option, the json must be a uri or file path (not a hash or a json text)
+#
+
+File.write("data.json", '{ "a": 1 }')
+
+# => true
+JSON::Validator.validate(schema, "data.json", :uri => true)
+# => "Can't convert Hash into String."
+begin
+  JSON::Validator.validate(schema, { "a"  => 1 }, :uri => true)
+rescue TypeError => e
+  e.message
+end
+
+#
+# with the `:clear_cache` option set to true, the internal cache of schemas is
+# cleared after validation (otherwise schemas are cached for efficiency)
+#
+
+File.write("schema.json", v2_schema.to_json)
+
+# => true
+JSON::Validator.validate("schema.json", {})
+
+File.write("schema.json", schema.to_json)
+
+# => true
+JSON::Validator.validate("schema.json", {}, :clear_cache => true)
+
+# => false
+JSON::Validator.validate("schema.json", {})
+```
+
+Extending Schemas
+-----------------
+
+For this example, we are going to extend the [JSON Schema Draft
+3](http://tools.ietf.org/html/draft-zyp-json-schema-03) specification by adding
+a 'bitwise-and' property for validation.
+
+```ruby
+require "json-schema"
+
+class BitwiseAndAttribute < JSON::Schema::Attribute
+  def self.validate(current_schema, data, fragments, processor, validator, options = {})
+    if data.is_a?(Integer) && data & current_schema.schema['bitwise-and'].to_i == 0
+      message = "The property '#{build_fragment(fragments)}' did not evaluate  to true when bitwise-AND'd with  #{current_schema.schema['bitwise-or']}"
+      validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+    end
+  end
+end
+
+class ExtendedSchema < JSON::Schema::Draft3
+  def initialize
+    super
+    @attributes["bitwise-and"] = BitwiseAndAttribute
+    @uri = JSON::Util::URI.parse("http://test.com/test.json")
+    @names = ["http://test.com/test.json"]
+  end
+
+  JSON::Validator.register_validator(self.new)
+end
+
+schema = {
+  "$schema" => "http://test.com/test.json",
+  "properties" => {
+    "a" => {
+      "bitwise-and" => 1
+    },
+    "b" => {
+      "type" => "string"
+    }
+  }
+}
+
+data = {
+  "a" => 0
+}
+
+data = {"a" => 1, "b" => "taco"}
+JSON::Validator.validate(schema,data) # => true
+data = {"a" => 1, "b" => 5}
+JSON::Validator.validate(schema,data) # => false
+data = {"a" => 0, "b" => "taco"}
+JSON::Validator.validate(schema,data) # => false
+```
+
+Custom format validation
+------------------------
+
+The JSON schema standard allows custom formats in schema definitions which
+should be ignored by validators that do not support them. JSON::Schema allows
+registering procs as custom format validators which receive the value to be
+checked as parameter and must raise a `JSON::Schema::CustomFormatError` to
+indicate a format violation. The error message will be prepended by the property
+name, e.g. [The property '#a']()
+
+```ruby
+require "json-schema"
+
+format_proc = -> value {
+  raise JSON::Schema::CustomFormatError.new("must be 42") unless value == "42"
+}
+
+# register the proc for format 'the-answer' for draft4 schema
+JSON::Validator.register_format_validator("the-answer", format_proc, ["draft4"])
+
+# omitting the version parameter uses ["draft1", "draft2", "draft3", "draft4"] as default
+JSON::Validator.register_format_validator("the-answer", format_proc)
+
+# deregistering the custom validator
+# (also ["draft1", "draft2", "draft3", "draft4"] as default version)
+JSON::Validator.deregister_format_validator('the-answer', ["draft4"])
+
+# shortcut to restore the default formats for validators (same default as before)
+JSON::Validator.restore_default_formats(["draft4"])
+
+# with the validator registered as above, the following results in
+# ["The property '#a' must be 42"] as returned errors
+schema = {
+  "$schema" => "http://json-schema.org/draft-04/schema#",
+  "properties" => {
+    "a" => {
+      "type" => "string",
+      "format" => "the-answer",
+    }
+  }
+}
+errors = JSON::Validator.fully_validate(schema, {"a" => "23"})
+```
+
+Validating a JSON Schema
+------------------------
+
+To validate that a JSON Schema conforms to the JSON Schema standard,
+you need to validate your schema against the metaschema for the appropriate
+JSON Schema Draft. All of the normal validation methods can be used
+for this. First retrieve the appropriate metaschema from the internal
+cache (using `JSON::Validator.validator_for_name()` or
+`JSON::Validator.validator_for_uri()`) and then simply validate your
+schema against it.
+
+
+```ruby
+require "json-schema"
+
+schema = {
+  "type" => "object",
+  "properties" => {
+    "a" => {"type" => "integer"}
+  }
+}
+
+metaschema = JSON::Validator.validator_for_name("draft4").metaschema
+# => true
+JSON::Validator.validate(metaschema, schema)
+```
+
+Controlling Remote Schema Reading
+---------------------------------
+
+In some cases, you may wish to prevent the JSON Schema library from making HTTP
+calls or reading local files in order to resolve `$ref` schemas. If you fully
+control all schemas which should be used by validation, this could be
+accomplished by registering all referenced schemas with the validator in
+advance:
+
+```ruby
+schema = JSON::Schema.new(some_schema_definition, Addressable::URI.parse('http://example.com/my-schema'))
+JSON::Validator.add_schema(schema)
+```
+
+If more extensive control is necessary, the `JSON::Schema::Reader` instance used
+can be configured in a few ways:
+
+```ruby
+# Change the default schema reader used
+JSON::Validator.schema_reader = JSON::Schema::Reader.new(:accept_uri => true, :accept_file => false)
+
+# For this validation call, use a reader which only accepts URIs from my-website.com
+schema_reader = JSON::Schema::Reader.new(
+  :accept_uri => proc { |uri| uri.host == 'my-website.com' }
+)
+JSON::Validator.validate(some_schema, some_object, :schema_reader => schema_reader)
+```
+
+The `JSON::Schema::Reader` interface requires only an object which responds to
+`read(string)` and returns a `JSON::Schema` instance. See the [API
+documentation](http://www.rubydoc.info/github/ruby-json-schema/json-schema/master/JSON/Schema/Reader)
+for more information.
+
+JSON Backends
+-------------
+
+The JSON Schema library currently supports the `json` and `yajl-ruby` backend
+JSON parsers. If either of these libraries are installed, they will be
+automatically loaded and used to parse any JSON strings supplied by the user.
+
+If more than one of the supported JSON backends are installed, the `yajl-ruby`
+parser is used by default. This can be changed by issuing the following before
+validation:
+
+```ruby
+JSON::Validator.json_backend = :json
+```
+
+Optionally, the JSON Schema library supports using the MultiJSON library for
+selecting JSON backends. If the MultiJSON library is installed, it will be
+autoloaded.
+
+Notes
+-----
+
+The 'format' attribute is only validated for the following values:
+
+- date-time
+- date
+- time
+- ip-address (IPv4 address in draft1, draft2 and draft3)
+- ipv4 (IPv4 address in draft4)
+- ipv6
+- uri
+
+All other 'format' attribute values are simply checked to ensure the instance
+value is of the correct datatype (e.g., an instance value is validated to be an
+integer or a float in the case of 'utc-millisec').
+
+Additionally, JSON::Validator does not handle any json hyperschema attributes.
+
+# Transfer Notice
+
+This plugin was originally authored by [Iain Beeston](https://github.com/iainbeeston).
+The maintainer preferred that [Vox Pupuli](https://voxpupuli.org/) take ownership of the module for future improvement and maintenance.
+Existing pull requests and issues were transferred, please fork and continue to contribute [here](https://github.com/voxpupuli/json-schema).
+
+# License
+
+This gem is licensed unter the [MIT license](LICENSE.md).
+
+## Release information
+
+To make a new release, please do:
+* update the version in VERSION.yml
+* Install gems with `bundle install --with release --path .vendor`
+* generate the changelog with `bundle exec rake changelog`
+* Check if the new version matches the closed issues/PRs in the changelog
+* Create a PR with it
+* After it got merged, push a tag. GitHub actions will do the actual release to rubygems and GitHub Packages

data/lib/json-schema/attribute.rb

@@ -0,0 +1,57 @@
+require 'json-schema/errors/validation_error'
+
+module JSON
+  class Schema
+    class Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+      end
+
+      def self.build_fragment(fragments)
+        "#/#{fragments.join('/')}"
+      end
+
+      def self.validation_error(processor, message, fragments, current_schema, failed_attribute, record_errors)
+        error = ValidationError.new(message, fragments, failed_attribute, current_schema)
+        if record_errors
+          processor.validation_error(error)
+        else
+          raise error
+        end
+      end
+
+      def self.validation_errors(validator)
+        validator.validation_errors
+      end
+
+      TYPE_CLASS_MAPPINGS = {
+        "string" => String,
+        "number" => Numeric,
+        "integer" => Integer,
+        "boolean" => [TrueClass, FalseClass],
+        "object" => Hash,
+        "array" => Array,
+        "null" => NilClass,
+        "any" => Object
+      }
+
+      def self.data_valid_for_type?(data, type)
+        valid_classes = TYPE_CLASS_MAPPINGS.fetch(type) { return true }
+        Array(valid_classes).any? { |c| data.is_a?(c) }
+      end
+
+      # Lookup Schema type of given class instance
+      def self.type_of_data(data)
+        type, _ = TYPE_CLASS_MAPPINGS.map { |k,v| [k,v] }.sort_by { |(_, v)|
+          -Array(v).map { |klass| klass.ancestors.size }.max
+        }.find { |(_, v)|
+          Array(v).any? { |klass| data.kind_of?(klass) }
+        }
+        type
+      end
+
+      def self.validate_on_false?
+        true
+      end
+    end
+  end
+end

data/lib/json-schema/attributes/additionalitems.rb

@@ -0,0 +1,28 @@
+require 'json-schema/attribute'
+
+module JSON
+  class Schema
+    class AdditionalItemsAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        return unless data.is_a?(Array)
+
+        schema = current_schema.schema
+        return unless schema['items'].is_a?(Array)
+
+        case schema['additionalItems']
+        when false
+          if schema['items'].length < data.length
+            message = "The property '#{build_fragment(fragments)}' contains additional array elements outside of the schema when none are allowed"
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+          end
+        when Hash
+          additional_items_schema = JSON::Schema.new(schema['additionalItems'], current_schema.uri, validator)
+          data.each_with_index do |item, i|
+            next if i < schema['items'].length
+            additional_items_schema.validate(item, fragments + [i.to_s], processor, options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json-schema/attributes/additionalproperties.rb

@@ -0,0 +1,58 @@
+require 'json-schema/attribute'
+require 'json-schema/attributes/extends'
+
+module JSON
+  class Schema
+    class AdditionalPropertiesAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        schema = current_schema.schema
+        return unless data.is_a?(Hash) && (schema['type'].nil? || schema['type'] == 'object')
+
+        extra_properties = remove_valid_properties(data.keys, current_schema, validator)
+
+        addprop = schema['additionalProperties']
+        if addprop.is_a?(Hash)
+          matching_properties = extra_properties # & addprop.keys
+          matching_properties.each do |key|
+            additional_property_schema = JSON::Schema.new(addprop, current_schema.uri, validator)
+            additional_property_schema.validate(data[key], fragments + [key], processor, options)
+          end
+          extra_properties -= matching_properties
+        end
+
+        if extra_properties.any? && (addprop == false || (addprop.is_a?(Hash) && !addprop.empty?))
+          message = "The property '#{build_fragment(fragments)}' contains additional properties #{extra_properties.inspect} outside of the schema when none are allowed"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+        end
+      end
+
+      def self.remove_valid_properties(extra_properties, current_schema, validator)
+        schema = current_schema.schema
+
+        if schema['properties']
+          extra_properties = extra_properties - schema['properties'].keys
+        end
+
+        if schema['patternProperties']
+          schema['patternProperties'].each_key do |key|
+            regexp = Regexp.new(key)
+            extra_properties.reject! { |prop| regexp.match(prop) }
+          end
+        end
+
+        if extended_schemas = schema['extends']
+          extended_schemas = [extended_schemas] unless extended_schemas.is_a?(Array)
+          extended_schemas.each do |schema_value|
+            _, extended_schema = JSON::Schema::ExtendsAttribute.get_extended_uri_and_schema(schema_value, current_schema, validator)
+            if extended_schema
+              extra_properties = remove_valid_properties(extra_properties, extended_schema, validator)
+            end
+          end
+        end
+
+        extra_properties
+      end
+
+    end
+  end
+end