NAME

       Kwalify - Kwalify schema for data structures

SYNOPSIS

         use Kwalify qw(validate);
         validate($schema, $data);

       Typically used together with YAML or JSON:

         use YAML;
         validate(YAML::LoadFile($schema_file), YAML::LoadFile($data_file));

         use JSON;
         validate(decode_json($schema_data), decode_json($data));

DESCRIPTION

       Kwalify is a Perl implementation for validating data structures against the Kwalify schema. For a schema
       definition, see
       <https://web.archive.org/web/20190718083758/http://www.kuwata-lab.com/kwalify/ruby/users-guide.01.html>,
       but see also below "SCHEMA DEFINITION".

   validate($schema_data, $data)
       Validate $data according to Kwalify schema specified in $schema_data. Dies if the validation fails.

       validate may be exported.

SCHEMA DEFINITION

       The original schema definition document is not very specific about types and behaviour. Here's how
       Kwalify.pm implements things:

       name
           The name of the schema.

       desc
           The description for the rule.  It is not used for validation.

       pattern
           A pattern matching the valid values.

           Perl  regular expressions are used for patterns. This may or may not be compatible with other Kwalify
           validators, so restrict to "simple"  regular  expression  constructs  to  be  compatible  with  other
           validators.

       enum
           A list of the valid values.

       range
           A hash with the valid value ranges for types other than seq, map, bool and any.

           max The maximum inclusive.

           min The minimum inclusive.

           max-ex
               The maximum exclusive.

           min-ex
               The minimum exclusive.

       length
           Like range but for str and text.

       required
           A constraint to denote the value is required when true.  The default is false.

       type
           The default type if omitted is str.

           str Any defined value which is not a number. Most probably you will want to use text instead of str.

           int A  possibly  signed  integer.  Note that scientific notation is not supported, and it is also not
               clear whether it should be supported.

           float
               A possibly signed floating value with a mandatory decimal point. Note that scientific notation is
               also not supported here.

           number
               A possibly signed floating value with an optional decimal point (so either int or  float).   Note
               that scientific notation is also not supported here.

           text
               Any defined value which is either a str or a number.

           bool
               The  values yes, true, and 1 for true values and the values no, false, and 0 for false values are
               allowed. The ruby implementation possibly allows more values, but this is not documented.

               Note that this definition is problematic, because for example the string no  is  a  true  boolean
               value  in  Perl. So one should stick to 0 and 1 as data values, and probably define an additional
               pattern or enum to ensure this:

                   type: bool
                   enum: [0, 1]

           date
               A string matching "/^\d{4}-\d{2}-\d{2}$/" (i.e. YYYY-MM-DD). Note that no date range  checks  are
               done (yet).

           time
               A  string  matching  "/^\d{2}:\d{2}:\d{2}$/"  (i.e. HH:MM:SS). Note that no time range checks are
               done (yet).

           timestamp
               Not supported --- it is not clear what this is supposed to be.

           seq A sequence (list) of rules.

           map A mapping (hash) of rules.

               The name "=" can be used to apply rules to any key.

           scalar
               Currently the same as text, but it's not clear if this is correct.  Originally defined as all but
               seq and map.

           any Any data type.

       unique
           The value is unique for a seq or a map.

       assert
           Currently not supported by the Perl implementation.

       classname
           Previously           defined           what           is           now           class,           see
           <https://web.archive.org/web/20190718083758/http://www.kuwata-lab.com/kwalify/ruby/users-guide.01.html>.

       class
           Currently not used, as there's no genclass action.

       default
           Currently not used, as there's no genclass action.

TECHNICAL NOTES

       As  Kwalify.pm  is  a pure validator and de-coupled from a parser (in fact, it does not need to deal with
       YAML at all, but just with pure perl data structures), there's no connection to  the  original  validated
       document.  This  means  that no line numbers are available to the validator. In case of validation errors
       the validator is only able to show a path-like expression to the data causing the error.

AUTHOR

       Slaven Rezić, <srezic@cpan.org>

COPYRIGHT AND LICENSE

       Copyright (C) 2006,2007,2008,2009,2010,2015 by Slaven Rezić

       This library is free software; you can redistribute it and/or modify it under  the  same  terms  as  Perl
       itself.

SEE ALSO

       pkwalify, kwalify(1).

       Other non-XML schema languages: <http://rx.codesimply.com/>

perl v5.38.2                                       2024-07-28                                       Kwalify(3pm)