X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FMoose%2FRole.pm;h=55c283d00cec37eae943751ff5ce7197067a761e;hb=1edfdf1c2c930faea9d3b5e9fed40928fec420b0;hp=2d6b8d3ef35684e0aa01a7d3dbb9f6b16ab65140;hpb=d79e62fdf0519b8a6d25b1520463b9714997ea5f;p=gitmo%2FMoose.git diff --git a/lib/Moose/Role.pm b/lib/Moose/Role.pm index 2d6b8d3..55c283d 100644 --- a/lib/Moose/Role.pm +++ b/lib/Moose/Role.pm @@ -4,13 +4,16 @@ package Moose::Role; use strict; use warnings; -use Scalar::Util (); +use Scalar::Util 'blessed'; use Carp 'confess'; use Sub::Name 'subname'; use Sub::Exporter; -our $VERSION = '0.03'; +our $VERSION = '0.07'; +our $AUTHORITY = 'cpan:STEVAN'; + +use Moose (); use Moose::Meta::Role; use Moose::Util::TypeConstraints; @@ -27,24 +30,25 @@ use Moose::Util::TypeConstraints; subtype $role => as 'Role' => where { $_->does($role) } + => optimize_as { blessed($_[0]) && $_[0]->can('does') && $_[0]->does($role) } unless find_type_constraint($role); my $meta; if ($role->can('meta')) { $meta = $role->meta(); (blessed($meta) && $meta->isa('Moose::Meta::Role')) - || confess "Whoops, not møøsey enough"; + || confess "You already have a &meta function, but it does not return a Moose::Meta::Role"; } else { - $meta = Moose::Meta::Role->new(role_name => $role); - $meta->_role_meta->add_method('meta' => sub { $meta }) + $meta = Moose::Meta::Role->initialize($role); + $meta->Moose::Meta::Class::add_method('meta' => sub { $meta }) } return $METAS{$role} = $meta; } - my %exports = ( + my %exports = ( extends => sub { my $meta = _find_meta(); return subname 'Moose::Role::extends' => sub { @@ -53,9 +57,10 @@ use Moose::Util::TypeConstraints; }, with => sub { my $meta = _find_meta(); - return subname 'Moose::Role::with' => sub { + return subname 'Moose::Role::with' => sub (@) { my (@roles) = @_; - Moose::_load_all_classes(@roles); + confess "Must specify at least one role" unless @roles; + Class::MOP::load_class($_) for @roles; ($_->can('meta') && $_->meta->isa('Moose::Meta::Role')) || confess "You can only consume roles, $_ is not a Moose role" foreach @roles; @@ -71,65 +76,71 @@ use Moose::Util::TypeConstraints; }, requires => sub { my $meta = _find_meta(); - return subname 'Moose::Role::requires' => sub { + return subname 'Moose::Role::requires' => sub (@) { + confess "Must specify at least one method" unless @_; $meta->add_required_methods(@_); }; }, excludes => sub { my $meta = _find_meta(); - return subname 'Moose::Role::excludes' => sub { + return subname 'Moose::Role::excludes' => sub (@) { + confess "Must specify at least one role" unless @_; $meta->add_excluded_roles(@_); }; }, has => sub { my $meta = _find_meta(); - return subname 'Moose::Role::has' => sub { + return subname 'Moose::Role::has' => sub ($;%) { my ($name, %options) = @_; $meta->add_attribute($name, %options) }; }, before => sub { my $meta = _find_meta(); - return subname 'Moose::Role::before' => sub { - my $code = pop @_; - $meta->add_before_method_modifier($_, $code) for @_; + return subname 'Moose::Role::before' => sub (@&) { + my $code = pop @_; + $meta->add_before_method_modifier($_, $code) for @_; }; }, after => sub { my $meta = _find_meta(); - return subname 'Moose::Role::after' => sub { + return subname 'Moose::Role::after' => sub (@&) { my $code = pop @_; $meta->add_after_method_modifier($_, $code) for @_; }; }, around => sub { my $meta = _find_meta(); - return subname 'Moose::Role::around' => sub { + return subname 'Moose::Role::around' => sub (@&) { my $code = pop @_; $meta->add_around_method_modifier($_, $code) for @_; }; }, super => sub { + { + no strict 'refs'; + $Moose::SUPER_SLOT{$CALLER} = \*{"${CALLER}::super"}; + } my $meta = _find_meta(); return subname 'Moose::Role::super' => sub {}; }, override => sub { my $meta = _find_meta(); - return subname 'Moose::Role::override' => sub { + return subname 'Moose::Role::override' => sub ($&) { my ($name, $code) = @_; - $meta->add_override_method_modifier($name, $code); + $meta->add_override_method_modifier($name, $code); }; }, inner => sub { my $meta = _find_meta(); return subname 'Moose::Role::inner' => sub { - confess "Moose::Role does not currently support 'inner'"; + confess "Moose::Role cannot support 'inner'"; }; }, augment => sub { my $meta = _find_meta(); return subname 'Moose::Role::augment' => sub { - confess "Moose::Role does not currently support 'augment'"; + confess "Moose::Role cannot support 'augment'"; }; }, confess => sub { @@ -148,7 +159,15 @@ use Moose::Util::TypeConstraints; }); sub import { - $CALLER = caller(); + $CALLER = + ref $_[1] && defined $_[1]->{into} ? $_[1]->{into} + : ref $_[1] + && defined $_[1]->{into_level} ? caller( $_[1]->{into_level} ) + : caller(); + + + strict->import; + warnings->import; # we should never export to main return if $CALLER eq 'main'; @@ -171,9 +190,7 @@ Moose::Role - The Moose Role =head1 SYNOPSIS package Eq; - use strict; - use warnings; - use Moose::Role; + use Moose::Role; # automatically turns on strict and warnings requires 'equal'; @@ -185,9 +202,7 @@ Moose::Role - The Moose Role # ... then in your classes package Currency; - use strict; - use warnings; - use Moose; + use Moose; # automatically turns on strict and warnings with 'Eq'; @@ -198,36 +213,72 @@ Moose::Role - The Moose Role =head1 DESCRIPTION -This is currently a very early release of Perl 6 style Roles for -Moose, it is still incomplete, but getting much closer. If you are -interested in helping move this feature along, please come to -#moose on irc.perl.org and we can talk. +Role support in Moose is pretty solid at this point. However, the best +documentation is still the the test suite. It is fairly safe to assume Perl 6 +style behavior and then either refer to the test suite, or ask questions on +#moose if something doesn't quite do what you expect. -=head1 CAVEATS +We are planning writing some more documentation in the near future, but nothing +is ready yet, sorry. + +=head1 EXPORTED FUNCTIONS + +Moose::Role currently supports all of the functions that L exports, but +differs slightly in how some items are handled (see L below for +details). -Currently, the role support has a few of caveats. They are as follows: +Moose::Role also offers two role-specific keyword exports: =over 4 -=item * +=item B -At this time classes I correctly consume more than one role. The -role composition process, and it's conflict detection has not been added -yet. While this should be considered a major feature, it can easily be -worked around, and in many cases, is not needed at all. - -A class can actually consume multiple roles, they are just applied one -after another in the order you ask for them. This is incorrect behavior, -the roles should be merged first, and conflicts determined, etc. However, -if your roles do not have any conflicts, then things will work just -fine. This actually tends to be quite sufficient for basic roles. +Roles can require that certain methods are implemented by any class which +C the role. + +=item B + +Roles can C other roles, in effect saying "I can never be combined +with these C<@role_names>". This is a feature which should not be used +lightly. + +=back + +=head1 CAVEATS + +Role support has only a few caveats: + +=over 4 =item * -Roles cannot use the C keyword, it will throw an exception for now. +Roles cannot use the C keyword; it will throw an exception for now. The same is true of the C and C keywords (not sure those really make sense for roles). All other Moose keywords will be I -so that they can be applied to the consuming class. +so that they can be applied to the consuming class. + +=item * + +Role composition does its best to B be order-sensitive when it comes to +conflict resolution and requirements detection. However, it is order-sensitive +when it comes to method modifiers. All before/around/after modifiers are +included whenever a role is composed into a class, and then applied in the order +in which the roles are used. This also means that there is no conflict for +before/around/after modifiers. + +In most cases, this will be a non-issue; however, it is something to keep in +mind when using method modifiers in a role. You should never assume any +ordering. + +=item * + +The C keyword currently only works with actual methods. A method +modifier (before/around/after and override) will not count as a fufillment +of the requirement, and neither will an autogenerated accessor for an attribute. + +It is likely that attribute accessors will eventually be allowed to fufill those +requirements, or we will introduce a C keyword of some kind +instead. This decision has not yet been finalized. =back @@ -245,11 +296,11 @@ Christian Hansen Echansen@cpan.orgE =head1 COPYRIGHT AND LICENSE -Copyright 2006 by Infinity Interactive, Inc. +Copyright 2006, 2007 by Infinity Interactive, Inc. L This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself. -=cut \ No newline at end of file +=cut