NAME
    Mo::utils - Mo utilities.

SYNOPSIS
     use Mo::utils qw(check_angle check_array check_array_object check_array_required
             check_bool check_code check_isa check_length check_length_fix check_number
             check_number_min check_number_of_items check_number_range check_regexp
             check_required check_string check_string_begin check_strings);

     check_angle($self, $key);
     check_array($self, $key);
     check_array_object($self, $key, $class, $class_name);
     check_array_required($self, $key);
     check_bool($self, $key);
     check_code($self, $key);
     check_isa($self, $key, $class);
     check_length($self, $key, $max_length);
     check_length_fix($self, $key, $length);
     check_number($self, $key);
     check_number_min($self, $key, $min);
     check_number_of_items($self, $list_method, $item_method, $object_name, $item_name);
     check_number_range($self, $key, $min, $max);
     check_regexp($self, $key, $regexp);
     check_required($self, $key);
     check_string($self, $key, $string);
     check_string_begin($self, $key, $string_base);
     check_strings($self, $key, $strings_ar);

DESCRIPTION
    Mo utilities for checking of data objects.

SUBROUTINES
  "check_angle"
     check_angle($self, $key);

    *Since version 0.20.*

    Check parameter defined by $key which is number between 0 and 360.

    Put error if check isn't ok.

    Returns undef.

  "check_array"
     check_array($self, $key);

    *Since version 0.06.*

    Check parameter defined by $key which is reference to array.

    Put error if check isn't ok.

    Returns undef.

  "check_array_object"
     check_array_object($self, $key, $class, $class_name);

    *Since version 0.02. Described functionality since version 0.21.*

    Check parameter defined by $key which is reference to array with
    instances of some object type ($class). $class_name is used to error
    message.

    Put error if check isn't ok.

    Returns undef.

  "check_array_required"
     check_array_required($self, $key);

    *Since version 0.18. Described functionality since version 0.19.*

    Check parameter defined by $key which is reference to array for at least
    one value inside.

    Put error if check isn't ok.

    Returns undef.

  "check_bool"
     check_bool($self, $key);

    *Since version 0.06.*

    Check parameter defined by $key if value is bool or not.

    Put error if check isn't ok.

    Returns undef.

  "check_code"
     check_code($self, $key);

    *Since version 0.12.*

    Check parameter defined by $key which is code reference or no.

    Put error if check isn't ok.

    Returns undef.

  "check_isa"
     check_isa($self, $key, $class);

    *Since version 0.01. Described functionality since version 0.08.*

    Check parameter defined by $key which is instance of $class or no.

    Put error if check isn't ok.

    Returns undef.

  "check_length"
     check_length($self, $key, $max_length);

    *Since version 0.04. Described functionality since version 0.05.*

    Check length of value for parameter defined by $key. Maximum length is
    defined by $max_length.

    Put error if check isn't ok.

    Returns undef.

  "check_length_fix"
     check_length_fix($self, $key, $length);

    *Since version 0.22.*

    Check fixed length of value for parameter defined by $key. Length is
    defined by $length variable.

    Put error if check isn't ok.

    Returns undef.

  "check_number"
     check_number($self, $key);

    *Since version 0.01. Described functionality since version 0.26.*

    Check parameter defined by $key which is number (positive or negative)
    or no. Number could be integer, float, exponencial and negative.

    Put error if check isn't ok.

    Returns undef.

  "check_number_min"
     check_number_min($self, $key, $min);

    *Since version 0.25. Described functionality since version 0.26.*

    Check parameter defined by $key which is number greater than $min value.
    Number could be integer, float, exponencial and negative.

    Put error if check isn't ok.

    Returns undef.

  "check_number_of_items"
     check_number_of_items($self, $list_method, $item_method, $object_name, $item_name);

    *Since version 0.01.*

    Check amount of unique items defined by $item_method method value. List
    items via $list_method and get value via $item_method method.
    $object_name and $item_name are variables for error output.

    Put error if check isn't ok.

    Returns undef.

  "check_number_range"
     check_number_range($self, $key, $min, $max);

    *Since version 0.23. Described functionality since version 0.26.*

    Check if number defined by $key is in range between $min and $max.
    Number could be integer, float, exponencial and negative.

    Put error if check isn't ok.

    Returns undef.

  "check_regexp"
     check_regexp($self, $key, $regexp);

    *Since version 0.17.*

    Check parameter defined by $key via regular expression defined by
    c<$regexp>.

    Put error if check isn't ok.

    Returns undef.

  "check_required"
     check_required($self, $key);

    *Since version 0.01.*

    Check required parameter defined by $key.

    Put error if check isn't ok.

    Returns undef.

  "check_string"
     check_string($self, $key, $string);

    *Since version 0.24.*

    Check string defined by $key to expected value.

    Put error if check isn't ok.

    Returns undef.

  "check_string_begin"
     check_string_begin($self, $key, $string_base);

    *Since version 0.16.*

    Check parameter if it is correct string which begins with base.

    Put error if string base doesn't exist. Put error string base isn't
    present in string on begin.

    Returns undef.

  "check_strings"
     check_strings($self, $key, $strings_ar);

    *Since version 0.15.*

    Check parameter if it is correct string from strings list.

    Put error if strings definition is undef or not list of strings. Put
    error if check isn't ok.

    Returns undef.

