Make coercion work for parameterized types

[gitmo/Mouse.git] / lib / Mouse / Meta / Attribute.pm

diff --git a/lib/Mouse/Meta/Attribute.pm b/lib/Mouse/Meta/Attribute.pm
index c4b5e01..42b1d39 100644 (file)
--- a/lib/Mouse/Meta/Attribute.pm
+++ b/lib/Mouse/Meta/Attribute.pm
@@ -7,17 +7,16 @@ use Carp 'confess';
 use Scalar::Util ();
 
 sub new {
-    my $class = shift;
-    my %args  = @_;
+    my ($class, $name, %options) = @_;
 
-    my $name = $args{name};
+    $options{name} = $name;
 
-    $args{init_arg} = $name
-        unless exists $args{init_arg};
+    $options{init_arg} = $name
+        unless exists $options{init_arg};
 
-    $args{is} ||= '';
+    $options{is} ||= '';
 
-    bless \%args, $class;
+    bless \%options, $class;
 }
 
 sub name                 { $_[0]->{name}                   }
@@ -76,14 +75,14 @@ sub generate_accessor {
 
     my $accessor = "sub {\n";
     if ($attribute->_is_metadata eq 'rw') {
-        $accessor .= 'if (scalar(@_) >= 2) {' . "\n";
+        $accessor .= 'if (@_ >= 2) {' . "\n";
 
         my $value = '$_[1]';
 
         if ($constraint) {
             $accessor .= 'my $val = ';
             if ($should_coerce) {
-                $accessor  .= 'Mouse::TypeRegistry->typecast_constraints("'.$attribute->associated_class->name.'", $attribute->{find_type_constraint}, $attribute->{type_constraint}, '.$value.');';
+                $accessor  .= 'Mouse::Util::TypeConstraints->typecast_constraints("'.$attribute->associated_class->name.'", $attribute->{find_type_constraint}, $attribute->{type_constraint}, '.$value.');';
             } else {
                 $accessor .= $value.';';
             }
@@ -192,6 +191,59 @@ sub generate_handles {
     return \%method_map;
 }
 
+my $optimized_constraints;
+sub _build_type_constraint {
+    my $spec = shift;
+    $optimized_constraints ||= Mouse::Util::TypeConstraints->optimized_constraints;
+    my $code;
+    if ($spec =~ /^([^\[]+)\[(.+)\]$/) {
+        # parameterized
+        my $constraint = $1;
+        my $param      = $2;
+        my $parent     = _build_type_constraint($constraint);
+        my $child      = _build_type_constraint($param);
+        if ($constraint eq 'ArrayRef') {
+            my $code_str = 
+                "sub {\n" .
+                "    if (\$parent->(\$_)) {\n" .
+                "        foreach my \$e (@\$_) {\n" .
+                "            local \$_ = \$e;\n" .
+                "            return () unless \$child->(\$_);\n" .
+                "        }\n" .
+                "        return 1;\n" .
+                "    }\n" .
+                "    return ();\n" .
+                "};\n"
+            ;
+            $code = eval $code_str or Carp::confess($@);
+        } elsif ($constraint eq 'HashRef') {
+            my $code_str = 
+                "sub {\n" .
+                "    if (\$parent->(\$_)) {\n" .
+                "        foreach my \$e (values %\$_) {\n" .
+                "            local \$_ = \$e;\n" .
+                "            return () unless \$child->(\$_);\n" .
+                "        }\n" .
+                "        return 1;\n" .
+                "    }\n" .
+                "    return ();\n" .
+                "};\n"
+            ;
+            $code = eval $code_str or Carp::confess($@);
+        } else {
+            Carp::confess("Support for parameterized types other than ArrayRef or HashRef is not implemented yet");
+        }
+        $optimized_constraints->{$spec} = $code;
+    } else {
+        $code = $optimized_constraints->{ $spec };
+        if (! $code) {
+            $code = sub { Scalar::Util::blessed($_) && $_->isa($spec) };
+            $optimized_constraints->{$spec} = $code;
+        }
+    }
+    return $code;
+}
+
 sub create {
     my ($self, $class, $name, %args) = @_;
 
@@ -205,21 +257,22 @@ sub create {
         if exists $args{coerce};
 
     if (exists $args{isa}) {
+        warn "Got isa => $args{isa}, but Mouse does not yet support parameterized types for containers other than ArrayRef and HashRef (rt.cpan.org #39795)"
+            if $args{isa} =~ /^([^\[]+)\[.+\]$/ &&
+               $1 ne 'ArrayRef' &&
+               $1 ne 'HashRef';
+
         my $type_constraint = delete $args{isa};
         $type_constraint =~ s/\s//g;
         my @type_constraints = split /\|/, $type_constraint;
 
         my $code;
-        my $optimized_constraints = Mouse::TypeRegistry->optimized_constraints;
         if (@type_constraints == 1) {
-            $code = $optimized_constraints->{$type_constraints[0]} ||
-                sub { Scalar::Util::blessed($_) && $_->isa($type_constraints[0]) };
+            $code = _build_type_constraint($type_constraints[0]);
             $args{type_constraint} = $type_constraints[0];
         } else {
             my @code_list = map {
-                my $type = $_;
-                $optimized_constraints->{$type} ||
-                    sub { Scalar::Util::blessed($_) && $_->isa($type) }
+                _build_type_constraint($_)
             } @type_constraints;
             $code = sub {
                 for my $code (@code_list) {
@@ -232,7 +285,7 @@ sub create {
         $args{find_type_constraint} = $code;
     }
 
-    my $attribute = $self->new(%args);
+    my $attribute = $self->new($name, %args);
 
     $attribute->_create_args(\%args);
 
@@ -323,7 +376,7 @@ sub validate_args {
     return 1;
 }
 
-sub verify_type_constraint {
+sub verify_against_type_constraint {
     return 1 unless $_[0]->{type_constraint};
 
     local $_ = $_[1];
@@ -343,7 +396,7 @@ sub verify_type_constraint_error {
 sub coerce_constraint { ## my($self, $value) = @_;
     my $type = $_[0]->{type_constraint}
         or return $_[1];
-    return Mouse::TypeRegistry->typecast_constraints($_[0]->associated_class->name, $_[0]->find_type_constraint, $type, $_[1]);
+    return Mouse::Util::TypeConstraints->typecast_constraints($_[0]->associated_class->name, $_[0]->find_type_constraint, $type, $_[1]);
 }
 
 sub _canonicalize_handles {
@@ -470,7 +523,7 @@ Creates a new code reference for each of the attribute's handles methods.
 Returns a code reference which can be used to check that a given value passes
 this attribute's type constraint;
 
-=head2 verify_type_constraint Item -> 1 | ERROR
+=head2 verify_against_type_constraint Item -> 1 | ERROR
 
 Checks that the given value passes this attribute's type constraint. Returns 1
 on success, otherwise C<confess>es.