package MooseX::Role::Parameterized;
-# ABSTRACT: parameterized roles
-
use Moose (
extends => { -as => 'moose_extends' },
around => { -as => 'moose_around' },
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, @_);
}
}
};
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 @_;
. 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 @_;
. 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 @_;
. 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
}
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'" }
__END__
+=head1 NAME
+
+MooseX::Role::Parameterized - parameterized roles
+
=head1 SYNOPSIS
package MyRole::Counter;
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>!
-
-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<in your methods>!
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
projects / gitmo/MooseX-Role-Parameterized.git / blobdiff