<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">NAME
    Data::Sah - Fast and featureful data structure validation

VERSION
    This document describes version 0.88 of Data::Sah (from Perl
    distribution Data-Sah), released on 2017-07-10.

SYNOPSIS
    Non-OO interface:

     use Data::Sah qw(
         normalize_schema
         gen_validator
     );

     my $v;

     # generate a validator for schema
     $v = gen_validator(["int*", min=&gt;1, max=&gt;10]);

     # validate your data using the generated validator
     say "valid" if $v-&gt;(5);     # valid
     say "valid" if $v-&gt;(11);    # invalid
     say "valid" if $v-&gt;(undef); # invalid
     say "valid" if $v-&gt;("x");   # invalid

     # generate validator which reports error message string
     $v = gen_validator(["int*", min=&gt;1, max=&gt;10],
                        {return_type=&gt;'str', lang=&gt;'id_ID'});
     # ditto but the error message will be in Indonesian
     $v = gen_validator(["int*", min=&gt;1, max=&gt;10],
                        {return_type=&gt;'str', lang=&gt;'id_ID'});
     say $v-&gt;(5);  # ''
     say $v-&gt;(12); # 'Data tidak boleh lebih besar dari 10'
                   # (in English: 'Data must not be larger than 10')

     # normalize a schema
     my $nschema = normalize_schema("int*"); # =&gt; ["int", {req=&gt;1}, {}]
     normalize_schema(["int*", min=&gt;0]); # =&gt; ["int", {min=&gt;0, req=&gt;1}, {}]

    OO interface (more advanced usage):

     use Data::Sah;
     my $sah = Data::Sah-&gt;new;

     # get perl compiler
     my $pl = $sah-&gt;get_compiler("perl");

     # compile schema into Perl code
     my $cd = $pl-&gt;compile(schema =&gt; ["int*", min=&gt;0]);
     say $cd-&gt;{result};

    will print something like:

     # req #0
     (defined($data))
     &amp;&amp;
     # check type 'int'
     (Scalar::Util::Numeric::isint($data))
     &amp;&amp;
     (# clause: min
     ($data &gt;= 0))

    To see the full validator code (with "sub {}" and all), you can do
    something like:

     % LOG_SAH_VALIDATOR_CODE=1 TRACE=1 perl -MLog::ger::LevelFromEnv -MLog::ger::Output=Screen -MData::Sah=gen_validator -E'gen_validator(["int*", min=&gt;0])'

    which will print log message like:

     normalized schema=['int',{min =&gt; 0,req =&gt; 1},{}]
     validator code:
        1|do {
        2|    require Scalar::Util::Numeric;
        3|    sub {
        4|        my ($data) = @_;
        5|        my $_sahv_res =
         |
        7|            # req #0
        8|            (defined($data))
         |
       10|            &amp;&amp;
         |
       12|            # check type 'int'
       13|            (Scalar::Util::Numeric::isint($data))
         |
       15|            &amp;&amp;
         |
       17|            (# clause: min
       18|            ($data &gt;= 0));
         |
       20|        return($_sahv_res);
       21|    }}

DESCRIPTION
    This distribution, "Data-Sah", implements compilers for producing Perl
    and JavaScript validators, as well as translatable human description
    text from Sah schemas. Compiler approach is used instead of interpreter
    for faster speed.

    The generated validator code can run without the "Data::Sah::*" modules.

STATUS
    Some features are not implemented yet:

    *   def/subschema

    *   expression

    *   obj: meths, attrs properties

    *   .prio, .err_msg, .ok_err_msg attributes

    *   .result_var attribute

    *   BaseType: if, prefilters, postfilters, check, prop, check_prop
        clauses

    *   HasElems: each_index, check_each_elem, check_each_index, exists
        clauses

    *   HasElems: len, elems, indices properties

    *   hash: check_each_key, check_each_value, allowed_keys_re,
        forbidden_keys_re clauses

    *   array: uniq clauses

    *   human compiler: markdown output

VARIABLES
  $Log_Validator_Code (bool, default: 0)
