Changes to work with 0.78 meta-instance code, which no longer expects

[gitmo/Moose.git] / lib / Moose / Meta / TypeConstraint.pm

diff --git a/lib/Moose/Meta/TypeConstraint.pm b/lib/Moose/Meta/TypeConstraint.pm
index 686183a..16c8d6b 100644 (file)
--- a/lib/Moose/Meta/TypeConstraint.pm
+++ b/lib/Moose/Meta/TypeConstraint.pm
@@ -12,7 +12,7 @@ use Scalar::Util qw(blessed refaddr);
 
 use base qw(Class::MOP::Object);
 
-our $VERSION   = '0.57';
+our $VERSION   = '0.71';
 $VERSION = eval $VERSION;
 our $AUTHORITY = 'cpan:STEVAN';
 
@@ -36,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',
@@ -59,14 +60,37 @@ __PACKAGE__->meta->add_attribute('package_defined_in' => (
 
 sub new {
     my $class = shift;
-    my $self  = $class->_new(@_);
+    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 || Moose::throw_error("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)) {
@@ -153,10 +177,12 @@ sub _actually_compile_type_constraint {
         if $self->has_hand_optimized_type_constraint;
 
     my $check = $self->constraint;
-    (defined $check)
-        || Moose::throw_error("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;
@@ -169,7 +195,11 @@ sub _compile_hand_optimized_type_constraint {
 
     my $type_constraint = $self->hand_optimized_type_constraint;
 
-    Moose::throw_error("Hand optimized type constraint is not a code reference") 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;
 }
@@ -204,8 +234,9 @@ sub _compile_subtype {
         } else {
             return Class::MOP::subname($self->name, sub {
                 return undef unless $optimized_parent->($_[0]);
-                local $_ = $_[0];
-                $check->($_[0]);
+                my (@args) = @_;
+                local $_ = $args[0];
+                $check->(@args);
             });
         }
     } else {
@@ -213,9 +244,10 @@ sub _compile_subtype {
         my @checks = @parents;
         push @checks, $check if $check != $null_constraint;
         return Class::MOP::subname($self->name => sub {
-            local $_ = $_[0];
+            my (@args) = @_;
+            local $_ = $args[0];
             foreach my $check (@checks) {
-                return undef unless $check->($_[0]);
+                return undef unless $check->(@args);
             }
             return 1;
         });
@@ -228,8 +260,9 @@ sub _compile_type {
     return $check if $check == $null_constraint; # Item, Any
 
     return Class::MOP::subname($self->name => sub {
-        local $_ = $_[0];
-        $check->($_[0]);
+        my (@args) = @_;
+        local $_ = $args[0];
+        $check->(@args);
     });
 }
 
@@ -246,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" }
@@ -323,7 +362,7 @@ The name of the type in the global type registry.
 
 =item B<parent>
 
-This type's parent  type.
+This type's parent type.
 
 =item B<has_parent>
 
@@ -331,22 +370,39 @@ Returns true if this type has a parent type.
 
 =item B<parents>
 
+Synonym for C<parent>.
+
 =item B<constraint>
 
+Returns this type's constraint.  This is the value of C<where> provided
+when defining a type.
+
 =item B<has_message>
 
+Returns true if this type has a message.
+
 =item B<message>
 
+Returns this type's message.
+
 =item B<get_message ($value)>
 
+Generate message for $value.
+
 =item B<has_coercion>
 
+Returns true if this type has a coercion.
+
 =item B<coercion>
 
+Returns this type's L<Moose::Meta::TypeCoercion> if one exists.
+
 =item B<hand_optimized_type_constraint>
 
 =item B<has_hand_optimized_type_constraint>
 
+=item B<create_child_type>
+
 =back
 
 =head2 DEPRECATED METHOD
@@ -372,7 +428,7 @@ Stevan Little E<lt>stevan@iinteractive.comE<gt>
 
 =head1 COPYRIGHT AND LICENSE
 
-Copyright 2006-2008 by Infinity Interactive, Inc.
+Copyright 2006-2009 by Infinity Interactive, Inc.
 
 L<http://www.iinteractive.com>