7 use Scalar::Util 'blessed';
9 use Sub::Name 'subname';
13 our $VERSION = '0.05';
17 use Moose::Meta::Role;
18 use Moose::Util::TypeConstraints;
21 my ( $CALLER, %METAS );
26 return $METAS{$role} if exists $METAS{$role};
28 # make a subtype for each Moose class
31 => where { $_->does($role) }
32 unless find_type_constraint($role);
35 if ($role->can('meta')) {
36 $meta = $role->meta();
37 (blessed($meta) && $meta->isa('Moose::Meta::Role'))
38 || confess "Whoops, not møøsey enough";
41 $meta = Moose::Meta::Role->new(role_name => $role);
42 $meta->_role_meta->add_method('meta' => sub { $meta })
45 return $METAS{$role} = $meta;
51 my $meta = _find_meta();
52 return subname 'Moose::Role::extends' => sub {
53 confess "Moose::Role does not currently support 'extends'"
57 my $meta = _find_meta();
58 return subname 'Moose::Role::with' => sub (@) {
60 confess "Must specify at least one role" unless @roles;
61 Moose::_load_all_classes(@roles);
62 ($_->can('meta') && $_->meta->isa('Moose::Meta::Role'))
63 || confess "You can only consume roles, $_ is not a Moose role"
65 if (scalar @roles == 1) {
66 $roles[0]->meta->apply($meta);
69 Moose::Meta::Role->combine(
70 map { $_->meta } @roles
76 my $meta = _find_meta();
77 return subname 'Moose::Role::requires' => sub (@) {
78 confess "Must specify at least one method" unless @_;
79 $meta->add_required_methods(@_);
83 my $meta = _find_meta();
84 return subname 'Moose::Role::excludes' => sub (@) {
85 confess "Must specify at least one role" unless @_;
86 $meta->add_excluded_roles(@_);
90 my $meta = _find_meta();
91 return subname 'Moose::Role::has' => sub ($;%) {
92 my ($name, %options) = @_;
93 $meta->add_attribute($name, %options)
97 my $meta = _find_meta();
98 return subname 'Moose::Role::before' => sub (@&) {
99 confess "Moose::Role does not currently support 'before'";
101 $meta->add_before_method_modifier($_, $code) for @_;
105 my $meta = _find_meta();
106 return subname 'Moose::Role::after' => sub (@&) {
107 confess "Moose::Role does not currently support 'after'";
109 $meta->add_after_method_modifier($_, $code) for @_;
113 my $meta = _find_meta();
114 return subname 'Moose::Role::around' => sub (@&) {
115 confess "Moose::Role does not currently support 'around'";
117 $meta->add_around_method_modifier($_, $code) for @_;
121 my $meta = _find_meta();
122 return subname 'Moose::Role::super' => sub {};
125 my $meta = _find_meta();
126 return subname 'Moose::Role::override' => sub ($&) {
127 confess "Moose::Role cannot support 'override'";
131 my $meta = _find_meta();
132 return subname 'Moose::Role::inner' => sub {
133 confess "Moose::Role cannot support 'inner'";
137 my $meta = _find_meta();
138 return subname 'Moose::Role::augment' => sub {
139 confess "Moose::Role cannot support 'augment'";
143 return \&Carp::confess;
146 return \&Scalar::Util::blessed;
150 my $exporter = Sub::Exporter::build_exporter({
151 exports => \%exports,
163 # we should never export to main
164 return if $CALLER eq 'main';
179 Moose::Role - The Moose Role
191 my ($self, $other) = @_;
192 !$self->equal($other);
195 # ... then in your classes
205 my ($self, $other) = @_;
206 $self->as_float == $other->as_float;
211 Role support in Moose is coming along quite well. It's best documentation
212 is still the the test suite, but it is fairly safe to assume Perl 6 style
213 behavior, and then either refer to the test suite, or ask questions on
214 #moose if something doesn't quite do what you expect. More complete
215 documentation is planned and will be included with the next official
216 (non-developer) release.
218 =head1 EXPORTED FUNCTIONS
220 Currently Moose::Role supports all of the functions that L<Moose> exports,
221 but differs slightly in how some items are handled (see L<CAVEATS> below
224 Moose::Role also offers two role specific keyword exports:
228 =item B<requires (@method_names)>
230 Roles can require that certain methods are implemented by any class which
233 =item B<excludes (@role_names)>
235 Roles can C<exclude> other roles, in effect saying "I can never be combined
236 with these C<@role_names>". This is a feature which should not be used
243 The role support now has only a few caveats. They are as follows:
249 Roles cannot use the C<extends> keyword, it will throw an exception for now.
250 The same is true of the C<augment> and C<inner> keywords (not sure those
251 really make sense for roles). All other Moose keywords will be I<deferred>
252 so that they can be applied to the consuming class.
256 Role composition does it's best to B<not> be order sensitive when it comes
257 to conflict resolution and requirements detection. However, it is order
258 sensitive when it comes to method modifiers. All before/around/after modifiers
259 are included whenever a role is composed into a class, and then are applied
260 in the order the roles are used. This too means that there is no conflict for
261 before/around/after modifiers as well.
263 In most cases, this will be a non issue, however it is something to keep in
264 mind when using method modifiers in a role. You should never assume any
269 The C<requires> keyword currently only works with actual methods. A method
270 modifier (before/around/after and override) will not count as a fufillment
271 of the requirement, and neither will an autogenerated accessor for an attribute.
273 It is likely that the attribute accessors will eventually be allowed to fufill
274 those requirements, either that or we will introduce a C<requires_attr> keyword
275 of some kind instead. This descision has not yet been finalized.
281 All complex software has bugs lurking in it, and this module is no
282 exception. If you find a bug please either email me, or add the bug
287 Stevan Little E<lt>stevan@iinteractive.comE<gt>
289 Christian Hansen E<lt>chansen@cpan.orgE<gt>
291 =head1 COPYRIGHT AND LICENSE
293 Copyright 2006 by Infinity Interactive, Inc.
295 L<http://www.iinteractive.com>
297 This library is free software; you can redistribute it and/or modify
298 it under the same terms as Perl itself.