ERRORS
     check_angle():
             From check_number():
                     Parameter '%s' must be a number.
                             Value: %s
             Parameter '%s' must be a number between 0 and 360.
                     Value: %s

     check_array():
             Parameter '%s' must be a array.
                     Value: %s
                     Reference: %s

     check_array_object():
             Parameter '%s' must be a array.
                     Value: %s
                     Reference: %s
             %s isn't '%s' object.
                     Value: %s
                     Reference: %s

     check_array_required():
             Parameter '%s' is required.
             Parameter '%s' must be a array.
                     Value: %s
                     Reference: %s
             Parameter '%s' with array must have at least one item.

     check_bool():
             Parameter '%s' must be a bool (0/1).
                     Value: %s

     check_code():
             Parameter '%s' must be a code.
                     Value: %s

     check_isa():
             Parameter '%s' must be a '%s' object.
                     Value: %s
                     Reference: %s

     check_length():
             Parameter '%s' has length greater than '%s'.
                     Value: %s

     check_length_fix():
             Parameter '%s' has length different than '%s'.
                     Value: %s

     check_number():
             Parameter '%s' must be a number.
                     Value: %s

     check_number_min():
             Parameter '%s' must be a number.
                     Value: %s
             Parameter '%s' must be greater than %s.
                     Value: %s

     check_number_of_items():
             %s for %s '%s' has multiple values.

     check_number_range():
             Parameter '%s' must be a number.
                     Value: %s
             Parameter '%s' must be a number between %s and %s.",
                     Value: %s

     check_regexp():
             Parameter '%s' must have defined regexp.
             Parameter '%s' does not match the specified regular expression.
                     String: %s
                     Regexp: %s

     check_required():
             Parameter '%s' is required.

     check_string():
             Parameter '%s' must have expected value.
                     Value: %s
                     Expected value: %s

     check_string_begin():
             Parameter '%s' must have defined string base.
             Parameter '%s' must begin with defined string base.
                     String: %s
                     String base: %s

     check_strings():
             Parameter '%s' must have strings definition.
             Parameter '%s' must have right string definition.
             Parameter '%s' must be one of defined strings.
                     String: %s
                     Possible strings: %s

EXAMPLE1
     use strict;
     use warnings;

     use Mo::utils qw(check_angle);

     my $self = {
             'key' => 10.1,
     };
     check_angle($self, 'key');

     # Print out.
     print "ok\n";

     # Output:
     # ok

EXAMPLE2
     use strict;
     use warnings;

     use Error::Pure;
     use Mo::utils qw(check_angle);

     $Error::Pure::TYPE = 'Error';

     my $self = {
             'key' => 400,
     };
     check_angle($self, 'key');

     # Print out.
     print "ok\n";

     # Output like:
     # #Error [..utils.pm:?] Parameter 'key' must be a number between 0 and 360.

EXAMPLE3
     use strict;
     use warnings;

     use Mo::utils qw(check_array);

     my $self = {
             'key' => ['foo'],
     };
     check_array($self, 'key');

     # Print out.
     print "ok\n";

     # Output:
     # ok

