X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FMoose%2FMeta%2FTypeConstraint.pm;h=1ec67a2cd86d224a766044751b80910b109d1ff5;hb=4a315f4b0c6b14bffc21f3337127c6335b7ec15f;hp=0318f679c15a8a169667f6e905ac956818e97a20;hpb=4b2189ce8dae168787b635b71a918bd64461ed7a;p=gitmo%2FMoose.git diff --git a/lib/Moose/Meta/TypeConstraint.pm b/lib/Moose/Meta/TypeConstraint.pm index 0318f67..1ec67a2 100644 --- a/lib/Moose/Meta/TypeConstraint.pm +++ b/lib/Moose/Meta/TypeConstraint.pm @@ -5,14 +5,17 @@ use strict; use warnings; use metaclass; -use overload '""' => sub { shift->name }, # stringify to tc name +use overload '0+' => sub { refaddr(shift) }, # id an object + '""' => sub { shift->name }, # stringify to tc name + bool => sub { 1 }, fallback => 1; use Scalar::Util qw(blessed refaddr); +use Sub::Name qw(subname); use base qw(Class::MOP::Object); -our $VERSION = '0.72'; +our $VERSION = '1.19'; $VERSION = eval $VERSION; our $AUTHORITY = 'cpan:STEVAN'; @@ -82,9 +85,30 @@ sub coerce { Moose->throw_error("Cannot coerce without a type coercion"); } + return $_[0] if $self->check($_[0]); + return $coercion->coerce(@_); } +sub assert_coerce { + my $self = shift; + + my $coercion = $self->coercion; + + unless ($coercion) { + require Moose; + Moose->throw_error("Cannot coerce without a type coercion"); + } + + return $_[0] if $self->check($_[0]); + + my $result = $coercion->coerce(@_); + + $self->assert_valid($result); + + return $result; +} + sub check { my ($self, @args) = @_; my $constraint_subref = $self->_compiled_type_constraint; @@ -101,6 +125,16 @@ sub validate { } } +sub assert_valid { + my ($self, $value) = @_; + + my $error = $self->validate($value); + return 1 if ! defined $error; + + require Moose; + Moose->throw_error($error); +} + sub get_message { my ($self, $value) = @_; if (my $msg = $self->message) { @@ -108,9 +142,9 @@ sub get_message { return $msg->($value); } else { - $value = (defined $value ? overload::StrVal($value) : 'undef'); - return "Validation failed for '" . $self->name . "' failed with value $value"; - } + $value = (defined $value ? overload::StrVal($value) : 'undef'); + return "Validation failed for '" . $self->name . "' with value $value"; + } } ## type predicates ... @@ -120,7 +154,7 @@ sub equals { my $other = Moose::Util::TypeConstraints::find_type_constraint($type_or_name) or return; - return 1 if refaddr($self) == refaddr($other); + return 1 if $self == $other; if ( $self->has_hand_optimized_type_constraint and $other->has_hand_optimized_type_constraint ) { return 1 if $self->hand_optimized_type_constraint == $other->hand_optimized_type_constraint; @@ -135,7 +169,7 @@ sub equals { return if $other->has_parent; } - return 1; + return; } sub is_a_type_of { @@ -232,7 +266,7 @@ sub _compile_subtype { if ( $check == $null_constraint ) { return $optimized_parent; } else { - return Class::MOP::subname($self->name, sub { + return subname($self->name, sub { return undef unless $optimized_parent->($_[0]); my (@args) = @_; local $_ = $args[0]; @@ -243,7 +277,7 @@ sub _compile_subtype { # general case, check all the constraints, from the first parent to ourselves my @checks = @parents; push @checks, $check if $check != $null_constraint; - return Class::MOP::subname($self->name => sub { + return subname($self->name => sub { my (@args) = @_; local $_ = $args[0]; foreach my $check (@checks) { @@ -259,7 +293,7 @@ sub _compile_type { return $check if $check == $null_constraint; # Item, Any - return Class::MOP::subname($self->name => sub { + return subname($self->name => sub { my (@args) = @_; local $_ = $args[0]; $check->(@args); @@ -285,10 +319,6 @@ sub create_child_type { return $class->new(%opts, parent => $self); } -## this should get deprecated actually ... - -sub union { Carp::croak "DEPRECATED" } - 1; __END__ @@ -301,126 +331,171 @@ Moose::Meta::TypeConstraint - The Moose Type Constraint metaclass =head1 DESCRIPTION -For the most part, the only time you will ever encounter an -instance of this class is if you are doing some serious deep -introspection. This API should not be considered final, but -it is B that this will matter to a regular -Moose user. +This class represents a single type constraint. Moose's built-in type +constraints, as well as constraints you define, are all stored in a +L object as objects of this +class. + +=head1 INHERITANCE -If you wish to use features at this depth, please come to the -#moose IRC channel on irc.perl.org and we can talk :) +C is a subclass of L. =head1 METHODS =over 4 -=item B +=item B<< Moose::Meta::TypeConstraint->new(%options) >> + +This creates a new type constraint based on the provided C<%options>: -=item B +=over 8 -=item B +=item * name -This checks the current type against the supplied type (only). -Returns false if the two types are not equal. It also returns false if -you provide the type as a name, and the type name isn't found in the -type registry. +The constraint name. If a name is not provided, it will be set to +"__ANON__". -=item B +=item * parent -This checks the current type against the supplied type, or if the -current type is a sub-type of the type name or object supplied. It -also returns false if you provide the type as a name, and the type -name isn't found in the type registry. +A C object which is the parent type for +the type being created. This is optional. -=item B +=item * constraint -This checks the current type is a sub-type of the type name or object -supplied. It also returns false if you provide the type as a name, and -the type name isn't found in the type registry. +This is the subroutine reference that implements the actual constraint +check. This defaults to a subroutine which always returns true. -=item B +=item * message -=item B +A subroutine reference which is used to generate an error message when +the constraint fails. This is optional. -This will apply the type-coercion if applicable. +=item * coercion -=item B +A L object representing the coercions to +the type. This is optional. -This method will return a true (C<1>) if the C<$value> passes the -constraint, and false (C<0>) otherwise. +=item * optimized -=item B +This is a variant of the C parameter that is somehow +optimized. Typically, this means incorporating both the type's +constraint and all of its parents' constraints into a single +subroutine reference. -This method is similar to C, but it deals with the error -message. If the C<$value> passes the constraint, C will be -returned. If the C<$value> does B pass the constraint, then -the C will be used to construct a custom error message. +=back -=item B +=item B<< $constraint->equals($type_name_or_object) >> -The name of the type in the global type registry. +Returns true if the supplied name or type object is the same as the +current type. -=item B +=item B<< $constraint->is_subtype_of($type_name_or_object) >> -This type's parent type. +Returns true if the supplied name or type object is a parent of the +current type. -=item B +=item B<< $constraint->is_a_type_of($type_name_or_object) >> -Returns true if this type has a parent type. +Returns true if the given type is the same as the current type, or is +a parent of the current type. This is a shortcut for checking +C and C. -=item B +=item B<< $constraint->coerce($value) >> -Synonym for C. +This will attempt to coerce the value to the type. If the type does not +have any defined coercions this will throw an error. -=item B +If no coercion can produce a value matching C<$constraint>, the original +value is returned. -Returns this type's constraint. This is the value of C provided -when defining a type. +=item B<< $constraint->assert_coerce($value) >> -=item B +This method behaves just like C, but if the result is not valid +according to C<$constraint>, an error is thrown. -Returns true if this type has a message. +=item B<< $constraint->check($value) >> -=item B +Returns true if the given value passes the constraint for the type. -Returns this type's message. +=item B<< $constraint->validate($value) >> -=item B +This is similar to C. However, if the type I then the +method returns an explicit C. If the type is not valid, we call +C<< $self->get_message($value) >> internally to generate an error +message. -Generate message for $value. +=item B<< $constraint->assert_valid($value) >> -=item B +Like C and C, this method checks whether C<$value> is +valid under the constraint. If it is, it will return true. If it is not, +an exception will be thrown with the results of +C<< $self->get_message($value) >>. -Returns true if this type has a coercion. +=item B<< $constraint->name >> -=item B +Returns the type's name, as provided to the constructor. -Returns this type's L if one exists. +=item B<< $constraint->parent >> -=item B +Returns the type's parent, as provided to the constructor, if any. -=item B +=item B<< $constraint->has_parent >> -=item B +Returns true if the type has a parent type. -=back +=item B<< $constraint->parents >> -=head2 DEPRECATED METHOD +A synonym for C. This is useful for polymorphism with types +that can have more than one parent. -=over 4 +=item B<< $constraint->constraint >> + +Returns the type's constraint, as provided to the constructor. + +=item B<< $constraint->get_message($value) >> + +This generates a method for the given value. If the type does not have +an explicit message, we generate a default message. + +=item B<< $constraint->has_message >> + +Returns true if the type has a message. + +=item B<< $constraint->message >> + +Returns the type's message as a subroutine reference. + +=item B<< $constraint->coercion >> + +Returns the type's L object, if one +exists. + +=item B<< $constraint->has_coercion >> + +Returns true if the type has a coercion. + +=item B<< $constraint->hand_optimized_type_constraint >> + +Returns the type's hand optimized constraint, as provided to the +constructor via the C option. + +=item B<< $constraint->has_hand_optimized_type_constraint >> + +Returns true if the type has an optimized constraint. + +=item B<< $constraint->create_child_type(%options) >> -=item B +This returns a new type constraint of the same class using the +provided C<%options>. The C option will be the current type. -This was just bad idea on my part,.. use the L -itself instead. +This method exists so that subclasses of this class can override this +behavior and change how child types are created. =back =head1 BUGS -All complex software has bugs lurking in it, and this module is no -exception. If you find a bug please either email me, or add the bug -to cpan-RT. +See L for details on reporting bugs. =head1 AUTHOR @@ -428,7 +503,7 @@ Stevan Little Estevan@iinteractive.comE =head1 COPYRIGHT AND LICENSE -Copyright 2006-2009 by Infinity Interactive, Inc. +Copyright 2006-2010 by Infinity Interactive, Inc. L