npm 中文文档

Ruby JSON Schema Validator


Test Release

This library is intended to provide Ruby with an interface for validating JSON objects against a JSON schema conforming to JSON Schema Draft6. Legacy support for JSON Schema Draft 4, JSON Schema Draft 3, JSON Schema Draft 2, and JSON Schema Draft 1 is also included.

Additional Resources


Google Groups
#voxpupuli on irc.libera.chat

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.

Version 3.0.0 Upgrade Notes


All individual changes are documented in the CHANGELOG.md. The biggest change is that the new version only supports Ruby 2.5 and newer. Take a look into the gemspec file to see the currently supported Ruby version and also .github/workflows/test.yml to see the Ruby versions we test on.

Installation


From rubygems.org:

  1. ``` shell
  2. gem install json-schema
  3. ```

From the git repo:

  1. ``` shell
  2. gem build json-schema.gemspec
  3. gem install json-schema-*.gem
  4. ```

Validation


Three base validation methods exist:

validate : returns a boolean on whether a validation attempt passes
validate! : throws a JSON::Schema::ValidationError with an appropriate message/trace on where the validation failed
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 Draft4 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 UnderstandingJSON Schema.

Basic Usage


  1. ``` ruby
  2. require "json-schema"

  4. schema = {
  5.   "type" => "object",
  6.   "required" => ["a"],
  7.   "properties" => {
  8.     "a" => {"type" => "integer"}
  9.   }
  10. }

  12. #
  13. # validate ruby objects against a ruby schema
  14. #

  16. # => true
  17. JSON::Validator.validate(schema, { "a" => 5 })
  18. # => false
  19. JSON::Validator.validate(schema, {})

  21. #
  22. # validate a json string against a json schema file
  23. #

  25. require "json"
  26. File.write("schema.json", JSON.dump(schema))

  28. # => true
  29. JSON::Validator.validate('schema.json', '{ "a": 5 }')

  31. #
  32. # raise an error when validation fails
  33. #

  35. # => "The property '#/a' of type String did not match the following type: integer"
  36. begin
  37.   JSON::Validator.validate!(schema, { "a" => "taco" })
  38. rescue JSON::Schema::ValidationError => e
  39.   e.message
  40. end

  42. #
  43. # return an array of error messages when validation fails
  44. #

  46. # => ["The property '#/a' of type String did not match the following type: integer in schema 18a1ffbb-4681-5b00-bd15-2c76aee4b28f"]
  47. JSON::Validator.fully_validate(schema, { "a" => "taco" })
  48. ```

