view release on metacpan or  search on metacpan

lib/Crypt/HSXKPasswd/Types.pm  view on Meta::CPAN

package Crypt::HSXKPasswd::Types;

# inhert from Type::Library
use parent Type::Library;

# import required modules
use strict;
use warnings;
use English qw( -no_match_vars );
use Carp; # for nicer 'exceptions' for users of the module
use Fatal qw( :void open close binmode ); # make builtins throw exceptions
use List::MoreUtils qw( uniq );
use Data::Dumper; # for generating sane error messages
use Type::Tiny;
use Types::Standard qw( :types );

# set things up for using UTF-8
use 5.016; # min Perl for good UTF-8 support, implies feature 'unicode_strings'
use Encode qw(encode decode);
use utf8;
binmode STDOUT, ':encoding(UTF-8)';

#==============================================================================#
# Custom Type Library for Crypt::HSXKPasswd
#==============================================================================#
#
# A library of custom Type::Tiny types for use in the various Crypt::HSXKPasswd
# packages.
#
#==============================================================================#

#
# === CONSTANTS ===============================================================#
#

# version info
use version; our $VERSION = qv('1.2');

#
# === Define The Fundamental Types ============================================#
#

# add a type for Perl package names
my $PERL_PACKAGE_NAME_ENGLISH = q{a valid Perl Package Name like 'Crypt::HSXKPasswd'};
my $PERL_PACKAGE_NAME = Type::Tiny->new(
    name => 'PerlPackageName',
    parent => Str,
    constraint => sub{ m/^[a-zA-Z_]\w*(?:[:]{2}\w+)*$/sx; }, ## no critic (ProhibitEnumeratedClasses)
    message => sub{
        return var_to_string($_).qq{ is not $PERL_PACKAGE_NAME_ENGLISH};
    },
    my_methods => {
        english => sub {return $PERL_PACKAGE_NAME_ENGLISH;},
    },
);
__PACKAGE__->meta->add_type($PERL_PACKAGE_NAME);

# add a type for positive integers (including 0)
my $POSITIVE_INTEGER_ENGLISH = 'an integer greater than or equal to zero';
my $POSITIVE_INTEGER = Type::Tiny->new(
    name => 'PositiveInteger',
    parent => Int,
    constraint => sub{
        return $_ >= 0;
    },
    message => sub{
        return var_to_string($_).qq{ is not $POSITIVE_INTEGER_ENGLISH};
    },
    my_methods => {
        english => sub {return $POSITIVE_INTEGER_ENGLISH;},
    },
);
__PACKAGE__->meta->add_type($POSITIVE_INTEGER);

# add a type for positive integers (including 0)
my $NON_ZERO_POSITIVE_INTEGER_ENGLISH = 'an integer greater than zero';
my $NON_ZERO_POSITIVE_INTEGER = Type::Tiny->new(
    name => 'NonZeroPositiveInteger',

lib/Crypt/HSXKPasswd/Types.pm  view on Meta::CPAN

        return var_to_string($_).qq{ is not $NON_ZERO_POSITIVE_INTEGER_ENGLISH};
    },
    my_methods => {
        english => sub {return $NON_ZERO_POSITIVE_INTEGER_ENGLISH;},
    },
);
__PACKAGE__->meta->add_type($NON_ZERO_POSITIVE_INTEGER);

# add a type for strings of at least one character
my $NON_EMPTY_STRING_ENGLISH = 'a string contianing at least one character';
my $NON_EMPTY_STRING = Type::Tiny->new(
    name => 'NonEmptyString',
    parent => Str,
    constraint => sub{
        return length $_ > 0;
    },
    message => sub{
        return var_to_string($_).qq{ is not $NON_EMPTY_STRING_ENGLISH};
    },
    my_methods => {
        english => sub {return $NON_EMPTY_STRING_ENGLISH;},
    },
);
__PACKAGE__->meta->add_type($NON_EMPTY_STRING);

# add a type for a single letter (a single alpha grapheme)
my $LETTER_ENGLISH = q{a string containing exactly one letter};
my $LETTER = Type::Tiny->new(
    name => 'Letter',
    parent => Str,
    constraint => sub{
        return m/^\pL$/sx;
    },
    message => sub{
        return var_to_string($_).qq{ is not a Letter (must be $LETTER_ENGLISH)};
    },
    my_methods => {
        english => sub {return $LETTER_ENGLISH;},
    },
);
__PACKAGE__->meta->add_type($LETTER);

# add a type for words (a grouping of alpha characters at least four graphemes
# long)
my $WORD_ENGLISH = q{a string of only letters at least four long};
my $WORD = Type::Tiny->new(
    name => 'Word',
    parent => Str,
    constraint => sub{
        return m/^\pL{4,}$/sx;
    },
    message => sub{
        return var_to_string($_).qq{ is not a Word (must be $WORD_ENGLISH)};
    },
    my_methods => {
        english => sub {return $WORD_ENGLISH;},
    },
);
__PACKAGE__->meta->add_type($WORD);

# add a type for a single symbol (a single non-letter unicode grapheme)
my $SYMBOL_ENGLISH = 'a string containing exactly one non-letter character';
my $SYMBOL = Type::Tiny->new(
    name => 'Symbol',
    parent => Str,
    constraint => sub{
        return m/^\X$/sx && m/^[^\pL]$/sx;
    },
    message => sub{
        return var_to_string($_).qq{ is not a Symbol (must be $SYMBOL_ENGLISH)};
    },
    my_methods => {
        english => sub {return $SYMBOL_ENGLISH;},
    },
);
__PACKAGE__->meta->add_type($SYMBOL);

# add a type for symbol alphabets - array refs containing only, and at least 2,
# single-character strings
my $SYMBOL_ALPHABET_ENGLISH = 'a reference to an array of distinct Symbols at least two long';
my $SYMBOL_ALPHABET = Type::Tiny->new(
    name => 'SymbolAlphabet',
    parent => ArrayRef[$SYMBOL],
    constraint => sub{
        my @unique_symbols = uniq(@{$_});
        return scalar @unique_symbols >= 2;
    },
    message => sub{
        return var_to_string($_).qq{ is not a Symbol Alphabet (must be $SYMBOL_ALPHABET_ENGLISH)};
    },
    my_methods => {
        english => sub {return $SYMBOL_ALPHABET_ENGLISH;},
    },
);
__PACKAGE__->meta->add_type($SYMBOL_ALPHABET);

# add a type for word lengths - integers greater than 3
my $WORD_LENGTH_ENGLISH = 'an integer greater than 3';
my $WORD_LENGTH = Type::Tiny->new(
    name => 'WordLength',
    parent => Int,
    constraint => sub{
        return $_ > 3;
    },
    message => sub{
        return var_to_string($_).qq{ is not a valid Word Length (must be $WORD_LENGTH_ENGLISH)};
    },
    my_methods => {
        english => sub {return $WORD_LENGTH_ENGLISH;},
    },
);
__PACKAGE__->meta->add_type($WORD_LENGTH);

# add a type for word lengths - integers greater than 3
my $TRUE_FALSE_ENGLISH = '1 to indicate true, or 0, undef, or the empty string to indicate false';
my $TRUE_FALSE = Type::Tiny->new(
    name => 'TrueFalse',
    parent => Bool,
    message => sub{
        return var_to_string($_).qq{ is not a valid True/False value (must be $TRUE_FALSE_ENGLISH)};
    },