X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FMooseX%2FRole%2FParameterized.pm;h=ae24e210f84356bbb84e77b9e943c354153d2393;hb=c190fb29393d3ba7a7e37d138e5bd84197744a13;hp=8d3ee66ca40de3d745d0c64321676c0763e117b8;hpb=d9e02904b2452dfcbbd103fd47287e266e0ca173;p=gitmo%2FMooseX-Role-Parameterized.git

diff --git a/lib/MooseX/Role/Parameterized.pm b/lib/MooseX/Role/Parameterized.pm
index 8d3ee66..ae24e21 100644
--- a/lib/MooseX/Role/Parameterized.pm
+++ b/lib/MooseX/Role/Parameterized.pm
@@ -1,7 +1,5 @@
 package MooseX::Role::Parameterized;
 
-# ABSTRACT: parameterized roles
-
 use Moose (
     extends => { -as => 'moose_extends' },
     around  => { -as => 'moose_around' },
@@ -17,22 +15,21 @@ use MooseX::Role::Parameterized::Meta::Role::Parameterizable;
 our $CURRENT_METACLASS;
 
 __PACKAGE__->setup_import_methods(
-    with_caller => ['parameter', 'role', 'method'],
-    as_is       => [
-        'has', 'with', 'extends', 'requires', 'excludes', 'augment', 'inner',
-        'before', 'after', 'around', 'super', 'override', 'confess',
-        'blessed',
-    ],
+    with_caller => ['parameter', 'role', 'method', 'has', 'with', 'extends',
+                    'requires', 'excludes', 'augment', 'inner', 'before',
+                    'after', 'around', 'super', 'override'],
+    as_is => [ 'confess', 'blessed' ],
 );
 
 sub parameter {
     my $caller = shift;
-    my $names  = shift;
+    my $meta   = Class::MOP::Class->initialize($caller);
 
+    my $names = shift;
     $names = [$names] if !ref($names);
 
     for my $name (@$names) {
-        Class::MOP::Class->initialize($caller)->add_parameter($name, @_);
+        $meta->add_parameter($name, @_);
     }
 }
 
@@ -63,37 +60,36 @@ moose_around _make_wrapper => sub {
 };
 
 sub has {
-    confess "has must be called within the role { ... } block."
-        unless $CURRENT_METACLASS;
+    my $caller = shift;
+    my $meta   = $CURRENT_METACLASS || Class::MOP::Class->initialize($caller);
 
     my $names = shift;
     $names = [$names] if !ref($names);
 
     for my $name (@$names) {
-        $CURRENT_METACLASS->add_attribute($name, @_);
+        $meta->add_attribute($name, @_);
     }
 }
 
 sub method {
-    confess "method must be called within the role { ... } block."
-        unless $CURRENT_METACLASS;
-
     my $caller = shift;
+    my $meta   = $CURRENT_METACLASS || Class::MOP::Class->initialize($caller);
+
     my $name   = shift;
     my $body   = shift;
 
-    my $method = $CURRENT_METACLASS->method_metaclass->wrap(
+    my $method = $meta->method_metaclass->wrap(
         package_name => $caller,
         name         => $name,
         body         => $body,
     );
 
-    $CURRENT_METACLASS->add_method($name => $method);
+    $meta->add_method($name => $method);
 }
 
 sub before {
-    confess "before must be called within the role { ... } block."
-        unless $CURRENT_METACLASS;
+    my $caller = shift;
+    my $meta   = $CURRENT_METACLASS || Class::MOP::Class->initialize($caller);
 
     my $code = pop @_;
 
@@ -102,13 +98,13 @@ sub before {
             . ref($_)
             . " references for before method modifiers"
             if ref $_;
-        $CURRENT_METACLASS->add_before_method_modifier($_, $code);
+        $meta->add_before_method_modifier($_, $code);
     }
 }
 
 sub after {
-    confess "after must be called within the role { ... } block."
-        unless $CURRENT_METACLASS;
+    my $caller = shift;
+    my $meta   = $CURRENT_METACLASS || Class::MOP::Class->initialize($caller);
 
     my $code = pop @_;
 
@@ -117,13 +113,13 @@ sub after {
             . ref($_)
             . " references for after method modifiers"
             if ref $_;
-        $CURRENT_METACLASS->add_after_method_modifier($_, $code);
+        $meta->add_after_method_modifier($_, $code);
     }
 }
 
 sub around {
-    confess "around must be called within the role { ... } block."
-        unless $CURRENT_METACLASS;
+    my $caller = shift;
+    my $meta   = $CURRENT_METACLASS || Class::MOP::Class->initialize($caller);
 
     my $code = pop @_;
 
@@ -132,28 +128,31 @@ sub around {
             . ref($_)
             . " references for around method modifiers"
             if ref $_;
-        $CURRENT_METACLASS->add_around_method_modifier($_, $code);
+        $meta->add_around_method_modifier($_, $code);
     }
 }
 
 sub with {
-    confess "with must be called within the role { ... } block."
-        unless $CURRENT_METACLASS;
-    Moose::Util::apply_all_roles($CURRENT_METACLASS, @_);
+    my $caller = shift;
+    my $meta   = $CURRENT_METACLASS || Class::MOP::Class->initialize($caller);
+
+    Moose::Util::apply_all_roles($meta, @_);
 }
 
 sub requires {
-    confess "requires must be called within the role { ... } block."
-        unless $CURRENT_METACLASS;
+    my $caller = shift;
+    my $meta   = $CURRENT_METACLASS || Class::MOP::Class->initialize($caller);
+
     croak "Must specify at least one method" unless @_;
-    $CURRENT_METACLASS->add_required_methods(@_);
+    $meta->add_required_methods(@_);
 }
 
 sub excludes {
-    confess "excludes must be called within the role { ... } block."
-        unless $CURRENT_METACLASS;
+    my $caller = shift;
+    my $meta   = $CURRENT_METACLASS || Class::MOP::Class->initialize($caller);
+
     croak "Must specify at least one role" unless @_;
-    $CURRENT_METACLASS->add_excluded_roles(@_);
+    $meta->add_excluded_roles(@_);
 }
 
 # see Moose.pm for discussion
@@ -163,11 +162,11 @@ sub super {
 }
 
 sub override {
-    confess "override must be called within the role { ... } block."
-        unless $CURRENT_METACLASS;
+    my $caller = shift;
+    my $meta   = $CURRENT_METACLASS || Class::MOP::Class->initialize($caller);
 
     my ($name, $code) = @_;
-    $CURRENT_METACLASS->add_override_method_modifier($name, $code);
+    $meta->add_override_method_modifier($name, $code);
 }
 
 sub extends { croak "Roles do not currently support 'extends'" }
@@ -180,6 +179,10 @@ sub augment { croak "Roles cannot support 'augment'" }
 
 __END__
 
+=head1 NAME
+
+MooseX::Role::Parameterized - parameterized roles
+
 =head1 SYNOPSIS
 
     package MyRole::Counter;
@@ -241,18 +244,19 @@ customizable!
 
 There are many paths to parameterized roles (hopefully with a consistent enough
 API); I believe this to be the easiest and most flexible implementation.
-Coincidentally, Pugs has a very similar design (I'm not convinced that that is
-a good thing yet).
+Coincidentally, Pugs has a very similar design (I'm not yet convinced that that
+is a good thing).
 
 =head1 CAVEATS
 
 You must use this syntax to declare methods in the role block:
-C<method NAME => sub { ... };>. This is due to a limitation in Perl. In return
-though you can use parameters I<in your methods>!
+C<< method NAME => sub { ... }; >>. This is due to a limitation in Perl. In
+return though you can use parameters I<in your methods>!
 
-L<Moose::Role/alias> and L<Moose::Role/excludes> are not yet supported. Because
-I'm totally unsure of whether they should be handled by this module, both
-declaring and providing a parameter named C<alias> or C<excludes> is an error.
+L<Moose::Role/alias> and L<Moose::Role/excludes> are not yet supported. I'm
+completely unsure of whether they should be handled by this module. Until we
+figure out a plan, both declaring and providing a parameter named C<alias> or
+C<excludes> is an error.
 
 =head1 AUTHOR