Aplicar comprobación específica (más allá de los tipos de Moose) al atributo de Moose

Question

Moose types son geniales, pero a veces debe ser más específico. Todos ustedes conocen estas reglas de tipo de datos: ese parámetro solo puede ser 'A', 'B' o 'C', o solo un símbolo de moneda, o debe ajustarse a alguna expresión regular.

Eche un vistazo al siguiente ejemplo que tiene dos atributos restringidos, uno debe ser 'm' o 'f', el otro debe ser una fecha ISO válida. ¿Cuál es la mejor manera en Moose para especificar estas restricciones? Pensaría en la cláusula SQL CHECK, pero AFAICS no hay check palabra clave en Moose. Entonces usé trigger, pero suena mal. Alguien tiene una mejor respuesta?

package Person; 
use Moose; 

has gender   => is => 'rw', isa => 'Str', trigger => 
    sub { confess 'either m or f' if $_[1] !~ m/^m|f$/ }; 
has name   => is => 'rw', isa => 'Str'; 
has dateOfBirth  => is => 'rw', isa => 'Str', trigger => 
    sub { confess 'not an ISO date' if $_[1] !~ m/^\d\d\d\d-\d\d-\d\d$/ }; 

no Moose; 
__PACKAGE__->meta->make_immutable; 

package main; 
use Test::More; 
use Test::Exception; 

dies_ok { Person->new(gender => 42) } 'gender must be m or f'; 
dies_ok { Person->new(dateOfBirth => 42) } 'must be an ISO date'; 

done_testing; 

Esto es lo que terminé usando:

package Blabla::Customer; 
use Moose::Util::TypeConstraints; 
use Moose; 

subtype ISODate => as 'Str' => where { /^\d\d\d\d-\d\d-\d\d$/ }; 

has id    => is => 'rw', isa => 'Str'; 
has gender   => is => 'rw', isa => enum ['m', 'f']; 
has firstname  => is => 'rw', isa => 'Str'; 
has dateOfBirth  => is => 'rw', isa => 'ISODate'; 

no Moose; 
__PACKAGE__->meta->make_immutable; 

Esta es la versión 1.19 alces, en caso de que importa. Recibí la siguiente advertencia para la erróneasubtype as => 'Str', where => { ... } sintaxis que introduje erróneamente: Calling subtype() with a simple list of parameters is deprecated. Así que tuve que cambiarlo un poco según el fino manual.

Answer 1

Simplemente defina su propio subtipo y úselo.

package Person; 

use Moose::Util::TypeConstraints; 

use namespace::clean; 
use Moose; 

has gender => (
    is => 'rw', 
    isa => subtype(
    as 'Str', 
    where { /^[mf]$/ } 
), 
); 
has name => (
    is => 'rw', 
    isa => 'Str' 
); 
has dateOfBirth => (
    is => 'rw', 
    isa => subtype(
    as 'Str', 
    where { /^\d\d\d\d-\d\d-\d\d$/ } 
), 
); 

no Moose; 
__PACKAGE__->meta->make_immutable; 
1; 

package main; 
use Test::More; 
use Test::Exception; 

dies_ok { Person->new(gender => 42) } 'gender must be m or f'; 
dies_ok { Person->new(dateOfBirth => 42) } 'must be an ISO date'; 

done_testing; 

O usted podría utilizar el módulo MooseX::Types.

package Person::TypeConstraints; 

use MooseX::Types::Moose qw'Str'; 
use MooseX::Types -declare => [qw' 
    Gender ISODate 
']; 

subtype Gender, (
    as Str, 
    where { /^[mf]$/ }, 
); 

subtype ISODate, (
    as Str, 
    where { /^\d\d\d\d-\d\d-\d\d$/ } 
); 
1; 

package Person: 

use MooseX::Types::Moose qw'Str'; 
use Person::TypeConstraints qw'Gender ISODate'; 

use namespace::clean; 
use Moose; 

has gender => (
    is => 'rw', 
    isa => Gender, 
); 
has name => (
    is => 'rw', 
    isa => Str, 
); 
has dateOfBirth => (
    is => 'rw', 
    isa => ISODate, 
); 

no Moose; 
__PACKAGE__->meta->make_immutable; 
1; 

Answer 2

Añadiendo su propio tipo como Brad dijo:

use Moose::Util::TypeConstraints; 

my $gender_constraint = subtype as 'Str', where { $_ =~ /^[FfMm]$/ }; 
has gender => (is => 'rw', isa => $gender_constraint); 

Answer 3

Usted podría tratar de usar MooseX-Types-Parameterizable para poner en práctica los tipos que tienen parámetros para los casos que presentan (no probados, que acabamos de esbozar):

package YourTypes; 
use MooseX::Types -declare => [qw(OneOfStr MatchingStr)]; 
use MooseX::Types::Moose qw(Str ArrayRef RegexpRef); 

subtype OneOfStr, 
    as Parameterizable[ Str, ArrayRef[ Str ] ], 
    where { 
     my ($str, $allowed) = @_; 
     return scalar grep { $_ eq $str } @$allowed; 
    }; 

subtype MatchingStr, 
    as Parameterizable[ Str, RegexpRef ], 
    where { 
     my ($str, $rx) = @_; 
     return scalar $str =~ $rx; 
    }; 

1; 

y lo usarías así:

use YourTypes qw(OneOfStr MatchingStr); 

has gender => (is => 'ro', isa => OneOfStr[ [qw(f m)] ]); 
has dob => (is => 'ro', isa => MatchingStr[ qr/^$yourregex$/ ]);