X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FMoose%2FMeta%2FTypeConstraint.pm;h=16c8d6bb6f7239c7aeef47dc40f89a57f6386b5b;hb=eae37c67268fb05d0f2bc5473c38710a4a726f11;hp=e2109c6c5d6d039d744a0a74dbb2e0ca929f64a1;hpb=cce8198ba52519eaf60ebb1121fb8304537cb4a5;p=gitmo%2FMoose.git diff --git a/lib/Moose/Meta/TypeConstraint.pm b/lib/Moose/Meta/TypeConstraint.pm index e2109c6..16c8d6b 100644 --- a/lib/Moose/Meta/TypeConstraint.pm +++ b/lib/Moose/Meta/TypeConstraint.pm @@ -5,15 +5,29 @@ use strict; use warnings; use metaclass; -use Sub::Name 'subname'; -use Carp 'confess'; -use Scalar::Util 'blessed'; +use overload '""' => sub { shift->name }, # stringify to tc name + fallback => 1; -our $VERSION = '0.03'; +use Scalar::Util qw(blessed refaddr); -__PACKAGE__->meta->add_attribute('name' => (reader => 'name' )); -__PACKAGE__->meta->add_attribute('parent' => (reader => 'parent' )); -__PACKAGE__->meta->add_attribute('constraint' => (reader => 'constraint')); +use base qw(Class::MOP::Object); + +our $VERSION = '0.71'; +$VERSION = eval $VERSION; +our $AUTHORITY = 'cpan:STEVAN'; + +__PACKAGE__->meta->add_attribute('name' => (reader => 'name')); +__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 { $null_constraint } +)); __PACKAGE__->meta->add_attribute('message' => ( accessor => 'message', predicate => 'has_message' @@ -23,141 +37,258 @@ __PACKAGE__->meta->add_attribute('coercion' => ( predicate => 'has_coercion' )); -# private accessor +__PACKAGE__->meta->add_attribute('hand_optimized_type_constraint' => ( + init_arg => 'optimized', + accessor => 'hand_optimized_type_constraint', + predicate => 'has_hand_optimized_type_constraint', +)); + +sub parents { + my $self; + $self->parent; +} + +# private accessors + __PACKAGE__->meta->add_attribute('compiled_type_constraint' => ( - accessor => '_compiled_type_constraint' + accessor => '_compiled_type_constraint', + predicate => '_has_compiled_type_constraint' +)); +__PACKAGE__->meta->add_attribute('package_defined_in' => ( + accessor => '_package_defined_in' )); -sub new { +sub new { my $class = shift; - my $self = $class->meta->new_object(@_); - $self->compile_type_constraint(); + 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 compile_type_constraint { - my $self = shift; - my $check = $self->constraint; - (defined $check) - || confess "Could not compile type constraint '" . $self->name . "' because no constraint check"; - my $parent = $self->parent; - if (defined $parent) { - # we have a subtype ... - $parent = $parent->_compiled_type_constraint; - $self->_compiled_type_constraint(subname $self->name => sub { - local $_ = $_[0]; - return undef unless defined $parent->($_[0]) && $check->($_[0]); - 1; - }); - } - else { - # we have a type .... - $self->_compiled_type_constraint(subname $self->name => sub { - local $_ = $_[0]; - return undef unless $check->($_[0]); - 1; - }); + + +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 { $_[0]->_compiled_type_constraint->($_[1]) } +sub check { + my ($self, @args) = @_; + my $constraint_subref = $self->_compiled_type_constraint; + return $constraint_subref->(@args) ? 1 : undef; +} -sub validate { +sub validate { my ($self, $value) = @_; if ($self->_compiled_type_constraint->($value)) { return undef; } else { - if ($self->has_message) { - local $_ = $value; - return $self->message->($value); - } - else { - return "Validation failed for '" . $self->name . "' failed"; - } + $self->get_message($value); } } +sub get_message { + my ($self, $value) = @_; + 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"; + } +} + +## type predicates ... + +sub equals { + my ( $self, $type_or_name ) = @_; + + my $other = Moose::Util::TypeConstraints::find_type_constraint($type_or_name) or return; + + 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) or return; + + ($self->equals($type) || $self->is_subtype_of($type)); +} + sub is_subtype_of { - my ($self, $type_name) = @_; + my ($self, $type_or_name) = @_; + + my $type = Moose::Util::TypeConstraints::find_type_constraint($type_or_name) or return; + my $current = $self; + while (my $parent = $current->parent) { - return 1 if $parent->name eq $type_name; + return 1 if $parent->equals($type); $current = $parent; } + return 0; } -sub union { - my ($class, @type_constraints) = @_; - (scalar @type_constraints >= 2) - || confess "You must pass in at least 2 Moose::Meta::TypeConstraint instances to make a union"; - (blessed($_) && $_->isa('Moose::Meta::TypeConstraint')) - || confess "You must pass in only Moose::Meta::TypeConstraint instances to make unions" - foreach @type_constraints; - return Moose::Meta::TypeConstraint::Union->new( - type_constraints => \@type_constraints - ); +## compiling the type constraint + +sub compile_type_constraint { + my $self = shift; + $self->_compiled_type_constraint($self->_actually_compile_type_constraint); } -package Moose::Meta::TypeConstraint::Union; +## type compilers ... -use strict; -use warnings; -use metaclass; +sub _actually_compile_type_constraint { + my $self = shift; -our $VERSION = '0.01'; + return $self->_compile_hand_optimized_type_constraint + if $self->has_hand_optimized_type_constraint; -__PACKAGE__->meta->add_attribute('type_constraints' => ( - accessor => 'type_constraints', - default => sub { [] } -)); + my $check = $self->constraint; + unless ( defined $check ) { + require Moose; + Moose->throw_error( "Could not compile type constraint '" + . $self->name + . "' because no constraint check" ); + } -sub new { - my $class = shift; - my $self = $class->meta->new_object(@_); - return $self; -} + return $self->_compile_subtype($check) + if $self->has_parent; -sub name { join ' | ' => map { $_->name } @{$_[0]->type_constraints} } + return $self->_compile_type($check); +} -# NOTE: -# this should probably never be used -# but we include it here for completeness -sub constraint { +sub _compile_hand_optimized_type_constraint { my $self = shift; - sub { $self->check($_[0]) }; + + my $type_constraint = $self->hand_optimized_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; } -# conform to the TypeConstraint API -sub parent { undef } -sub coercion { undef } -sub has_coercion { 0 } -sub message { undef } -sub has_message { 0 } +sub _compile_subtype { + my ($self, $check) = @_; + + # 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) { + push @parents => $optimized_parent = $parent->hand_optimized_type_constraint; + last; + } + else { + push @parents => $parent->constraint; + } + } -sub check { - my $self = shift; - my $value = shift; - foreach my $type (@{$self->type_constraints}) { - return 1 if $type->check($value); + @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); + }); + } + } 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; + }); } - return undef; } -sub validate { - my $self = shift; - my $value = shift; - my $message; - foreach my $type (@{$self->type_constraints}) { - my $err = $type->validate($value); - return unless defined $err; - $message .= ($message ? ' and ' : '') . $err - if defined $err; +sub _compile_type { + my ($self, $check) = @_; + + return $check if $check == $null_constraint; # Item, Any + + return Class::MOP::subname($self->name => sub { + my (@args) = @_; + local $_ = $args[0]; + $check->(@args); + }); +} + +## other utils ... + +sub _collect_all_parents { + my $self = shift; + my @parents; + my $current = $self->parent; + while (defined $current) { + push @parents => $current; + $current = $current->parent; } - return ($message . ' in (' . $self->name . ')') ; + 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" } + 1; __END__ @@ -170,13 +301,13 @@ 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 +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 +If you wish to use features at this depth, please come to the #moose IRC channel on irc.perl.org and we can talk :) =head1 METHODS @@ -187,47 +318,107 @@ If you wish to use features at this depth, please come to the =item B -=item B +=item B + +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. + +=item B + +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. + +=item B + +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. =item B +=item B + +This will apply the type-coercion if applicable. + =item B -This method will return a true (C<1>) if the C<$value> passes the +This method will return a true (C<1>) if the C<$value> passes the constraint, and false (C<0>) otherwise. =item B -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. +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. =item B +The name of the type in the global type registry. + =item B +This type's parent type. + +=item B + +Returns true if this type has a parent type. + +=item B + +Synonym for C. + =item B +Returns this type's constraint. This is the value of C provided +when defining a type. + =item B +Returns true if this type has a message. + =item B +Returns this type's message. + +=item B + +Generate message for $value. + =item B +Returns true if this type has a coercion. + =item B +Returns this type's L if one exists. + +=item B + +=item B + +=item B + =back +=head2 DEPRECATED METHOD + =over 4 -=item B +=item B + +This was just bad idea on my part,.. use the L +itself instead. =back =head1 BUGS -All complex software has bugs lurking in it, and this module is no +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. @@ -237,11 +428,11 @@ Stevan Little Estevan@iinteractive.comE =head1 COPYRIGHT AND LICENSE -Copyright 2006 by Infinity Interactive, Inc. +Copyright 2006-2009 by Infinity Interactive, Inc. L This library is free software; you can redistribute it and/or modify -it under the same terms as Perl itself. +it under the same terms as Perl itself. -=cut \ No newline at end of file +=cut