3 sub _getglob { \*{$_[0]} }
6 use warnings FATAL => 'all';
13 return 1 if $_[0]->can('can');
14 (my $proto = $_[0]) =~ s/::/\//g;
15 require "${proto}.pm";
23 return if $INFO{$target}; # already exported into this package
24 # get symbol table reference
25 my $stash = do { no strict 'refs'; \%{"${target}::"} };
26 # install before/after/around subs
27 foreach my $type (qw(before after around)) {
28 *{_getglob "${target}::${type}"} = sub {
29 require Class::Method::Modifiers;
30 push @{$INFO{$target}{modifiers}||=[]}, [ $type => @_ ];
33 *{_getglob "${target}::requires"} = sub {
34 push @{$INFO{$target}{requires}||=[]}, @_;
36 *{_getglob "${target}::with"} = sub {
37 die "Only one role supported at a time by with" if @_ > 1;
38 $me->apply_role_to_package($target, $_[0]);
40 # grab all *non-constant* (ref eq 'SCALAR') subs present
41 # in the symbol table and store their refaddrs (no need to forcibly
42 # inflate constant subs into real subs) - also add '' to here (this
44 @{$INFO{$target}{not_methods}={}}{
45 '', map { *$_{CODE}||() } grep !(ref eq 'SCALAR'), values %$stash
48 $APPLIED_TO{$target} = { $target => undef };
51 sub apply_role_to_package {
52 my ($me, $to, $role) = @_;
56 die "This is apply_role_to_package" if ref($to);
57 die "${role} is not a Role::Tiny" unless my $info = $INFO{$role};
59 $me->_check_requires($to, $role, @{$info->{requires}||[]});
61 $me->_install_methods($to, $role);
63 $me->_install_modifiers($to, $info->{modifiers});
65 # only add does() method to classes and only if they don't have one
66 if (not $INFO{$to} and not $to->can('does')) {
67 *{_getglob "${to}::does"} = \&does_role;
70 # copy our role list into the target's
71 @{$APPLIED_TO{$to}||={}}{keys %{$APPLIED_TO{$role}}} = ();
74 sub apply_roles_to_object {
75 my ($me, $object, @roles) = @_;
76 die "No roles supplied!" unless @roles;
77 my $class = ref($object);
78 bless($object, $me->create_class_with_roles($class, @roles));
82 sub create_class_with_roles {
83 my ($me, $superclass, @roles) = @_;
85 die "No roles supplied!" unless @roles;
88 '__WITH__', $superclass, my $compose_name = join '__AND__', @roles
91 return $new_name if $COMPOSED{class}{$new_name};
93 foreach my $role (@roles) {
95 die "${role} is not a Role::Tiny" unless my $info = $INFO{$role};
104 my @composable = map $me->_composable_package_for($_), reverse @roles;
106 *{_getglob("${new_name}::ISA")} = [ @composable, $superclass ];
108 my @info = map +($INFO{$_} ? $INFO{$_} : ()), @roles;
110 $me->_check_requires(
111 $new_name, $compose_name,
112 do { my %h; @h{map @{$_->{requires}||[]}, @info} = (); keys %h }
115 *{_getglob "${new_name}::does"} = \&does_role unless $new_name->can('does');
117 @{$APPLIED_TO{$new_name}||={}}{
118 map keys %{$APPLIED_TO{$_}}, @roles
121 $COMPOSED{class}{$new_name} = 1;
125 sub _composable_package_for {
126 my ($me, $role) = @_;
127 my $composed_name = 'Role::Tiny::_COMPOSABLE::'.$role;
128 return $composed_name if $COMPOSED{role}{$composed_name};
129 $me->_install_methods($composed_name, $role);
130 my $base_name = $composed_name.'::_BASE';
131 *{_getglob("${composed_name}::ISA")} = [ $base_name ];
132 my $modifiers = $INFO{$role}{modifiers}||[];
134 foreach my $modified (
135 do { my %h; @h{map $_->[1], @$modifiers} = (); keys %h }
137 push @mod_base, "sub ${modified} { shift->next::method(\@_) }";
139 eval(my $code = join "\n", "package ${base_name};", @mod_base);
140 die "Evaling failed: $@\nTrying to eval:\n${code}" if $@;
141 $me->_install_modifiers($composed_name, $modifiers);
142 $COMPOSED{role}{$composed_name} = 1;
143 return $composed_name;
146 sub _check_requires {
147 my ($me, $to, $name, @requires) = @_;
148 if (my @requires_fail = grep !$to->can($_), @requires) {
149 # role -> role, add to requires, role -> class, error out
150 if (my $to_info = $INFO{$to}) {
151 push @{$to_info->{requires}||=[]}, @requires_fail;
153 die "Can't apply ${name} to ${to} - missing ".join(', ', @requires_fail);
158 sub _concrete_methods_of {
159 my ($me, $role) = @_;
160 my $info = $INFO{$role};
161 $info->{methods} ||= do {
162 # grab role symbol table
163 my $stash = do { no strict 'refs'; \%{"${role}::"}};
164 my $not_methods = $info->{not_methods};
166 # grab all code entries that aren't in the not_methods list
168 my $code = *{$stash->{$_}}{CODE};
169 # rely on the '' key we added in import for "no code here"
170 exists $not_methods->{$code||''} ? () : ($_ => $code)
171 } grep !(ref($stash->{$_}) eq 'SCALAR'), keys %$stash
176 sub methods_provided_by {
177 my ($me, $role) = @_;
178 die "${role} is not a Role::Tiny" unless my $info = $INFO{$role};
179 (keys %{$me->_concrete_methods_of($role)}, @{$info->{requires}||[]});
182 sub _install_methods {
183 my ($me, $to, $role) = @_;
185 my $info = $INFO{$role};
187 my $methods = $me->_concrete_methods_of($role);
189 # grab target symbol table
190 my $stash = do { no strict 'refs'; \%{"${to}::"}};
192 # determine already extant methods of target
195 +((ref($stash->{$_}) eq 'SCALAR') || (*{$stash->{$_}}{CODE})),
199 foreach my $i (grep !exists $has_methods{$_}, keys %$methods) {
201 *{_getglob "${to}::${i}"} = $methods->{$i};
205 sub _install_modifiers {
206 my ($me, $to, $modifiers) = @_;
207 if (my $info = $INFO{$to}) {
208 push @{$info->{modifiers}}, @{$modifiers||[]};
210 foreach my $modifier (@{$modifiers||[]}) {
211 $me->_install_single_modifier($to, @$modifier);
216 sub _install_single_modifier {
217 my ($me, @args) = @_;
218 Class::Method::Modifiers::install_modifier(@args);
222 my ($proto, $role) = @_;
223 return exists $APPLIED_TO{ref($proto)||$proto}{$role};
230 Role::Tiny - Roles. Like a nouvelle cusine portion size slice of Moose.
250 # bar gets imported, but not foo
251 Role::Tiny->apply_role_to_package('Some::Role', __PACKAGE__);
259 C<Role::Tiny> is a minimalist role composition tool.
261 =head1 ROLE COMPOSITION
263 Role composition can be thought of as much more clever and meaningful multiple
264 inheritance. The basics of this implementation of roles is:
270 If a method is already defined on a class, that method will not be composed in
275 If a method that the role L</requires> to be implemented is not implemented,
276 role application will fail loudly.
280 Unlike L<Class::C3>, where the B<last> class inherited from "wins," role
281 composition is the other way around, where first wins. In a more complete
282 system (see L<Moose>) roles are checked to see if they clash. The goal of this
283 is to be much simpler, hence disallowing composition of multiple roles at once.
287 =head2 apply_role_to_package
289 Role::Tiny->apply_role_to_package('Some::Package', 'Some::Role');
291 Composes role with package
293 =head2 apply_roles_to_object
295 Role::Tiny->apply_roles_to_object($foo, qw(Some::Role1 Some::Role2));
297 Composes roles in order into object directly. Object is reblessed into the
300 =head2 create_class_with_roles
302 Role::Tiny->create_class_with_roles('Some::Base', qw(Some::Role1 Some::Role2));
304 Creates a new class based on base, with the roles composed into it in order.
305 New class is returned.
311 if (Role::Tiny::does_role($foo, 'Some::Role')) {
315 Returns true if class has been composed with role.
317 This subroutine is also installed as ->does on any class a Role::Tiny is
318 composed into unless that class already has an ->does method, so
320 if ($foo->does_role('Some::Role')) {
324 will work for classes but to test a role, one must use ::does_role directly
326 =head1 IMPORTED SUBROUTINES
330 requires qw(foo bar);
332 Declares a list of methods that must be defined to compose role.
339 Composes another role into the current role. Only one role may be composed in
340 at a time to allow the code to remain as simple as possible.
344 before foo => sub { ... };
346 See L<< Class::Method::Modifiers/before method(s) => sub { ... } >> for full
351 around foo => sub { ... };
353 See L<< Class::Method::Modifiers/around method(s) => sub { ... } >> for full
358 after foo => sub { ... };
360 See L<< Class::Method::Modifiers/after method(s) => sub { ... } >> for full