X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FMoose%2FMeta%2FTypeConstraint.pm;h=876d80c786f455c4b6dc331f79796a19f8fb7581;hb=cfd006f0b8626746aedb71e4fe8fb7de21ec5497;hp=a10fffcbbcf805648672950a5e28005e6336e847;hpb=bd72f3c88bf8fae9e98361acae65bb51691eabeb;p=gitmo%2FMoose.git diff --git a/lib/Moose/Meta/TypeConstraint.pm b/lib/Moose/Meta/TypeConstraint.pm index a10fffc..876d80c 100644 --- a/lib/Moose/Meta/TypeConstraint.pm +++ b/lib/Moose/Meta/TypeConstraint.pm @@ -8,11 +8,12 @@ use metaclass; use overload '""' => sub { shift->name }, # stringify to tc name fallback => 1; -use Sub::Name 'subname'; -use Carp 'confess'; -use Scalar::Util 'blessed'; +use Scalar::Util qw(blessed refaddr); -our $VERSION = '0.12'; +use base qw(Class::MOP::Object); + +our $VERSION = '0.72'; +$VERSION = eval $VERSION; our $AUTHORITY = 'cpan:STEVAN'; __PACKAGE__->meta->add_attribute('name' => (reader => 'name')); @@ -20,10 +21,12 @@ __PACKAGE__->meta->add_attribute('parent' => ( reader => 'parent', predicate => 'has_parent', )); + +my $null_constraint = sub { 1 }; __PACKAGE__->meta->add_attribute('constraint' => ( reader => 'constraint', writer => '_set_constraint', - default => sub { sub { 1 } } + default => sub { $null_constraint } )); __PACKAGE__->meta->add_attribute('message' => ( accessor => 'message', @@ -33,6 +36,7 @@ __PACKAGE__->meta->add_attribute('coercion' => ( accessor => 'coercion', predicate => 'has_coercion' )); + __PACKAGE__->meta->add_attribute('hand_optimized_type_constraint' => ( init_arg => 'optimized', accessor => 'hand_optimized_type_constraint', @@ -56,14 +60,37 @@ __PACKAGE__->meta->add_attribute('package_defined_in' => ( sub new { my $class = shift; - my $self = $class->meta->new_object(@_); + my ($first, @rest) = @_; + my %args = ref $first ? %$first : $first ? ($first, @rest) : (); + $args{name} = $args{name} ? "$args{name}" : "__ANON__"; + + my $self = $class->_new(%args); $self->compile_type_constraint() unless $self->_has_compiled_type_constraint; return $self; } -sub coerce { ((shift)->coercion || confess "Cannot coerce without a type coercion")->coerce(@_) } -sub check { $_[0]->_compiled_type_constraint->($_[1]) ? 1 : undef } + + +sub coerce { + my $self = shift; + + my $coercion = $self->coercion; + + unless ($coercion) { + require Moose; + Moose->throw_error("Cannot coerce without a type coercion"); + } + + return $coercion->coerce(@_); +} + +sub check { + my ($self, @args) = @_; + my $constraint_subref = $self->_compiled_type_constraint; + return $constraint_subref->(@args) ? 1 : undef; +} + sub validate { my ($self, $value) = @_; if ($self->_compiled_type_constraint->($value)) { @@ -76,12 +103,12 @@ sub validate { sub get_message { my ($self, $value) = @_; - $value = (defined $value ? overload::StrVal($value) : 'undef'); if (my $msg = $self->message) { local $_ = $value; return $msg->($value); } else { + $value = (defined $value ? overload::StrVal($value) : 'undef'); return "Validation failed for '" . $self->name . "' failed with value $value"; } } @@ -91,15 +118,30 @@ sub get_message { sub equals { my ( $self, $type_or_name ) = @_; - my $type = Moose::Util::TypeConstraints::find_type_constraint($type_or_name); + my $other = Moose::Util::TypeConstraints::find_type_constraint($type_or_name) or return; - $self->name eq $type->name; + return 1 if refaddr($self) == refaddr($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; + } + + return unless $self->constraint == $other->constraint; + + if ( $self->has_parent ) { + return unless $other->has_parent; + return unless $self->parent->equals( $other->parent ); + } else { + return if $other->has_parent; + } + + return 1; } sub is_a_type_of { my ($self, $type_or_name) = @_; - my $type = Moose::Util::TypeConstraints::find_type_constraint($type_or_name); + my $type = Moose::Util::TypeConstraints::find_type_constraint($type_or_name) or return; ($self->equals($type) || $self->is_subtype_of($type)); } @@ -107,7 +149,7 @@ sub is_a_type_of { sub is_subtype_of { my ($self, $type_or_name) = @_; - my $type = Moose::Util::TypeConstraints::find_type_constraint($type_or_name); + my $type = Moose::Util::TypeConstraints::find_type_constraint($type_or_name) or return; my $current = $self; @@ -135,10 +177,12 @@ sub _actually_compile_type_constraint { if $self->has_hand_optimized_type_constraint; my $check = $self->constraint; - (defined $check) - || confess "Could not compile type constraint '" + unless ( defined $check ) { + require Moose; + Moose->throw_error( "Could not compile type constraint '" . $self->name - . "' because no constraint check"; + . "' because no constraint check" ); + } return $self->_compile_subtype($check) if $self->has_parent; @@ -151,7 +195,11 @@ sub _compile_hand_optimized_type_constraint { my $type_constraint = $self->hand_optimized_type_constraint; - confess unless ref $type_constraint; + unless ( ref $type_constraint ) { + require Moose; + Carp::confess ("Hand optimized type constraint for " . $self->name . " is not a code reference"); + Moose->throw_error("Hand optimized type constraint is not a code reference"); + } return $type_constraint; } @@ -159,38 +207,63 @@ sub _compile_hand_optimized_type_constraint { sub _compile_subtype { my ($self, $check) = @_; - # so we gather all the parents in order - # and grab their constraints ... + # gather all the parent constraintss in order my @parents; + my $optimized_parent; foreach my $parent ($self->_collect_all_parents) { + # if a parent is optimized, the optimized constraint already includes + # all of its parents tcs, so we can break the loop if ($parent->has_hand_optimized_type_constraint) { - unshift @parents => $parent->hand_optimized_type_constraint; + push @parents => $optimized_parent = $parent->hand_optimized_type_constraint; last; } else { - unshift @parents => $parent->constraint; + push @parents => $parent->constraint; } } - # then we compile them to run without - # having to recurse as we did before - return subname $self->name => sub { - local $_ = $_[0]; - foreach my $parent (@parents) { - return undef unless $parent->($_[0]); + @parents = grep { $_ != $null_constraint } reverse @parents; + + unless ( @parents ) { + return $self->_compile_type($check); + } elsif( $optimized_parent and @parents == 1 ) { + # the case of just one optimized parent is optimized to prevent + # looping and the unnecessary localization + if ( $check == $null_constraint ) { + return $optimized_parent; + } else { + return Class::MOP::subname($self->name, sub { + return undef unless $optimized_parent->($_[0]); + my (@args) = @_; + local $_ = $args[0]; + $check->(@args); + }); } - return undef unless $check->($_[0]); - 1; - }; + } else { + # 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 { + my (@args) = @_; + local $_ = $args[0]; + foreach my $check (@checks) { + return undef unless $check->(@args); + } + return 1; + }); + } } sub _compile_type { my ($self, $check) = @_; - return subname $self->name => sub { - local $_ = $_[0]; - return undef unless $check->($_[0]); - 1; - }; + + return $check if $check == $null_constraint; # Item, Any + + return Class::MOP::subname($self->name => sub { + my (@args) = @_; + local $_ = $args[0]; + $check->(@args); + }); } ## other utils ... @@ -206,6 +279,12 @@ sub _collect_all_parents { return @parents; } +sub create_child_type { + my ($self, %opts) = @_; + my $class = ref $self; + return $class->new(%opts, parent => $self); +} + ## this should get deprecated actually ... sub union { Carp::croak "DEPRECATED" } @@ -222,84 +301,146 @@ 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. - -If you wish to use features at this depth, please come to the -#moose IRC channel on irc.perl.org and we can talk :) +This class represents a single type constraint. Moose's built-in type +constraints, as well as constraints you define, are all store in a +L object as objects of this +class. =head1 METHODS =over 4 -=item B +=item B<< Moose::Meta::TypeConstraint->new(%options) >> -=item B +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 name, and if it does not match, -checks if it is a subtype of it. +The constraint name. If a name is not provided, it will be set to +"__ANON__". -=item B +=item * parent -=item B +A C object which is the parent type for +the type being created. This is optional. -=item B +=item * constraint -This will apply the type-coercion if applicable. +This is the subroutine reference that implements the actual constraint +check. This defaults to a subroutine which always returns true. -=item B +=item * message -This method will return a true (C<1>) if the C<$value> passes the -constraint, and false (C<0>) otherwise. +A subroutine reference which is used to generate an error message when +the constraint fails. This is optional. -=item B +=item * coercion -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. +A L object representing the coercions to +the type. This is optional. -=item B +=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. -=item B +=back -=item B +=item B<< $constraint->equals($type_name_or_object) >> -=item B +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) >> -=item B +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) >> -=item B +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) >> -=item B +This will attempt to coerce the value to the type. If the type does +have any defined coercions this will throw an error. -=item B +=item B<< $constraint->check($value) >> -=back +Returns true if the given value passes the constraint for the type. -=head2 DEPRECATED METHOD +=item B<< $constraint->validate($value) >> -=over 4 +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. + +=item B<< $constraint->name >> + +Returns the type's name, as provided to the constructor. + +=item B<< $constraint->parent >> + +Returns the type's parent, as provided to the constructor, if any. + +=item B<< $constraint->has_parent >> + +Returns true if the type has a parent type. + +=item B<< $constraint->parents >> + +A synonym for C. This is useful for polymorphism with types +that can have more than one parent. + +=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 @@ -315,7 +456,7 @@ Stevan Little Estevan@iinteractive.comE =head1 COPYRIGHT AND LICENSE -Copyright 2006-2008 by Infinity Interactive, Inc. +Copyright 2006-2009 by Infinity Interactive, Inc. L