Advanced Options


  1. ``` ruby
  2. require "json-schema"

  4. schema = {
  5.   "type"=>"object",
  6.   "required" => ["a"],
  7.   "properties" => {
  8.     "a" => {
  9.       "type" => "integer",
  10.       "default" => 42
  11.     },
  12.     "b" => {
  13.       "type" => "object",
  14.       "properties" => {
  15.         "x" => {
  16.           "type" => "integer"
  17.         }
  18.       }
  19.     }
  20.   }
  21. }

  23. #
  24. # with the `:list` option, a list can be validated against a schema that represents the individual objects
  25. #

  27. # => true
  28. JSON::Validator.validate(schema, [{"a" => 1}, {"a" => 2}, {"a" => 3}], :list => true)
  29. # => false
  30. JSON::Validator.validate(schema, [{"a" => 1}, {"a" => 2}, {"a" => 3}])

  32. #
  33. # with the `:errors_as_objects` option, `#fully_validate` returns errors as hashes instead of strings
  34. #

  36. # => [{: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"}]
  37. JSON::Validator.fully_validate(schema, { "a" => "taco" }, :errors_as_objects => true)

  39. #
  40. # with the `:strict` option, all properties are considered to have `"required": true` and all objects `"additionalProperties": false`
  41. #

  43. # => true
  44. JSON::Validator.validate(schema, { "a" => 1, "b" => { "x" => 2 } }, :strict => true)
  45. # => false
  46. JSON::Validator.validate(schema, { "a" => 1, "b" => { "x" => 2 }, "c" => 3 }, :strict => true)
  47. # => false
  48. JSON::Validator.validate(schema, { "a" => 1 }, :strict => true)

  50. #
  51. # with the `:fragment` option, only a fragment of the schema is used for validation
  52. #

  54. # => true
  55. JSON::Validator.validate(schema, { "x" => 1 }, :fragment => "#/properties/b")
  56. # => false
  57. JSON::Validator.validate(schema, { "x" => 1 })

  59. #
  60. # with the `:validate_schema` option, the schema is validated (against the json schema spec) before the json is validated (against the specified schema)
  61. #

  63. # => true
  64. JSON::Validator.validate(schema, { "a" => 1 }, :validate_schema => true)
  65. # => false
  66. JSON::Validator.validate({ "required" => true }, { "a" => 1 }, :validate_schema => true)

  68. #
  69. # 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
  70. #

  72. # => true
  73. JSON::Validator.validate(schema, {}, :insert_defaults => true)
  74. # => false
  75. JSON::Validator.validate(schema, {})

  77. #
  78. # with the `:version` option, schemas conforming to older drafts of the json schema spec can be used
  79. #

  81. v2_schema = {
  82.   "type" => "object",
  83.   "properties" => {
  84.     "a" => {
  85.       "type" => "integer"
  86.     }
  87.   }
  88. }

  90. # => false
  91. JSON::Validator.validate(v2_schema, {}, :version => :draft2)
  92. # => true
  93. JSON::Validator.validate(v2_schema, {})

  95. #
  96. # 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)
  97. #

  99. # => true
  100. JSON::Validator.validate(schema, { "a" => 1 }, :parse_data => false)
  101. # => false
  102. JSON::Validator.validate(schema, '{ "a": 1 }', :parse_data => false)

  104. #
  105. # with the `:json` option, the json must be an unparsed json text (not a hash, a uri or a file path)
  106. #

  108. # => true
  109. JSON::Validator.validate(schema, '{ "a": 1 }', :json => true)
  110. # => "no implicit conversion of Hash into String"
  111. begin
  112.   JSON::Validator.validate(schema, { "a" => 1 }, :json => true)
  113. rescue TypeError => e
  114.   e.message
  115. end

  117. #
  118. # with the `:uri` option, the json must be a uri or file path (not a hash or a json text)
  119. #

  121. File.write("data.json", '{ "a": 1 }')

  123. # => true
  124. JSON::Validator.validate(schema, "data.json", :uri => true)
  125. # => "Can't convert Hash into String."
  126. begin
  127.   JSON::Validator.validate(schema, { "a"  => 1 }, :uri => true)
  128. rescue TypeError => e
  129.   e.message
  130. end

  132. #
  133. # with the `:clear_cache` option set to true, the internal cache of schemas is
  134. # cleared after validation (otherwise schemas are cached for efficiency)
  135. #

  137. File.write("schema.json", v2_schema.to_json)

  139. # => true
  140. JSON::Validator.validate("schema.json", {})

  142. File.write("schema.json", schema.to_json)

  144. # => true
  145. JSON::Validator.validate("schema.json", {}, :clear_cache => true)

  147. # => false
  148. JSON::Validator.validate("schema.json", {})
  149. ```

Extending Schemas


For this example, we are going to extend the JSON Schema Draft3 specification by adding a 'bitwise-and' property for validation.

  1. ``` ruby
  2. require "json-schema"

  4. class BitwiseAndAttribute < JSON::Schema::Attribute
  5.   def self.validate(current_schema, data, fragments, processor, validator, options = {})
  6.     if data.is_a?(Integer) && data & current_schema.schema['bitwise-and'].to_i == 0
  7.       message = "The property '#{build_fragment(fragments)}' did not evaluate  to true when bitwise-AND'd with  #{current_schema.schema['bitwise-or']}"
  8.       validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
  9.     end
  10.   end
  11. end

  13. class ExtendedSchema < JSON::Schema::Draft3
  14.   def initialize
  15.     super
  16.     @attributes["bitwise-and"] = BitwiseAndAttribute
  17.     @uri = JSON::Util::URI.parse("http://test.com/test.json")
  18.     @names = ["http://test.com/test.json"]
  19.   end

  21.   JSON::Validator.register_validator(self.new)
  22. end

  24. schema = {
  25.   "$schema" => "http://test.com/test.json",
  26.   "properties" => {
  27.     "a" => {
  28.       "bitwise-and" => 1
  29.     },
  30.     "b" => {
  31.       "type" => "string"
  32.     }
  33.   }
  34. }

  36. data = {
  37.   "a" => 0
  38. }

  40. data = {"a" => 1, "b" => "taco"}
  41. JSON::Validator.validate(schema,data) # => true
  42. data = {"a" => 1, "b" => 5}
  43. JSON::Validator.validate(schema,data) # => false
  44. data = {"a" => 0, "b" => "taco"}
  45. JSON::Validator.validate(schema,data) # => false
  46. ```

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'

  1. ``` ruby
  2. require "json-schema"

  4. format_proc = -> value {
  5.   raise JSON::Schema::CustomFormatError.new("must be 42") unless value == "42"
  6. }

  8. # register the proc for format 'the-answer' for draft4 schema
  9. JSON::Validator.register_format_validator("the-answer", format_proc, ["draft4"])

  11. # omitting the version parameter uses ["draft1", "draft2", "draft3", "draft4"] as default
  12. JSON::Validator.register_format_validator("the-answer", format_proc)

  14. # deregistering the custom validator
  15. # (also ["draft1", "draft2", "draft3", "draft4"] as default version)
  16. JSON::Validator.deregister_format_validator('the-answer', ["draft4"])

  18. # shortcut to restore the default formats for validators (same default as before)
  19. JSON::Validator.restore_default_formats(["draft4"])

  21. # with the validator registered as above, the following results in
  22. # ["The property '#a' must be 42"] as returned errors
  23. schema = {
  24.   "$schema" => "http://json-schema.org/draft-04/schema#",
  25.   "properties" => {
  26.     "a" => {
  27.       "type" => "string",
  28.       "format" => "the-answer",
  29.     }
  30.   }
  31. }
  32. errors = JSON::Validator.fully_validate(schema, {"a" => "23"})
  33. ```

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.

  1. ``` ruby
  2. require "json-schema"

  4. schema = {
  5.   "type" => "object",
  6.   "properties" => {
  7.     "a" => {"type" => "integer"}
  8.   }
  9. }

  11. metaschema = JSON::Validator.validator_for_name("draft4").metaschema
  12. # => true
  13. JSON::Validator.validate(metaschema, schema)
  14. ```

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:

  1. ``` ruby
  2. schema = JSON::Schema.new(some_schema_definition, Addressable::URI.parse('http://example.com/my-schema'))
  3. JSON::Validator.add_schema(schema)
  4. ```

If more extensive control is necessary, the JSON::Schema::Reader instance used can be configured in a few ways:

  1. ``` ruby
  2. # Change the default schema reader used
  3. JSON::Validator.schema_reader = JSON::Schema::Reader.new(:accept_uri => true, :accept_file => false)

  5. # For this validation call, use a reader which only accepts URIs from my-website.com
  6. schema_reader = JSON::Schema::Reader.new(
  7.   :accept_uri => proc { |uri| uri.host == 'my-website.com' }
  8. )
  9. JSON::Validator.validate(some_schema, some_object, :schema_reader => schema_reader)
  10. ```

The JSON::Schema::Reader interface requires only an object which responds to read(string) and returns a JSON::Schema instance. See the APIdocumentation 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:

  1. ``` ruby
  2. JSON::Validator.json_backend = :json
  3. ```

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. The maintainer preferred that Vox Pupuli take ownership of the module for future improvement and maintenance. Existing pull requests and issues were transferred, please fork and continue to contribute here.

License


This gem is licensed unter the MIT license.

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