MODULE ORGANIZATION
    Data::Sah::Type::* roles specify Sah types, e.g. "Data::Sah::Type::bool"
    specifies the bool type. It can also be used to name distributions that
    introduce new types, e.g. "Data-Sah-Type-complex" which introduces
    complex number type.

    Data::Sah::FuncSet::* roles specify bundles of functions, e.g.
    &lt;Data::Sah::FuncSet::Core&gt; specifies the core/standard functions.

    Data::Sah::Compiler::$LANG:: namespace is for compilers. Each compiler
    might further contain "::TH::*" (type handler) and "::FSH::*" (function
    handler) subnamespaces to implement appropriate functionalities, e.g.
    Data::Sah::Compiler::perl::TH::bool is the bool type handler for the
    Perl compiler, Data::Sah::Compiler::perl::FSH::Core is the Core funcset
    handler for Perl compiler.

    Data::Sah::Coerce::$LANG::$TARGET_TYPE::$SOURCE_TYPE_AND_EXTRA_DESCRIPTI
    ON contains coercion rules.

    Data::Sah::TypeX::$TYPENAME::$CLAUSENAME namespace can be used to name
    distributions that extend an existing Sah type by introducing a new
    clause for it. See Data::Sah::Manual::Extending for an example.

    Data::Sah::Lang::$LANGCODE namespaces are for modules that contain
    translations. They are further organized according to the organization
    of other Data::Sah modules, e.g. Data::Sah::Lang::en_US::Type::int or
    "Data::Sah::Lang::en_US::TypeX::str::is_palindrome".

    Sah::Schema:: namespace is reserved for modules that contain bundles of
    schemas. For example, "Sah::Schema::CPANMeta" contains the schema to
    validate CPAN META.yml. Sah::Schema::Int contains various schemas for
    integers such as "pos_int", "int8", "uint32". Sah::Schema::Sah contains
    the schema for Sah schema itself.

FUNCTIONS
    None exported by default.

  normalize_schema($schema) =&gt; ARRAY
    Normalize $schema.

    Can also be used as a method.

  gen_validator($schema, \%opts) =&gt; CODE (or STR)
    Generate validator code for $schema. Can also be used as a method. Known
    options (unknown options will be passed to Perl schema compiler):

    *   accept_ref =&gt; BOOL (default: 0)

        Normally the generated validator accepts data, as in:

         $res = $vdr-&gt;($data);
         $res = $vdr-&gt;(42);

        If this option is set to true, validator accepts reference to data
        instead, as in:

         $res = $vdr-&gt;(\$data);

        This allows $data to be modified by the validator (mainly, to set
        default value specified in schema). For example:

         my $data;
         my $vdr = gen_validator([int =&gt; {min=&gt;0, max=&gt;10, default=&gt;5}],
                                 {accept_ref=&gt;1});
         my $res = $vdr-&gt;(\$data);
         say $res;  # =&gt; 1 (success)
         say $data; # =&gt; 5

    *   source =&gt; BOOL (default: 0)

        If set to 1, return source code string instead of compiled
        subroutine. Usually only needed for debugging (but see also
        $Log_Validator_Code and "LOG_SAH_VALIDATOR_CODE" if you want to log
        validator source code).

ATTRIBUTES
  compilers =&gt; HASH
    A mapping of compiler name and compiler ("Data::Sah::Compiler::*")
    objects.

METHODS
  new() =&gt; OBJ
    Create a new Data::Sah instance.

  $sah-&gt;get_compiler($name) =&gt; OBJ
    Get compiler object. "Data::Sah::Compiler::$name" will be loaded first
    and instantiated if not already so. After that, the compiler object is
    cached.

    Example:

     my $plc = $sah-&gt;get_compiler("perl"); # loads Data::Sah::Compiler::perl

  $sah-&gt;normalize_schema($schema) =&gt; HASH
    Normalize a schema, e.g. change "int*" into "[int =&gt; {req=&gt;1}]", as well
    as do some sanity checks on it. Returns the normalized schema if
    succeeds, or dies on error.

    Can also be used as a function.

    Note: this functionality is implemented in Data::Sah::Normalize
    (distributed separately in Data-Sah-Normalize). Use that module instead
    if you just need normalizing schemas, to reduce dependencies.

  $sah-&gt;normalize_clset($clset[, \%opts]) =&gt; HASH
    Normalize a clause set, e.g. change "{"!match"=&gt;"abc"}" into
    "{"match"=&gt;"abc", "match.op"=&gt;"not"}". Produce a shallow copy of the
    input clause set hash.

    Can also be used as a function.

  $sah-&gt;normalize_var($var) =&gt; STR
    Normalize a variable name in expression into its fully
    qualified/absolute form.

    Not yet implemented (pending specification).

    For example:

     [int =&gt; {min =&gt; 10, 'max=' =&gt; '2*$min'}]

    $min in the above expression will be normalized as "schema:clauses.min".

  $sah-&gt;gen_validator($schema, \%opts) =&gt; CODE
    Use the Perl compiler to generate validator code. Can also be used as a
    function. See the documentation as a function for list of known options.