EXAMPLE4
     use strict;
     use warnings;

     use Error::Pure;
     use Mo::utils qw(check_array);

     $Error::Pure::TYPE = 'Error';

     my $self = {
             'key' => 'foo',
     };
     check_array($self, 'key');

     # Print out.
     print "ok\n";

     # Output like:
     # #Error [..utils.pm:?] Parameter 'key' must be a array.

EXAMPLE5
     use strict;
     use warnings;

     use Mo::utils qw(check_array_object);
     use Test::MockObject;

     my $self = {
             'key' => [
                     Test::MockObject->new,
             ],
     };
     check_array_object($self, 'key', 'Test::MockObject', 'Value');

     # Print out.
     print "ok\n";

     # Output:
     # ok

EXAMPLE6
     use strict;
     use warnings;

     use Error::Pure;
     use Mo::utils qw(check_array_object);

     $Error::Pure::TYPE = 'Error';

     my $self = {
             'key' => [
                     'foo',
             ],
     };
     check_array_object($self, 'key', 'Test::MockObject', 'Value');

     # Print out.
     print "ok\n";

     # Output like:
     # #Error [..utils.pm:?] Value isn't 'Test::MockObject' object.

EXAMPLE7
     use strict;
     use warnings;

     use Mo::utils qw(check_array_required);

     my $self = {
             'key' => ['value'],
     };
     check_array_required($self, 'key');

     # Print out.
     print "ok\n";

     # Output:
     # ok

EXAMPLE8
     use strict;
     use warnings;

     use Error::Pure;
     use Mo::utils qw(check_array_required);

     $Error::Pure::TYPE = 'Error';

     my $self = {
             'key' => [],
     };
     check_array_required($self, 'key');

     # Print out.
     print "ok\n";

     # Output like:
     # #Error [..utils.pm:?] Parameter 'key' with array must have at least one item.

EXAMPLE9
     use strict;
     use warnings;

     use Mo::utils qw(check_bool);
     use Test::MockObject;

     my $self = {
             'key' => 1,
     };
     check_bool($self, 'key');

     # Print out.
     print "ok\n";

     # Output:
     # ok

EXAMPLE10
     use strict;
     use warnings;

     use Error::Pure;
     use Mo::utils qw(check_bool);

     $Error::Pure::TYPE = 'Error';

     my $self = {
             'key' => 'bad',
     };
     check_bool($self, 'key');

     # Print out.
     print "ok\n";

     # Output like:
     # #Error [..utils.pm:?] Parameter 'key' must be a bool (0/1).

EXAMPLE11
     use strict;
     use warnings;

     use Mo::utils qw(check_code);
     use Test::MockObject;

     my $self = {
             'key' => sub {},
     };
     check_code($self, 'key');

     # Print out.
     print "ok\n";

     # Output:
     # ok

EXAMPLE12
     use strict;
     use warnings;

     use Error::Pure;
     use Mo::utils qw(check_code);

     $Error::Pure::TYPE = 'Error';

     my $self = {
             'key' => 'bad',
     };
     check_code($self, 'key');

     # Print out.
     print "ok\n";

     # Output like:
     # #Error [..utils.pm:?] Parameter 'key' must be a code.

EXAMPLE13
     use strict;
     use warnings;

     use Mo::utils qw(check_isa);
     use Test::MockObject;

     my $self = {
             'key' => Test::MockObject->new,
     };
     check_isa($self, 'key', 'Test::MockObject');

     # Print out.
     print "ok\n";

     # Output:
     # ok

EXAMPLE14
     use strict;
     use warnings;

     $Error::Pure::TYPE = 'Error';

     use Mo::utils qw(check_isa);

     my $self = {
             'key' => 'foo',
     };
     check_isa($self, 'key', 'Test::MockObject');

     # Print out.
     print "ok\n";

     # Output like:
     # #Error [...utils.pm:?] Parameter 'key' must be a 'Test::MockObject' object.

EXAMPLE15
     use strict;
     use warnings;

     $Error::Pure::TYPE = 'Error';

     use Mo::utils qw(check_length);

     my $self = {
             'key' => 'foo',
     };
     check_length($self, 'key', 3);

     # Print out.
     print "ok\n";

     # Output like:
     # ok

EXAMPLE16
     use strict;
     use warnings;

     $Error::Pure::TYPE = 'Error';

     use Mo::utils qw(check_length);

     my $self = {
             'key' => 'foo',
     };
     check_length($self, 'key', 2);

     # Print out.
     print "ok\n";

     # Output like:
     # #Error [...utils.pm:?] Parameter 'key' has length greater than '2'.

