Role::Tiny - Roles: a nouvelle cuisine portion size slice of Moose

NAME SYNOPSIS DESCRIPTION ROLE COMPOSITION ROLE METHODS IMPORTED SUBROUTINES requires with before around after Strict and Warnings SUBROUTINES does_role METHODS make_role apply_roles_to_package apply_roles_to_object create_class_with_roles is_role CAVEATS SEE ALSO AUTHOR CONTRIBUTORS COPYRIGHT LICENSE

NAME

Role::Tiny − Roles: a nouvelle cuisine portion size slice of Moose

SYNOPSIS

package Some::Role;
use Role::Tiny;
sub foo { ... }
sub bar { ... }
around baz => sub { ... };
1;

elsewhere

package Some::Class;
use Role::Tiny::With;
# bar gets imported, but not foo
with 'Some::Role';
sub foo { ... }
# baz is wrapped in the around modifier by Class::Method::Modifiers
sub baz { ... }
1;

If you wanted attributes as well, look at Moo::Role.

DESCRIPTION

"Role::Tiny" is a minimalist role composition tool.

ROLE COMPOSITION

Role composition can be thought of as much more clever and meaningful multiple inheritance. The basics of this implementation of roles is:

	•		If a method is already defined on a class, that method will not be composed in from the role. A method inherited by a class gets overridden by the role’s method of the same name, though.
	•		If a method that the role "requires" to be implemented is not implemented, role application will fail loudly.

Unlike Class::C3, where the last class inherited from "wins," role composition is the other way around, where the class wins. If multiple roles are applied in a single call (single with statement), then if any of their provided methods clash, an exception is raised unless the class provides a method since this conflict indicates a potential problem.

ROLE METHODS

All subs created after importing Role::Tiny will be considered methods to be composed. For example:

package MyRole;
use List::Util qw(min);
sub mysub { }
use Role::Tiny;
use List::Util qw(max);
sub mymethod { }

In this role, "max" and "mymethod" will be included when composing MyRole, and "min" and "mysub" will not. For additional control, namespace::clean can be used to exclude undesired subs from roles.

IMPORTED SUBROUTINES

requires

requires qw(foo bar);

Declares a list of methods that must be defined to compose role.

with

with 'Some::Role1';
with 'Some::Role1', 'Some::Role2';

Composes another role into the current role (or class via Role::Tiny::With).

If you have conflicts and want to resolve them in favour of Some::Role1 you can instead write:

with 'Some::Role1';
with 'Some::Role2';

If you have conflicts and want to resolve different conflicts in favour of different roles, please refactor your codebase.

before

before foo => sub { ... };

See "before method(s) => sub { ... };" in Class::Method::Modifiers for full documentation.

Note that since you are not required to use method modifiers, Class::Method::Modifiers is lazily loaded and we do not declare it as a dependency. If your Role::Tiny role uses modifiers you must depend on both Class::Method::Modifiers and Role::Tiny.

around

around foo => sub { ... };

See "around method(s) => sub { ... };" in Class::Method::Modifiers for full documentation.

after

after foo => sub { ... };

See "after method(s) => sub { ... };" in Class::Method::Modifiers for full documentation.

Strict and Warnings

In addition to importing subroutines, using "Role::Tiny" applies strict and warnings to the caller.

SUBROUTINES

does_role

if (Role::Tiny::does_role($foo, 'Some::Role')) {
...
}

Returns true if class has been composed with role.

This subroutine is also installed as −>does on any class a Role::Tiny is composed into unless that class already has an −>does method, so

if ($foo−>does('Some::Role')) {
...
}

will work for classes but to test a role, one must use ::does_role directly.

Additionally, Role::Tiny will override the standard Perl "DOES" method for your class. However, if "any" class in your class’ inheritance hierarchy provides "DOES", then Role::Tiny will not override it.

METHODS

make_role

Role::Tiny−>make_role('Some::Role');

Makes a package into a role, but does not export any subs into it.

apply_roles_to_package

Role::Tiny−>apply_roles_to_package(
'Some::Package', 'Some::Role', 'Some::Other::Role'
);

Composes role with package. See also Role::Tiny::With.

apply_roles_to_object

Role::Tiny−>apply_roles_to_object($foo, qw(Some::Role1 Some::Role2));

Composes roles in order into object directly. Object is reblessed into the resulting class. Note that the object’s methods get overridden by the role’s ones with the same names.

create_class_with_roles

Role::Tiny−>create_class_with_roles('Some::Base', qw(Some::Role1 Some::Role2));

Creates a new class based on base, with the roles composed into it in order. New class is returned.

is_role

Role::Tiny−>is_role('Some::Role1')

Returns true if the given package is a role.

CAVEATS

	•		On perl 5.8.8 and earlier, applying a role to an object won’t apply any overloads from the role to other copies of the object.
	•		On perl 5.16 and earlier, applying a role to a class won’t apply any overloads from the role to any existing instances of the class.