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'";
103 my $meta = _find_meta();
104 return subname 'Moose::Role::after' => sub (@&) {
105 confess "Moose::Role does not currently support 'after'";
109 my $meta = _find_meta();
110 return subname 'Moose::Role::around' => sub (@&) {
111 confess "Moose::Role does not currently support 'around'";
115 my $meta = _find_meta();
116 return subname 'Moose::Role::super' => sub {
117 confess "Moose::Role cannot support 'super'";
121 my $meta = _find_meta();
122 return subname 'Moose::Role::override' => sub ($&) {
123 confess "Moose::Role cannot support 'override'";
127 my $meta = _find_meta();
128 return subname 'Moose::Role::inner' => sub {
129 confess "Moose::Role cannot support 'inner'";
133 my $meta = _find_meta();
134 return subname 'Moose::Role::augment' => sub {
135 confess "Moose::Role cannot support 'augment'";
139 return \&Carp::confess;
142 return \&Scalar::Util::blessed;
146 my $exporter = Sub::Exporter::build_exporter({
147 exports => \%exports,
159 # we should never export to main
160 return if $CALLER eq 'main';
175 Moose::Role - The Moose Role
187 my ($self, $other) = @_;
188 !$self->equal($other);
191 # ... then in your classes
201 my ($self, $other) = @_;
202 $self->as_float == $other->as_float;
207 Role support in Moose is coming along quite well. It's best documentation
208 is still the the test suite, but it is fairly safe to assume Perl 6 style
209 behavior, and then either refer to the test suite, or ask questions on
210 #moose if something doesn't quite do what you expect. More complete
211 documentation is planned and will be included with the next official
212 (non-developer) release.
214 =head1 EXPORTED FUNCTIONS
216 Currently Moose::Role supports all of the functions that L<Moose> exports,
217 but differs slightly in how some items are handled (see L<CAVEATS> below
220 Moose::Role also offers two role specific keyword exports:
224 =item B<requires (@method_names)>
226 Roles can require that certain methods are implemented by any class which
229 =item B<excludes (@role_names)>
231 Roles can C<exclude> other roles, in effect saying "I can never be combined
232 with these C<@role_names>". This is a feature which should not be used
239 The role support now has only a few caveats. They are as follows:
245 Roles cannot use the C<extends> keyword, it will throw an exception for now.
246 The same is true of the C<augment> and C<inner> keywords (not sure those
247 really make sense for roles). All other Moose keywords will be I<deferred>
248 so that they can be applied to the consuming class.
252 Role composition does it's best to B<not> be order sensitive when it comes
253 to conflict resolution and requirements detection. However, it is order
254 sensitive when it comes to method modifiers. All before/around/after modifiers
255 are included whenever a role is composed into a class, and then are applied
256 in the order the roles are used. This too means that there is no conflict for
257 before/around/after modifiers as well.
259 In most cases, this will be a non issue, however it is something to keep in
260 mind when using method modifiers in a role. You should never assume any
265 The C<requires> keyword currently only works with actual methods. A method
266 modifier (before/around/after and override) will not count as a fufillment
267 of the requirement, and neither will an autogenerated accessor for an attribute.
269 It is likely that the attribute accessors will eventually be allowed to fufill
270 those requirements, either that or we will introduce a C<requires_attr> keyword
271 of some kind instead. This descision has not yet been finalized.
277 All complex software has bugs lurking in it, and this module is no
278 exception. If you find a bug please either email me, or add the bug
283 Stevan Little E<lt>stevan@iinteractive.comE<gt>
285 Christian Hansen E<lt>chansen@cpan.orgE<gt>
287 =head1 COPYRIGHT AND LICENSE
289 Copyright 2006 by Infinity Interactive, Inc.
291 L<http://www.iinteractive.com>
293 This library is free software; you can redistribute it and/or modify
294 it under the same terms as Perl itself.