EXAMPLE17
     use strict;
     use warnings;

     $Error::Pure::TYPE = 'Error';

     use Mo::utils qw(check_length_fix);

     my $self = {
             'key' => 'foo',
     };
     check_length_fix($self, 'key', 3);

     # Print out.
     print "ok\n";

     # Output like:
     # ok

EXAMPLE18
     use strict;
     use warnings;

     $Error::Pure::TYPE = 'Error';

     use Mo::utils qw(check_length_fix);

     my $self = {
             'key' => 'foo',
     };
     check_length_fix($self, 'key', 4);

     # Print out.
     print "ok\n";

     # Output like:
     # #Error [...utils.pm:?] Parameter 'key' has length different than '4'.

EXAMPLE19
     use strict;
     use warnings;

     use Mo::utils qw(check_number);

     my $self = {
             'key' => '10',
     };
     check_number($self, 'key');

     # Print out.
     print "ok\n";

     # Output:
     # ok

EXAMPLE20
     use strict;
     use warnings;

     $Error::Pure::TYPE = 'Error';

     use Mo::utils qw(check_number);

     my $self = {
             'key' => 'foo',
     };
     check_number($self, 'key');

     # Print out.
     print "ok\n";

     # Output like:
     # #Error [...utils.pm:?] Parameter 'key' must be a number.

EXAMPLE21
     use strict;
     use warnings;

     use Mo::utils qw(check_number_min);

     my $self = {
             'key' => 10,
     };
     check_number_min($self, 'key', 5);

     # Print out.
     print "ok\n";

     # Output:
     # ok

EXAMPLE22
     use strict;
     use warnings;

     $Error::Pure::TYPE = 'Error';

     use Mo::utils qw(check_number_min);

     my $self = {
             'key' => 10,
     };
     check_number_min($self, 'key', 11);

     # Print out.
     print "ok\n";

     # Output like:
     # #Error [...utils.pm:?] Parameter 'key' must be greater than 11.

EXAMPLE23
     use strict;
     use warnings;

     use Test::MockObject;

     $Error::Pure::TYPE = 'Error';

     use Mo::utils qw(check_number_of_items);

     # Item object #1.
     my $item1 = Test::MockObject->new;
     $item1->mock('value', sub {
             return 'value1',
     });

     # Item object #1.
     my $item2 = Test::MockObject->new;
     $item2->mock('value', sub {
             return 'value2',
     });

     # Tested object.
     my $self = Test::MockObject->new({
             'key' => [],
     });
     $self->mock('list', sub {
             return [
                     $item1,
                     $item2,
             ];
     });

     # Check number of items.
     check_number_of_items($self, 'list', 'value', 'Test', 'Item');

     # Print out.
     print "ok\n";

     # Output like:
     # ok

EXAMPLE24
     use strict;
     use warnings;

     use Test::MockObject;

     $Error::Pure::TYPE = 'Error';

     use Mo::utils qw(check_number_of_items);

     # Item object #1.
     my $item1 = Test::MockObject->new;
     $item1->mock('value', sub {
             return 'value1',
     });

     # Item object #2.
     my $item2 = Test::MockObject->new;
     $item2->mock('value', sub {
             return 'value1',
     });

     # Tested object.
     my $self = Test::MockObject->new({
             'key' => [],
     });
     $self->mock('list', sub {
             return [
                     $item1,
                     $item2,
             ];
     });

     # Check number of items.
     check_number_of_items($self, 'list', 'value', 'Test', 'Item');

     # Print out.
     print "ok\n";

     # Output like:
     # #Error [...utils.pm:?] Test for Item 'value1' has multiple values.

EXAMPLE25
     use strict;
     use warnings;

     use Mo::utils qw(check_number_range);

     my $self = {
             'key' => '10',
     };
     check_number_range($self, 'key', 1, 10);

     # Print out.
     print "ok\n";

     # Output:
     # ok

EXAMPLE26
     use strict;
     use warnings;

     $Error::Pure::TYPE = 'Error';

     use Mo::utils qw(check_number_range);

     my $self = {
             'key' => 3,
     };
     check_number_range($self, 'key', 10, 12);

     # Print out.
     print "ok\n";

     # Output like:
     # #Error [...utils.pm:?] Parameter 'key' must be a number between 10 and 12.