FAQ
    See also Sah::FAQ.

  Comparison to {JSON::Schema, Data::Rx, Data::FormValidator, ...}?
    See Sah::FAQ.

  Why is it so slow?
    You probably do not reuse the compiled schema, e.g. you continually
    destroy and recreate Data::Sah object, or repeatedly recompile the same
    schema. To gain the benefit of compilation, you need to keep the
    compiled result and use the generated Perl code repeatedly.

  Can I generate another schema dynamically from within the schema?
    For example:

     // if first element is an integer, require the array to contain only integers,
     // otherwise require the array to contain only strings.
     ["array", {"min_len": 1, "of=": "[is_int($_[0]) ? 'int':'str']"}]

    Currently no, Data::Sah does not support expression on clauses that
    contain other schemas. In other words, dynamically generated schemas are
    not supported. To support this, if the generated code needs to run
    independent of Data::Sah, it needs to contain the compiler code itself
    (or an interpreter) to compile or evaluate the generated schema.

    However, an "eval_schema()" Sah function which uses Data::Sah can be
    trivially declared and target the Perl compiler.

  How to display the validator code being generated?
    Use the "source =&gt; 1" option in "gen_validator()".

    If you use the OO interface, e.g.:

     # generate perl code
     my $cd = $plc-&gt;compile(schema=&gt;..., ...);

    then the generated code is in "$cd-&gt;{result}" and you can just print it.

    If you generate validator using "gen_validator()", you can set
    environment LOG_SAH_VALIDATOR_CODE or package variable
    $Log_Validator_Code to true and the generated code will be logged at
    trace level using Log::ger. The log can be displayed using, e.g.,
    Log::ger::Output::Screen:

     % LOG_SAH_VALIDATOR_CODE=1 TRACE=1 \
       perl -MLog::ger::LevelFromEnv -MLog::ger::Output=Screen \
       -MData::Sah=gen_validator -e '$sub = gen_validator([int =&gt; min=&gt;1, max=&gt;10])'

    Sample output:

     normalized schema=['int',{max =&gt; 10,min =&gt; 1},{}]
     schema already normalized, skipped normalization
     validator code:
        1|do {
        2|    require Scalar::Util::Numeric;
        3|    sub {
        4|        my ($data) = @_;
        5|        my $_sahv_res =
         |
        7|            # skip if undef
        8|            (!defined($data) ? 1 :
         |
       10|            (# check type 'int'
       11|            (Scalar::Util::Numeric::isint($data))
         |
       13|            &amp;&amp;
         |
       15|            (# clause: min
       16|            ($data &gt;= 1))
         |
       18|            &amp;&amp;
         |
       20|            (# clause: max
       21|            ($data &lt;= 10))));
         |
       23|        return($_sahv_res);
       24|    }}

    Lastly, you can also use validate-with-sah CLI utility from the
    App::SahUtils distribution (use the "--show-code" option).

  How to show the validation error message? The validator only returns true/false!
    Pass the "return_type=&gt;"str"" to get an error message string on error,
    or "return_type=&gt;"full"" to get a hash of detailed error messages. Note
    also that the error messages are translateable (e.g. use "LANG" or
    "lang=&gt;..." option. For example:

     my $v = gen_validator([int =&gt; between =&gt; [1,10]], {return_type=&gt;"str"});
     say "$_: ", $v-&gt;($_) for 1, "x", 12;

    will output:

     1:
     "x": Input is not of type integer
     12: Must be between 1 and 10

  How to show all the error and warning messages?
    If you pass "return_type=&gt;"full"" then the generated validator code can
    return a hashref containing all the errors (in the "errors" key) and
    warnings (in the "warnings" key) instead of just a boolean (when
    "return_type=&gt;"bool"") or a string containing the first encountered
    error message (when "return_type=&gt;"str"") .

  How to get the data value with the default filled in, or coercion done?
    If you use "return_type=&gt;"full"", the generated validator code will also
    return the input data after the default is filled in or coercion is done
    in the "value" key of the result hashref. Or, if you do not need a
    validator that checks for all errors/warnings, you can use
    "return_type=&gt;"bool+val"" or "return_type=&gt;"str+val"". For example:

     my $v = gen_validator(["date", {"x.perl.coerce_to"=&gt;"DateTime"}],
                           {return_type=&gt;"str+val"});

     my ($err, $val) = @{ $v-&gt;("2016-05-14") };

    The validator will return an error message string (or an empty string if
    validation succeeds) as well as the final value. In the example above,
    $val will contain a DateTime object. This is convenient because the
    final value is what is usually used further after validation process.

  What does the "@..." prefix that is sometimes shown on the error message mean?
    It shows the path to data item that fails the validation, e.g.:

     my $v = gen_validator([array =&gt; of =&gt; [int=&gt;min=&gt;5], {return_type=&gt;"str"});
     say $v-&gt;([10, 5, "x"]);

    prints:

     @[2]: Input is not of type integer

    which means that the third element (subscript 2) of the array fails the
    validation. Another example:

     my $v = gen_validator([array =&gt; of =&gt; [hash=&gt;keys=&gt;{a=&gt;"int"}]]);
     say $v-&gt;([{}, {a=&gt;1.1}]);

    prints:

     @[1][a]: Input is not of type integer

    Note that for validator that returns full result hashref
    ("return_type=&gt;"full"") the error messages in the "errors" key are also
    keyed with data path, albeit in a slightly different format (i.e.
    slash-separated, e.g. 2 and "1/a") for easier parsing.

  How to show the process of validation by the compiled code?
    If you are generating Perl code from schema, you can pass "debug=&gt;1"
    option so the code contains logging (Log::ger-based) and other debugging
    information, which you can display. For example:

     % TRACE=1 perl -MLog::ger::LevelFromEnv -MLog::ger::Output=Screen \
       -MData::Sah=gen_validator -E'
       $v = gen_validator([array =&gt; of =&gt; [hash =&gt; {req_keys=&gt;["a"]}]],
                          {return_type=&gt;"str", debug=&gt;1});
       say "Validation result: ", $v-&gt;([{a=&gt;1}, "x"]);'

    will output:

     ...
     [spath=[]]skip if undef ...
     [spath=[]]check type 'array' ...
     [spath=['of']]clause: {"of":["hash",{"req_keys":["a"]}]} ...
     [spath=['of']]skip if undef ...
     [spath=['of']]check type 'hash' ...
     [spath=['of','req_keys']]clause: {"req_keys":["a"]} ...
     [spath=['of']]skip if undef ...
     [spath=['of']]check type 'hash' ...
     Validation result: [spath=of]@1: Input is not of type hash

  What else can I do with the compiled code?
    Data::Sah offers some options in code generation. Beside compiling the
    validator code into a subroutine, there are also some other options.
    Examples:

    *   Dist::Zilla::Plugin::Rinci::Validate

        This plugin inserts the generated code (without the "sub { ... }"
        wrapper) to validate the content of %args right before "#
        VALIDATE_ARG" or "# VALIDATE_ARGS" like below:

         $SPEC{foo} = {
             args =&gt; {
                 arg1 =&gt; { schema =&gt; ..., req=&gt;1 },
                 arg2 =&gt; { schema =&gt; ... },
             },
             ...
         };
         sub foo {
             my %args = @_; # VALIDATE_ARGS
         }

        The schemas will be retrieved from the Rinci metadata ($SPEC{foo}
        above). This means, subroutines in your built distribution will do
        argument validation.

    *   Perinci::Sub::Wrapper

        This module is part of the Perinci family. What the module does is
        basically wrap your subroutine with a wrapper code that can include
        validation code (among others). This is a convenient way to add
        argument validation to an existing subroutine/code.

ENVIRONMENT
  LOG_SAH_VALIDATOR_CODE =&gt; bool
    If set to true, will log (using Log::ger, at the trace level) the
    validator code being generated. See "SYNOPSIS" or "FAQ" for example on
    how to see this log message.

HOMEPAGE
    Please visit the project's homepage at
    &lt;https://metacpan.org/release/Data-Sah&gt;.

SOURCE
    Source repository is at &lt;https://github.com/perlancar/perl-Data-Sah&gt;.

BUGS
    Please report any bugs or feature requests on the bugtracker website
    &lt;https://rt.cpan.org/Public/Dist/Display.html?Name=Data-Sah&gt;

    When submitting a bug or request, please include a test-file or a patch
    to an existing test-file that illustrates the bug or desired feature.

SEE ALSO
   Other compiled validators
   Other interpreted validators
    Params::Validate is very fast, although minimal. Data::Rx, Kwalify,
    Data::Verifier, Data::Validator, JSON::Schema, Validation::Class.

    For Moo/Mouse/Moose stuffs: Moose type system, MooseX::Params::Validate,
    Type::Tiny, among others.

    Form-oriented: Data::FormValidator, FormValidator::Lite, among others.

AUTHOR
    perlancar &lt;perlancar@cpan.org&gt;

COPYRIGHT AND LICENSE
    This software is copyright (c) 2017, 2016, 2015, 2014, 2013, 2012 by
    perlancar@cpan.org.

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

</pre></body></html>