JSON::Validator::Util - Utility functions for JSON::Validator


JSON::Validator::Util is a package containing utility functions for JSON::Validator. Each of the "FUNCTIONS" can be imported.



  $str = data_checksum $any;

Will create a checksum for any data structure stored in $any.


  $str = data_section "Some::Module", "file.json";
  $str = data_section "Some::Module", "file.json", {encode => 'UTF-8'};

Same as "data_section" in Mojo::Loader, but will also look up the file in any inherited class.


  $str = data_type $any;
  $str = data_type $any, [@schemas];
  $str = data_type $any, [{type => "integer", ...}];

Returns the JSON type for $any. $str can be array, boolean, integer, null, number object or string. Note that a list of schemas need to be provided to differentiate between "integer" and "number".


  $bool = is_type $any, $class;
  $bool = is_type $any, $type; # $type = "ARRAY", "BOOL", "HASH", "NUM" ...

Checks if $any is a, or inherits from, $class or $type. Two special types can be checked:

  • BOOL

    Checks if $any is a boolean value. $any is considered boolean if it is an object inheriting from JSON::PP::Boolean or is another object that stringifies to "1" or "0".

  • NUM

    Checks if $any is indeed a number.


  $str = json_pointer $path, $append;

Will concat $append on to $path, but will also escape the two special characters "~" and "/" in $append.


  $content_type = negotiate_content_type($header, \@content_types);

This method can take a "Content-Type" or "Accept" header and find the closest matching content type in @content_types. @content_types can contain wildcards, meaning "*/*" will match anything.


  @errors = prefix_errors $prefix, @errors;

Consider this internal for now.


  $data       = schema_extract $any, $json_pointer;
  $data       = schema_extract $any, "/x/cool_beans/y";
  $collection = schema_extract $any, ["x", undef, "y"];
  schema_extract $any, $json_pointer, sub { my ($data, $json_pointer) = @_ };

The basic usage is to extract data from $any, using a $json_pointer - RFC 6901. It can however be used in a more complex way by passing in an array-ref, instead of a plain string. The array-ref can contain undef() values, will result in extracting any element on that point, regardsless of value. In that case a Mojo::Collection will be returned.

A callback can also be given. This callback will be called each time the $json_pointer matches some data, and will pass in the $json_pointer at that place.

In addition, if the $json_pointer points to a JSON::Validator::Ref at any point, the "$ref" will be followed, while if you used Mojo::JSON::Pointer, it would return either the JSON::Validator::Ref or undef().

Even though "schema_extract" has special capabilities for handling a JSON-Schema, it can be used for any data-structure, just like Mojo::JSON::Pointer.


  $str = schema_type $hash_ref;
  $str = schema_type $hash_ref, $any;

Looks at $hash_ref and tries to figure out what kind of type the schema represents. $str can be "array", "const", "number", "object", "string", or fallback to empty string if the correct type could not be figured out.

$any can be provided to double check the type, so if $hash_ref describes an "object", but $any is an array-ref, then $str will become an empty string. Example:

  # $str = "";
  $str = schema {additionalProperties => false}, [];

  # $str = "object"
  $str = schema {additionalProperties => false};
  $str = schema {additionalProperties => false}, {};

Note that this process is relatively slow, so it will make your validation faster if you specify "type". Both of the two below is valid, but the one with "type" will be faster.

  {"type": "object", "properties": {}} # Faster
  {"properties": {}}                   # Slower