X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FMooseX%2FRole%2FParameterized.pm;h=441c971525c2e12546e4eb6003fcc1d8f1d27d25;hb=988cddaacaeb894ff19773466eecfb19fa26785f;hp=29c17e5572b952659a86c1707f3d4816a5094805;hpb=9d029b3d5e6f027ceea61789982b316c6ba42f09;p=gitmo%2FMooseX-Role-Parameterized.git diff --git a/lib/MooseX/Role/Parameterized.pm b/lib/MooseX/Role/Parameterized.pm index 29c17e5..441c971 100644 --- a/lib/MooseX/Role/Parameterized.pm +++ b/lib/MooseX/Role/Parameterized.pm @@ -1,38 +1,33 @@ package MooseX::Role::Parameterized; - -# ABSTRACT: parameterized roles - use Moose ( extends => { -as => 'moose_extends' }, around => { -as => 'moose_around' }, qw/confess blessed/, ); +moose_extends 'Moose::Exporter'; -use Carp 'croak'; use Moose::Role (); -moose_extends 'Moose::Exporter'; 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,97 +58,99 @@ 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 @_; for (@_) { - croak "Roles do not currently support " + Carp::croak "Roles do not currently support " . 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 @_; for (@_) { - croak "Roles do not currently support " + Carp::croak "Roles do not currently support " . 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 @_; for (@_) { - croak "Roles do not currently support " + Carp::croak "Roles do not currently support " . 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; - croak "Must specify at least one method" unless @_; - $CURRENT_METACLASS->add_required_methods(@_); + my $caller = shift; + my $meta = $CURRENT_METACLASS || Class::MOP::Class->initialize($caller); + + Carp::croak "Must specify at least one method" unless @_; + $meta->add_required_methods(@_); } sub excludes { - confess "excludes must be called within the role { ... } block." - unless $CURRENT_METACLASS; - croak "Must specify at least one role" unless @_; - $CURRENT_METACLASS->add_excluded_roles(@_); + my $caller = shift; + my $meta = $CURRENT_METACLASS || Class::MOP::Class->initialize($caller); + + Carp::croak "Must specify at least one role" unless @_; + $meta->add_excluded_roles(@_); } # see Moose.pm for discussion @@ -163,23 +160,27 @@ 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'" } +sub extends { Carp::croak "Roles do not currently support 'extends'" } -sub inner { croak "Roles cannot support 'inner'" } +sub inner { Carp::croak "Roles cannot support 'inner'" } -sub augment { croak "Roles cannot support 'augment'" } +sub augment { Carp::croak "Roles cannot support 'augment'" } 1; __END__ +=head1 NAME + +MooseX::Role::Parameterized - parameterized roles + =head1 SYNOPSIS package MyRole::Counter; @@ -241,20 +242,14 @@ 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 sub { ... };>. This is due to a limitation in Perl. In return -though you can use parameters I! - -You must use all the keywords in the role block. If it turns out to be correct, -we'll compose the parameterizable role (everything outside the role block) with -the parameterized role (everything inside the role block). We throw an error if -you try to use a keyword outside of the role block, so don't worry about it for -now. +C<< method NAME => sub { ... }; >>. This is due to a limitation in Perl. In +return though you can use parameters I! L and L are not yet supported. I'm completely unsure of whether they should be handled by this module. Until we @@ -265,5 +260,9 @@ C is an error. Shawn M Moore, C<< >> +=head1 SEE ALSO + +L + =cut