MooX-Types-MooseLike-Numeric-1.02/0000755000175000017500000000000012244163325016303 5ustar hunterhunterMooX-Types-MooseLike-Numeric-1.02/META.yml0000664000175000017500000000136512244163325017563 0ustar hunterhunter--- abstract: 'Moo types for numbers' author: - 'mateu - Mateu X. Hunter (cpan:MATEU) ' build_requires: Test::Fatal: 0.003 Test::More: 0.96 configure_requires: ExtUtils::MakeMaker: 0 dynamic_config: 1 generated_by: 'ExtUtils::MakeMaker version 6.8, CPAN::Meta::Converter version 2.120921' license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: 1.4 name: MooX-Types-MooseLike-Numeric no_index: directory: - t - inc requires: MooX::Types::MooseLike: 0.23 resources: bugtracker: http://rt.cpan.org/NoAuth/Bugs.html?Dist=MooX-Types-MooseLike-Numeric repository: git://github.com/mateu/MooX-Types-MooseLike-Numeric.git x_IRC: irc://irc.perl.org/#web-simple version: 1.02 MooX-Types-MooseLike-Numeric-1.02/MANIFEST0000644000175000017500000000055312244163325017437 0ustar hunterhunterChanges lib/MooX/Types/MooseLike/Numeric.pm maint/Makefile.PL.include Makefile.PL MANIFEST This list of files t/numeric.t META.yml Module YAML meta-data (added by MakeMaker) META.json Module JSON meta-data (added by MakeMaker) README README file (added by Distar) MooX-Types-MooseLike-Numeric-1.02/META.json0000664000175000017500000000235212244163325017730 0ustar hunterhunter{ "abstract" : "Moo types for numbers", "author" : [ "mateu - Mateu X. Hunter (cpan:MATEU) " ], "dynamic_config" : 1, "generated_by" : "ExtUtils::MakeMaker version 6.8, CPAN::Meta::Converter version 2.120921", "license" : [ "perl_5" ], "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : "2" }, "name" : "MooX-Types-MooseLike-Numeric", "no_index" : { "directory" : [ "t", "inc" ] }, "prereqs" : { "build" : { "requires" : { "Test::Fatal" : "0.003", "Test::More" : "0.96" } }, "configure" : { "requires" : { "ExtUtils::MakeMaker" : "0" } }, "runtime" : { "requires" : { "MooX::Types::MooseLike" : "0.23" } } }, "release_status" : "stable", "resources" : { "bugtracker" : { "web" : "http://rt.cpan.org/NoAuth/Bugs.html?Dist=MooX-Types-MooseLike-Numeric" }, "repository" : { "url" : "git://github.com/mateu/MooX-Types-MooseLike-Numeric.git" }, "x_IRC" : "irc://irc.perl.org/#web-simple" }, "version" : "1.02" } MooX-Types-MooseLike-Numeric-1.02/lib/0000755000175000017500000000000012244163325017051 5ustar hunterhunterMooX-Types-MooseLike-Numeric-1.02/lib/MooX/0000755000175000017500000000000012244163325017733 5ustar hunterhunterMooX-Types-MooseLike-Numeric-1.02/lib/MooX/Types/0000755000175000017500000000000012244163325021037 5ustar hunterhunterMooX-Types-MooseLike-Numeric-1.02/lib/MooX/Types/MooseLike/0000755000175000017500000000000012244163325022726 5ustar hunterhunterMooX-Types-MooseLike-Numeric-1.02/lib/MooX/Types/MooseLike/Numeric.pm0000644000175000017500000000644512244163122024672 0ustar hunterhunterpackage MooX::Types::MooseLike::Numeric; use strict; use warnings FATAL => 'all'; use MooX::Types::MooseLike qw(exception_message); use MooX::Types::MooseLike::Base; use Exporter 5.57 'import'; our @EXPORT_OK = (); our $VERSION = '1.02'; my $type_definitions = [ { name => 'PositiveNum', subtype_of => 'Num', from => 'MooX::Types::MooseLike::Base', test => sub { defined $_[0] and $_[0] > 0 }, message => sub { return exception_message($_[0], 'a positive number') }, }, { name => 'PositiveOrZeroNum', subtype_of => 'Num', from => 'MooX::Types::MooseLike::Base', test => sub { defined $_[0] and $_[0] >= 0 }, message => sub { return exception_message($_[0], 'a positive number or zero') }, }, { name => 'PositiveInt', subtype_of => 'Int', from => 'MooX::Types::MooseLike::Base', test => sub { defined $_[0] and $_[0] > 0 }, message => sub { return exception_message($_[0], 'a positive integer') }, }, { name => 'PositiveOrZeroInt', subtype_of => 'Int', from => 'MooX::Types::MooseLike::Base', test => sub { defined $_[0] and $_[0] >= 0 }, message => sub { return exception_message($_[0], 'a positive integer or zero') }, }, { name => 'NegativeNum', subtype_of => 'Num', from => 'MooX::Types::MooseLike::Base', test => sub { defined $_[0] and $_[0] < 0 }, message => sub { return exception_message($_[0], 'a negative number') }, }, { name => 'NegativeOrZeroNum', subtype_of => 'Num', from => 'MooX::Types::MooseLike::Base', test => sub { defined $_[0] and $_[0] <= 0 }, message => sub { return exception_message($_[0], 'a negative number or zero') }, }, { name => 'NegativeInt', subtype_of => 'Int', from => 'MooX::Types::MooseLike::Base', test => sub { defined $_[0] and $_[0] < 0 }, message => sub { return exception_message($_[0], 'a negative integer') }, }, { name => 'NegativeOrZeroInt', subtype_of => 'Int', from => 'MooX::Types::MooseLike::Base', test => sub { defined $_[0] and $_[0] <= 0 }, message => sub { return exception_message($_[0], 'a negative integer or zero') }, }, { name => 'SingleDigit', subtype_of => 'PositiveOrZeroInt', from => 'MooX::Types::MooseLike::Numeric', test => sub { defined $_[0] and $_[0] < 10 }, message => sub { return exception_message($_[0], 'a single digit') }, }, ]; MooX::Types::MooseLike::register_types($type_definitions, __PACKAGE__, 'MooseX::Types::Common::Numeric'); our %EXPORT_TAGS = ('all' => \@EXPORT_OK); 1; __END__ =head1 NAME MooX::Types::MooseLike::Numeric - Moo types for numbers =head1 SYNOPSIS package MyPackage; use Moo; use MooX::Types::MooseLike::Numeric qw(PositiveInt); has "daily_breathes" => ( isa => PositiveInt ); =head1 DESCRIPTION adapted from MooseX::Types::Common::Numeric =head1 TYPES (subroutines) Available types are listed below. =over =item PositiveNum =item PositiveOrZeroNum =item PositiveInt =item PositiveOrZeroInt =item NegativeNum =item NegativeOrZeroNum =item NegativeInt =item NegativeOrZeroInt =item SingleDigit =back MooX-Types-MooseLike-Numeric-1.02/maint/0000755000175000017500000000000012244163325017413 5ustar hunterhunterMooX-Types-MooseLike-Numeric-1.02/maint/Makefile.PL.include0000644000175000017500000000030612124436561023010 0ustar hunterhunterBEGIN { -e 'Distar' or system("git clone git://git.shadowcat.co.uk/p5sagit/Distar.git") } use lib 'Distar/lib'; use Distar; author 'mateu - Mateu X. Hunter (cpan:MATEU) '; 1; MooX-Types-MooseLike-Numeric-1.02/Makefile.PL0000644000175000017500000000140612124436714020260 0ustar hunterhunteruse strict; use warnings FATAL => 'all'; use 5.008001; use ExtUtils::MakeMaker; (do 'maint/Makefile.PL.include' or die $@) unless -f 'META.yml'; my %RUN_DEPS = ( 'MooX::Types::MooseLike' => 0.23, ); my %BUILD_DEPS = ( 'Test::More' => 0.96, 'Test::Fatal' => 0.003, ); WriteMakefile( NAME => 'MooX::Types::MooseLike::Numeric', VERSION_FROM => 'lib/MooX/Types/MooseLike/Numeric.pm', PREREQ_PM => { %RUN_DEPS, }, BUILD_REQUIRES => { %BUILD_DEPS, }, META_ADD => { resources => { repository => 'git://github.com/mateu/MooX-Types-MooseLike-Numeric.git', bugtracker => 'http://rt.cpan.org/NoAuth/Bugs.html?Dist=MooX-Types-MooseLike-Numeric', IRC => 'irc://irc.perl.org/#web-simple', }, }, LICENSE => 'perl', ); MooX-Types-MooseLike-Numeric-1.02/README0000664000175000017500000000104312244163325017163 0ustar hunterhunterNAME MooX::Types::MooseLike::Numeric - Moo types for numbers SYNOPSIS package MyPackage; use Moo; use MooX::Types::MooseLike::Numeric qw(PositiveInt); has "daily_breathes" => ( isa => PositiveInt ); DESCRIPTION adapted from MooseX::Types::Common::Numeric TYPES (subroutines) Available types are listed below. PositiveNum PositiveOrZeroNum PositiveInt PositiveOrZeroInt NegativeNum NegativeOrZeroNum NegativeInt NegativeOrZeroInt SingleDigit MooX-Types-MooseLike-Numeric-1.02/Changes0000644000175000017500000000033212244163266017600 0ustar hunterhunter1.02 - 2013-11-23 - Correct Makefile NAME 1.01 - 2013-03-07 - Corrected test (check for existence of Type before-hand) 1.00 - 2013-03-07 - Extracted from MooX::Types::MooseLike as its own distribution MooX-Types-MooseLike-Numeric-1.02/t/0000755000175000017500000000000012244163325016546 5ustar hunterhunterMooX-Types-MooseLike-Numeric-1.02/t/numeric.t0000644000175000017500000001460312124436561020403 0ustar hunterhunter{ package MooX::Types::MooseLike::Numeric::Test; use strict; use warnings FATAL => 'all'; use Moo; use MooX::Types::MooseLike::Numeric qw(:all); has 'a_positive_number' => ( is => 'ro', isa => PositiveNum, ); has 'a_nonnegative_number' => ( is => 'ro', isa => PositiveOrZeroNum, ); has 'a_positive_integer' => ( is => 'ro', isa => PositiveInt, ); has 'a_nonnegative_integer' => ( is => 'ro', isa => PositiveOrZeroInt, ); has 'a_negative_number' => ( is => 'ro', isa => NegativeNum, ); has 'a_nonpositive_number' => ( is => 'ro', isa => NegativeOrZeroNum, ); has 'a_negative_integer' => ( is => 'ro', isa => NegativeInt, ); has 'a_nonpositive_integer' => ( is => 'ro', isa => NegativeOrZeroInt, ); has 'a_single_digit' => ( is => 'ro', isa => SingleDigit, ); } { package main; use strict; use warnings FATAL => 'all'; use Test::More; use Test::Fatal; use IO::Handle; use MooX::Types::MooseLike::Numeric qw(:all); ok(is_PositiveNum(1), 'is_PositiveNum'); ok(!is_PositiveNum(0), 'is_PositiveNum fails on zero'); ok(is_PositiveOrZeroNum(3.142), 'is_PositiveOrZeroNum'); ok(!is_PositiveOrZeroNum(-1), 'is_PositiveOrZeroNum fails on -1'); ok(is_PositiveInt(1), 'is_PositiveInt'); ok(!is_PositiveInt(0), 'is_PositiveInt fails on zero'); ok(is_PositiveOrZeroInt(0), 'is_PositiveOrZeroInt'); ok(!is_PositiveOrZeroInt(-1), 'is_PositiveOrZeroInt fails on -1'); ok(is_NegativeNum(-1), 'is_NegativeNum'); ok(!is_NegativeNum(0), 'is_NegativeNum fails on zero'); ok(is_NegativeOrZeroNum(-3.142), 'is_NegativeOrZeroNum'); ok(!is_NegativeOrZeroNum(1), 'is_NegativeOrZeroNum fails on 1'); ok(is_NegativeInt(-1), 'is_NegativeInt'); ok(!is_NegativeInt(0), 'is_NegativeInt fails on zero'); ok(is_NegativeOrZeroInt(0), 'is_NegativeOrZeroInt'); ok(!is_NegativeOrZeroNum(1), 'is_NonPositiveNum fails on 1'); ## PositiveNum ok(MooX::Types::MooseLike::Numeric::Test->new(a_positive_number => 1), 'PositiveNum'); like( exception { MooX::Types::MooseLike::Numeric::Test->new(a_positive_number => undef); }, qr/is not a positive number/, 'undef is an exception when we want a positive number' ); like( exception { MooX::Types::MooseLike::Numeric::Test->new(a_positive_number => ''); }, qr/is not a positive number/, 'empty string is an exception when we want a positive number' ); ## PositiveOrZeroNum ok(MooX::Types::MooseLike::Numeric::Test->new(a_nonnegative_number => 0), 'PositiveOrZeroNum'); like( exception { MooX::Types::MooseLike::Numeric::Test->new(a_nonnegative_number => -1); }, qr/is not a positive number or zero/, '-1 is an exception when we want a non-negative number' ); ## PositiveInt ok(MooX::Types::MooseLike::Numeric::Test->new(a_positive_integer => 1), 'PositiveInt'); like( exception { MooX::Types::MooseLike::Numeric::Test->new(a_positive_integer => ''); }, qr/is not a positive integer/, 'empty string is an exception when we want a positive integer' ); ## PositiveOrZeroInt ok(MooX::Types::MooseLike::Numeric::Test->new(a_nonnegative_integer => 0), 'PositiveOrZeroInt'); like( exception { MooX::Types::MooseLike::Numeric::Test->new(a_nonnegative_integer => -1); }, qr/is not a positive integer or zero/, '-1 is an exception when we want a non-negative integer' ); ## NegativeNum ok(MooX::Types::MooseLike::Numeric::Test->new(a_negative_number => -11), 'NegativeNum'); like( exception { MooX::Types::MooseLike::Numeric::Test->new(a_negative_number => ''); }, qr/is not a negative number/, 'empty string is an exception when we want a negative number' ); ## NegativeOrZeroNum ok(MooX::Types::MooseLike::Numeric::Test->new(a_nonpositive_number => 0), 'NegativeOrZeroNum'); like( exception { MooX::Types::MooseLike::Numeric::Test->new(a_nonpositive_number => 1); }, qr/is not a negative number or zero/, '1 is an exception when we want a non-negative number' ); ## NegativeInt ok(MooX::Types::MooseLike::Numeric::Test->new(a_negative_integer => -1), 'NegativeInt'); like( exception { MooX::Types::MooseLike::Numeric::Test->new(a_negative_integer => ''); }, qr/is not a negative integer/, 'empty string is an exception when we want a negative integer' ); ## NegativeOrZeroInt ok(MooX::Types::MooseLike::Numeric::Test->new(a_nonpositive_integer => 0), 'NegativeOrZeroInt'); like( exception { MooX::Types::MooseLike::Numeric::Test->new(a_nonpositive_integer => 1); }, qr/is not a negative integer or zero/, '1 is an exception when we want a non-positive integer' ); ## SingleDigit ok(MooX::Types::MooseLike::Numeric::Test->new(a_single_digit => 0), 'SingleDigit'); like( exception { MooX::Types::MooseLike::Numeric::Test->new(a_single_digit => 10); }, qr/is not a single digit/, '10 is an exception when we want a single digit' ); eval q{ require Moose; require MooseX::Types::Common::Numeric; } or do { note "Moose or Type not available; skipping actual inflation tests"; done_testing; exit; }; is( exception { MooX::Types::MooseLike::Numeric::Test->new(a_positive_integer => 3) }, undef, 'Moose loaded; value which should not violate type constraint', ); like( exception { MooX::Types::MooseLike::Numeric::Test->new(a_positive_integer => 0)}, qr{isa check for "a_positive_integer" failed: 0 is not a positive integer}, 'Moose loaded; value which should violate type constraint', ); my $tc = do { # Suppress distracting warnings from within Moose local $SIG{__WARN__} = sub { 0 }; MooX::Types::MooseLike::Numeric::Test->meta->get_attribute('a_positive_integer')->type_constraint; }; is( $tc->name, 'MooseX::Types::Common::Numeric::PositiveInt', 'type constraint inflation results in MooseX counterpart type', ); ok($tc->check(1), 'Moose::Meta::TypeConstraint works (1)'); ok(!$tc->check(0), 'Moose::Meta::TypeConstraint works (3)'); ok(!$tc->check(-1), 'Moose::Meta::TypeConstraint works (3)'); ok(!$tc->check([]), 'Moose::Meta::TypeConstraint works (4)'); ok(!$tc->check(undef),'Moose::Meta::TypeConstraint works (5)'); done_testing; }