strict->import;
warnings->import(FATAL => 'all');
return if $INFO{$target}; # already exported into this package
+ $INFO{$target}{is_role} = 1;
# get symbol table reference
my $stash = _getstash($target);
# install before/after/around subs
$APPLIED_TO{$target} = { $target => undef };
}
+sub role_application_steps {
+ qw(_install_methods _check_requires _install_modifiers _copy_applied_list);
+}
+
sub apply_single_role_to_package {
my ($me, $to, $role) = @_;
_load_module($role);
die "This is apply_role_to_package" if ref($to);
- die "${role} is not a Role::Tiny" unless my $info = $INFO{$role};
-
- $me->_check_requires($to, $role, @{$info->{requires}||[]});
-
- $me->_install_methods($to, $role);
+ die "${role} is not a Role::Tiny" unless $INFO{$role};
- $me->_install_modifiers($to, $info->{modifiers});
+ foreach my $step ($me->role_application_steps) {
+ $me->$step($to, $role);
+ }
+}
+sub _copy_applied_list {
+ my ($me, $to, $role) = @_;
# copy our role list into the target's
@{$APPLIED_TO{$to}||={}}{keys %{$APPLIED_TO{$role}}} = ();
}
return $me->apply_role_to_package($to, $roles[0]) if @roles == 1;
my %conflicts = %{$me->_composite_info_for(@roles)->{conflicts}};
- delete $conflicts{$_} for $me->_concrete_methods_of($to);
+ delete $conflicts{$_} for keys %{ $me->_concrete_methods_of($to) };
if (keys %conflicts) {
my $fail =
join "\n",
delete $INFO{$to}{methods}; # reset since we're about to add methods
}
- foreach my $role (@roles) {
- $me->apply_single_role_to_package($to, $role);
+ # backcompat: allow subclasses to use apply_single_role_to_package
+ # to apply changes. set a local var so ours does nothing.
+ our %BACKCOMPAT_HACK;
+ if($me ne __PACKAGE__
+ and exists $BACKCOMPAT_HACK{$me} ? $BACKCOMPAT_HACK{$me} :
+ $BACKCOMPAT_HACK{$me} =
+ $me->can('role_application_steps')
+ == \&role_application_steps
+ && $me->can('apply_single_role_to_package')
+ != \&apply_single_role_to_package
+ ) {
+ foreach my $role (@roles) {
+ $me->apply_single_role_to_package($to, $role);
+ }
+ }
+ else {
+ foreach my $step ($me->role_application_steps) {
+ foreach my $role (@roles) {
+ $me->$step($to, $role);
+ }
+ }
}
$APPLIED_TO{$to}{join('|',@roles)} = 1;
}
$e = "Evaling failed: $@\nTrying to eval:\n${code}" if $@;
}
die $e if $e;
- $me->_install_modifiers($composed_name, $modifiers);
+ $me->_install_modifiers($composed_name, $role);
$COMPOSED{role}{$composed_name} = 1;
return $composed_name;
}
sub _check_requires {
- my ($me, $to, $name, @requires) = @_;
+ my ($me, $to, $name) = @_;
+ return unless my @requires = @{$INFO{$name}{requires}||[]};
if (my @requires_fail = grep !$to->can($_), @requires) {
# role -> role, add to requires, role -> class, error out
if (my $to_info = $INFO{$to}) {
}
sub _install_modifiers {
- my ($me, $to, $modifiers) = @_;
+ my ($me, $to, $name) = @_;
+ return unless my $modifiers = $INFO{$name}{modifiers};
if (my $info = $INFO{$to}) {
push @{$info->{modifiers}}, @{$modifiers||[]};
} else {
return 0;
}
+sub is_role {
+ my ($me, $role) = @_;
+ return !!$INFO{$role};
+}
+
1;
=encoding utf-8
Additionally, Role::Tiny will override the standard Perl C<DOES> method
for your class. However, if C<any> class in your class' inheritance
-heirarchy provides C<DOES>, then Role::Tiny will not override it.
+hierarchy provides C<DOES>, then Role::Tiny will not override it.
=head1 METHODS
Creates a new class based on base, with the roles composed into it in order.
New class is returned.
+=head2 is_role
+
+ Role::Tiny->is_role('Some::Role1')
+
+Returns true if the given package is a role.
+
=head1 SEE ALSO
L<Role::Tiny> is the attribute-less subset of L<Moo::Role>; L<Moo::Role> is