EXAMPLE27
     use strict;
     use warnings;

     use Mo::utils qw(check_regexp);

     my $self = {
             'key' => 'https://example.com/1',
     };
     check_regexp($self, 'key', qr{^https://example\.com/\d+$});

     # Print out.
     print "ok\n";

     # Output:
     # ok

EXAMPLE28
     use strict;
     use warnings;

     use Error::Pure;
     use Mo::utils qw(check_regexp);

     $Error::Pure::TYPE = 'Error';

     my $self = {
             'key' => 'https://example.com/bad',
     };
     check_regexp($self, 'key', qr{^https://example\.com/\d+$});

     # Print out.
     print "ok\n";

     # Output like:
     # #Error [...utils.pm:?] Parameter 'key' does not match the specified regular expression.

EXAMPLE29
     use strict;
     use warnings;

     use Mo::utils qw(check_required);

     my $self = {
             'key' => 'value',
     };
     check_required($self, 'key');

     # Print out.
     print "ok\n";

     # Output:
     # ok

EXAMPLE30
     use strict;
     use warnings;

     use Error::Pure;
     use Mo::utils qw(check_required);

     $Error::Pure::TYPE = 'Error';

     my $self = {
             'key' => undef,
     };
     check_required($self, 'key');

     # Print out.
     print "ok\n";

     # Output like:
     # #Error [...utils.pm:?] Parameter 'key' is required.

EXAMPLE31
     use strict;
     use warnings;

     use Mo::utils qw(check_string);

     my $self = {
             'key' => 'foo',
     };
     check_string($self, 'key', 'foo');

     # Print out.
     print "ok\n";

     # Output:
     # ok

EXAMPLE32
     use strict;
     use warnings;

     use Error::Pure;
     use Mo::utils qw(check_string);

     $Error::Pure::TYPE = 'Error';

     my $self = {
             'key' => 'bad',
     };
     check_string($self, 'key', 'foo');

     # Print out.
     print "ok\n";

     # Output like:
     # #Error [...utils.pm:?] Parameter 'key' have expected value.

EXAMPLE33
     use strict;
     use warnings;

     use Mo::utils qw(check_string_begin);

     my $self = {
             'key' => 'http://example.com/foo',
     };
     check_string_begin($self, 'key', 'http://example.com/');

     # Print out.
     print "ok\n";

     # Output:
     # ok

EXAMPLE34
     use strict;
     use warnings;

     use Error::Pure;
     use Mo::utils qw(check_string_begin);

     $Error::Pure::TYPE = 'Error';

     my $self = {
             'key' => 'http://example/foo',
     };
     check_string_begin($self, 'key', 'http://example.com/');

     # Print out.
     print "ok\n";

     # Output like:
     # #Error [...utils.pm:?] Parameter 'key' must begin with defined string base.

EXAMPLE35
     use strict;
     use warnings;

     use Mo::utils qw(check_strings);

     my $self = {
             'key' => 'value',
     };
     check_strings($self, 'key', ['value', 'foo']);

     # Print out.
     print "ok\n";

     # Output:
     # ok

EXAMPLE36
     use strict;
     use warnings;

     use Error::Pure;
     use Mo::utils qw(check_strings);

     $Error::Pure::TYPE = 'Error';

     my $self = {
             'key' => 'bar',
     };
     check_strings($self, 'key', ['foo', 'value']);

     # Print out.
     print "ok\n";

     # Output like:
     # #Error [...utils.pm:?] Parameter 'key' must be one of defined strings.

DEPENDENCIES
    Exporter, Error::Pure, List::Utils, Readonly, Scalar::Util.

SEE ALSO
    Mo  Micro Objects. Mo is less.

    Mo::utils::Language
        Mo language utilities.

    Mo::utils::CSS
        Mo CSS utilities.

    Wikibase::Datatype::Utils
        Wikibase datatype utilities.

REPOSITORY
    <https://github.com/michal-josef-spacek/Mo-utils>

AUTHOR
    Michal Josef Špaček <mailto:skim@cpan.org>

    <http://skim.cz>

LICENSE AND COPYRIGHT
    © 2020-2024 Michal Josef Špaček

    BSD 2-Clause License

VERSION
    0.27