NAME Mo::utils - Mo utilities. SYNOPSIS use Mo::utils qw(check_array check_array_object check_bool check_code check_isa check_length check_number check_number_of_items check_required); check_array($self, $key); check_array_object($self, $key, $class, $class_name); check_bool($self, $key); check_code($self, $key); check_isa($self, $key, $class); check_length($self, $key, $max_length); check_number($self, $key); check_number_of_items($self, $list_method, $item_method, $object_name, $item_name); check_required($self, $key); check_strings($self, $key, $strings_ar); DESCRIPTION Mo utilities for checking of data objects. SUBROUTINES "check_array" check_array($self, $key); 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); 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_bool" check_bool($self, $key); 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); 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); 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); 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_number" check_number($self, $key); Check parameter defined by $key which is number (positive or negative) or no. 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); 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_required" check_required($self, $key); Check required parameter defined by $key. Put error if check isn't ok. Returns undef. "check_strings" check_strings($self, $key, $strings_ar); 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_array(): Parameter '%s' must be a array. Value: %s Reference: %s check_array_object(): Parameter '%s' must be a array. %s isn't '%s' object. 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_number(): Parameter '%s' must a number. Value: %s check_number_of_items(): %s for %s '%s' has multiple values. check_required(): Parameter '%s' is required. 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_array); my $self = { 'key' => ['foo'], }; check_array($self, 'key'); # Print out. print "ok\n"; # Output: # ok EXAMPLE2 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. EXAMPLE3 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 EXAMPLE4 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. EXAMPLE5 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 EXAMPLE6 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). EXAMPLE7 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 EXAMPLE8 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. EXAMPLE9 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 EXAMPLE10 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. EXAMPLE11 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 EXAMPLE12 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'. EXAMPLE13 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 EXAMPLE14 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. EXAMPLE15 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 EXAMPLE16 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. EXAMPLE17 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 EXAMPLE18 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. EXAMPLE19 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 EXAMPLE20 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. REPOSITORY AUTHOR Michal Josef Špaček LICENSE AND COPYRIGHT © 2020-2023 Michal Josef Špaček BSD 2-Clause License VERSION 0.15