lib/Role/Tiny.pm

   1 package Role::Tiny;
   2
   3 sub _getglob { \*{$_[0]} }
   4 sub _getstash { \%{"$_[0]::"} }
   5
   6 use strict;
   7 use warnings FATAL => 'all';
   8
   9 our $VERSION = '1.000001'; # 1.0.1
  10 $VERSION = eval $VERSION;
  11
  12 our %INFO;
  13 our %APPLIED_TO;
  14 our %COMPOSED;
  15
  16 # Module state workaround totally stolen from Zefram's Module::Runtime.
  17
  18 BEGIN {
  19   *_WORK_AROUND_BROKEN_MODULE_STATE = "$]" < 5.009 ? sub(){1} : sub(){0};
  20 }
  21
  22 sub Role::Tiny::__GUARD__::DESTROY {
  23   delete $INC{$_[0]->[0]} if @{$_[0]};
  24 }
  25
  26 sub _load_module {
  27   (my $proto = $_[0]) =~ s/::/\//g;
  28   $proto .= '.pm';
  29   return 1 if $INC{$proto};
  30   # can't just ->can('can') because a sub-package Foo::Bar::Baz
  31   # creates a 'Baz::' key in Foo::Bar's symbol table
  32   return 1 if grep !/::$/, keys %{_getstash($_[0])||{}};
  33   my $guard = _WORK_AROUND_BROKEN_MODULE_STATE
  34     && bless([ $proto ], 'Role::Tiny::__GUARD__');
  35   require $proto;
  36   pop @$guard if _WORK_AROUND_BROKEN_MODULE_STATE;
  37   return 1;
  38 }
  39
  40 sub import {
  41   my $target = caller;
  42   my $me = shift;
  43   strict->import;
  44   warnings->import(FATAL => 'all');
  45   return if $INFO{$target}; # already exported into this package
  46   # get symbol table reference
  47   my $stash = do { no strict 'refs'; \%{"${target}::"} };
  48   # install before/after/around subs
  49   foreach my $type (qw(before after around)) {
  50     *{_getglob "${target}::${type}"} = sub {
  51       require Class::Method::Modifiers;
  52       push @{$INFO{$target}{modifiers}||=[]}, [ $type => @_ ];
  53     };
  54   }
  55   *{_getglob "${target}::requires"} = sub {
  56     push @{$INFO{$target}{requires}||=[]}, @_;
  57   };
  58   *{_getglob "${target}::with"} = sub {
  59     $me->apply_union_of_roles_to_package($target, @_);
  60   };
  61   # grab all *non-constant* (stash slot is not a scalarref) subs present
  62   # in the symbol table and store their refaddrs (no need to forcibly
  63   # inflate constant subs into real subs) - also add '' to here (this
  64   # is used later)
  65   @{$INFO{$target}{not_methods}={}}{
  66     '', map { *$_{CODE}||() } grep !ref($_), values %$stash
  67   } = ();
  68   # a role does itself
  69   $APPLIED_TO{$target} = { $target => undef };
  70 }
  71
  72 sub apply_role_to_package {
  73   my ($me, $to, $role) = @_;
  74
  75   _load_module($role);
  76
  77   die "This is apply_role_to_package" if ref($to);
  78   die "${role} is not a Role::Tiny" unless my $info = $INFO{$role};
  79
  80   $me->_check_requires($to, $role, @{$info->{requires}||[]});
  81
  82   $me->_install_methods($to, $role);
  83
  84   $me->_install_modifiers($to, $info->{modifiers});
  85
  86   # only add does() method to classes and only if they don't have one
  87   if (not $INFO{$to} and not $to->can('does')) {
  88     *{_getglob "${to}::does"} = \&does_role;
  89   }
  90
  91   # copy our role list into the target's
  92   @{$APPLIED_TO{$to}||={}}{keys %{$APPLIED_TO{$role}}} = ();
  93 }
  94
  95 sub apply_roles_to_object {
  96   my ($me, $object, @roles) = @_;
  97   die "No roles supplied!" unless @roles;
  98   my $class = ref($object);
  99   bless($object, $me->create_class_with_roles($class, @roles));
 100   $object;
 101 }
 102
 103 sub create_class_with_roles {
 104   my ($me, $superclass, @roles) = @_;
 105
 106   die "No roles supplied!" unless @roles;
 107
 108   my $new_name = join(
 109     '__WITH__', $superclass, my $compose_name = join '__AND__', @roles
 110   );
 111
 112   return $new_name if $COMPOSED{class}{$new_name};
 113
 114   foreach my $role (@roles) {
 115     _load_module($role);
 116     die "${role} is not a Role::Tiny" unless $INFO{$role};
 117   }
 118
 119   if ($] >= 5.010) {
 120     require mro;
 121   } else {
 122     require MRO::Compat;
 123   }
 124
 125   my @composable = map $me->_composable_package_for($_), reverse @roles;
 126
 127   *{_getglob("${new_name}::ISA")} = [ @composable, $superclass ];
 128
 129   my @info = map $INFO{$_}, @roles;
 130
 131   $me->_check_requires(
 132     $new_name, $compose_name,
 133     do { my %h; @h{map @{$_->{requires}||[]}, @info} = (); keys %h }
 134   );
 135
 136   *{_getglob "${new_name}::does"} = \&does_role unless $new_name->can('does');
 137
 138   @{$APPLIED_TO{$new_name}||={}}{
 139     map keys %{$APPLIED_TO{$_}}, @roles
 140   } = ();
 141
 142   $COMPOSED{class}{$new_name} = 1;
 143   return $new_name;
 144 }
 145
 146 sub apply_union_of_roles_to_package {
 147   my ($me, $to, @roles) = @_;
 148
 149   return $me->apply_role_to_package($to, $roles[0]) if @roles == 1;
 150
 151   _load_module($_) for @roles;
 152   my %methods;
 153   foreach my $role (@roles) {
 154     my $this_methods = $me->_concrete_methods_of($role);
 155     $methods{$_}{$this_methods->{$_}} = $role for keys %$this_methods;
 156   }
 157   delete $methods{$_} for grep keys(%{$methods{$_}}) == 1, keys %methods;
 158   delete $methods{$_} for $me->_concrete_methods_of($to);
 159   if (keys %methods) {
 160     my $fail =
 161       join "\n",
 162         map "$_ is provided by: ".join(', ', values %{$methods{$_}}),
 163           keys %methods;
 164     die "Conflict combining ".join(', ', @roles);
 165   }
 166   $me->apply_role_to_package($to, $_) for @roles;
 167 }
 168
 169 sub _composable_package_for {
 170   my ($me, $role) = @_;
 171   my $composed_name = 'Role::Tiny::_COMPOSABLE::'.$role;
 172   return $composed_name if $COMPOSED{role}{$composed_name};
 173   $me->_install_methods($composed_name, $role);
 174   my $base_name = $composed_name.'::_BASE';
 175   *{_getglob("${composed_name}::ISA")} = [ $base_name ];
 176   my $modifiers = $INFO{$role}{modifiers}||[];
 177   my @mod_base;
 178   foreach my $modified (
 179     do { my %h; @h{map $_->[1], @$modifiers} = (); keys %h }
 180   ) {
 181     push @mod_base, "sub ${modified} { shift->next::method(\@_) }";
 182   }
 183   my $e;
 184   {
 185     local $@;
 186     eval(my $code = join "\n", "package ${base_name};", @mod_base);
 187     $e = "Evaling failed: $@\nTrying to eval:\n${code}" if $@;
 188   }
 189   die $e if $e;
 190   $me->_install_modifiers($composed_name, $modifiers);
 191   $COMPOSED{role}{$composed_name} = 1;
 192   return $composed_name;
 193 }
 194
 195 sub _check_requires {
 196   my ($me, $to, $name, @requires) = @_;
 197   if (my @requires_fail = grep !$to->can($_), @requires) {
 198     # role -> role, add to requires, role -> class, error out
 199     if (my $to_info = $INFO{$to}) {
 200       push @{$to_info->{requires}||=[]}, @requires_fail;
 201     } else {
 202       die "Can't apply ${name} to ${to} - missing ".join(', ', @requires_fail);
 203     }
 204   }
 205 }
 206
 207 sub _concrete_methods_of {
 208   my ($me, $role) = @_;
 209   my $info = $INFO{$role};
 210   # grab role symbol table
 211   my $stash = do { no strict 'refs'; \%{"${role}::"}};
 212   my $not_methods = $info->{not_methods};
 213   +{
 214     # grab all code entries that aren't in the not_methods list
 215     map {
 216       my $code = *{$stash->{$_}}{CODE};
 217       # rely on the '' key we added in import for "no code here"
 218       exists $not_methods->{$code||''} ? () : ($_ => $code)
 219     } grep !ref($stash->{$_}), keys %$stash
 220   };
 221 }
 222
 223 sub methods_provided_by {
 224   my ($me, $role) = @_;
 225   die "${role} is not a Role::Tiny" unless my $info = $INFO{$role};
 226   (keys %{$me->_concrete_methods_of($role)}, @{$info->{requires}||[]});
 227 }
 228
 229 sub _install_methods {
 230   my ($me, $to, $role) = @_;
 231
 232   my $info = $INFO{$role};
 233
 234   my $methods = $me->_concrete_methods_of($role);
 235
 236   # grab target symbol table
 237   my $stash = do { no strict 'refs'; \%{"${to}::"}};
 238
 239   # determine already extant methods of target
 240   my %has_methods;
 241   @has_methods{grep
 242     +(ref($stash->{$_}) || *{$stash->{$_}}{CODE}),
 243     keys %$stash
 244   } = ();
 245
 246   foreach my $i (grep !exists $has_methods{$_}, keys %$methods) {
 247     no warnings 'once';
 248     *{_getglob "${to}::${i}"} = $methods->{$i};
 249   }
 250 }
 251
 252 sub _install_modifiers {
 253   my ($me, $to, $modifiers) = @_;
 254   if (my $info = $INFO{$to}) {
 255     push @{$info->{modifiers}}, @{$modifiers||[]};
 256   } else {
 257     foreach my $modifier (@{$modifiers||[]}) {
 258       $me->_install_single_modifier($to, @$modifier);
 259     }
 260   }
 261 }
 262
 263 sub _install_single_modifier {
 264   my ($me, @args) = @_;
 265   Class::Method::Modifiers::install_modifier(@args);
 266 }
 267
 268 sub does_role {
 269   my ($proto, $role) = @_;
 270   return exists $APPLIED_TO{ref($proto)||$proto}{$role};
 271 }
 272
 273 1;
 274
 275 =head1 NAME
 276
 277 Role::Tiny - Roles. Like a nouvelle cuisine portion size slice of Moose.
 278
 279 =head1 SYNOPSIS
 280
 281  package Some::Role;
 282
 283  use Role::Tiny;
 284
 285  sub foo { ... }
 286
 287  sub bar { ... }
 288
 289  around baz => sub { ... }
 290
 291  1;
 292
 293 else where
 294
 295  package Some::Class;
 296
 297  use Role::Tiny::With;
 298
 299  # bar gets imported, but not foo
 300  with 'Some::Role';
 301
 302  sub foo { ... }
 303
 304  # baz is wrapped in the around modifier by Class::Method::Modifiers
 305  sub baz { ... }
 306
 307  1;
 308
 309 If you wanted attributes as well, look at L<Moo::Role>.
 310
 311 =head1 DESCRIPTION
 312
 313 C<Role::Tiny> is a minimalist role composition tool.
 314
 315 =head1 ROLE COMPOSITION
 316
 317 Role composition can be thought of as much more clever and meaningful multiple
 318 inheritance.  The basics of this implementation of roles is:
 319
 320 =over 2
 321
 322 =item *
 323
 324 If a method is already defined on a class, that method will not be composed in
 325 from the role.
 326
 327 =item *
 328
 329 If a method that the role L</requires> to be implemented is not implemented,
 330 role application will fail loudly.
 331
 332 =back
 333
 334 Unlike L<Class::C3>, where the B<last> class inherited from "wins," role
 335 composition is the other way around, where first wins.  In a more complete
 336 system (see L<Moose>) roles are checked to see if they clash.  The goal of this
 337 is to be much simpler, hence disallowing composition of multiple roles at once.
 338
 339 =head1 METHODS
 340
 341 =head2 apply_role_to_package
 342
 343  Role::Tiny->apply_role_to_package('Some::Package', 'Some::Role');
 344
 345 Composes role with package.  See also L<Role::Tiny::With>.
 346
 347 =head2 apply_roles_to_object
 348
 349  Role::Tiny->apply_roles_to_object($foo, qw(Some::Role1 Some::Role2));
 350
 351 Composes roles in order into object directly.  Object is reblessed into the
 352 resulting class.
 353
 354 =head2 create_class_with_roles
 355
 356  Role::Tiny->create_class_with_roles('Some::Base', qw(Some::Role1 Some::Role2));
 357
 358 Creates a new class based on base, with the roles composed into it in order.
 359 New class is returned.
 360
 361 =head1 SUBROUTINES
 362
 363 =head2 does_role
 364
 365  if (Role::Tiny::does_role($foo, 'Some::Role')) {
 366    ...
 367  }
 368
 369 Returns true if class has been composed with role.
 370
 371 This subroutine is also installed as ->does on any class a Role::Tiny is
 372 composed into unless that class already has an ->does method, so
 373
 374   if ($foo->does('Some::Role')) {
 375     ...
 376   }
 377
 378 will work for classes but to test a role, one must use ::does_role directly
 379
 380 =head1 IMPORTED SUBROUTINES
 381
 382 =head2 requires
 383
 384  requires qw(foo bar);
 385
 386 Declares a list of methods that must be defined to compose role.
 387
 388 =head2 with
 389
 390  with 'Some::Role1';
 391  with 'Some::Role2';
 392
 393 Composes another role into the current role.  Only one role may be composed in
 394 at a time to allow the code to remain as simple as possible.
 395
 396 =head2 before
 397
 398  before foo => sub { ... };
 399
 400 See L<< Class::Method::Modifiers/before method(s) => sub { ... } >> for full
 401 documentation.
 402
 403 Note that since you are not required to use method modifiers,
 404 L<Class::Method::Modifiers> is lazily loaded and we do not declare it as
 405 a dependency. If your L<Role::Tiny> role uses modifiers you must depend on
 406 both L<Class::Method::Modifiers> and L<Role::Tiny>.
 407
 408 =head2 around
 409
 410  around foo => sub { ... };
 411
 412 See L<< Class::Method::Modifiers/around method(s) => sub { ... } >> for full
 413 documentation.
 414
 415 Note that since you are not required to use method modifiers,
 416 L<Class::Method::Modifiers> is lazily loaded and we do not declare it as
 417 a dependency. If your L<Role::Tiny> role uses modifiers you must depend on
 418 both L<Class::Method::Modifiers> and L<Role::Tiny>.
 419
 420 =head2 after
 421
 422  after foo => sub { ... };
 423
 424 See L<< Class::Method::Modifiers/after method(s) => sub { ... } >> for full
 425 documentation.
 426
 427 Note that since you are not required to use method modifiers,
 428 L<Class::Method::Modifiers> is lazily loaded and we do not declare it as
 429 a dependency. If your L<Role::Tiny> role uses modifiers you must depend on
 430 both L<Class::Method::Modifiers> and L<Role::Tiny>.
 431
 432 =head1 SEE ALSO
 433
 434 L<Role::Tiny> is the attribute-less subset of L<Moo::Role>; L<Moo::Role> is
 435 a meta-protocol-less subset of the king of role systems, L<Moose::Role>.
 436
 437 If you don't want method modifiers and do want to be forcibly restricted
 438 to a single role application per class, Ovid's L<Role::Basic> exists. But
 439 Stevan Little (the L<Moose> author) and I are both still convinced that
 440 he's Doing It Wrong.
 441
 442 =head1 AUTHOR
 443
 444 mst - Matt S. Trout (cpan:MSTROUT) <mst@shadowcat.co.uk>
 445
 446 =head1 CONTRIBUTORS
 447
 448 dg - David Leadbeater (cpan:DGL) <dgl@dgl.cx>
 449
 450 frew - Arthur Axel "fREW" Schmidt (cpan:FREW) <frioux@gmail.com>
 451
 452 hobbs - Andrew Rodland (cpan:ARODLAND) <arodland@cpan.org>
 453
 454 jnap - John Napiorkowski (cpan:JJNAPIORK) <jjn1056@yahoo.com>
 455
 456 ribasushi - Peter Rabbitson (cpan:RIBASUSHI) <ribasushi@cpan.org>
 457
 458 chip - Chip Salzenberg (cpan:CHIPS) <chip@pobox.com>
 459
 460 ajgb - Alex J. G. Burzyński (cpan:AJGB) <ajgb@cpan.org>
 461
 462 doy - Jesse Luehrs (cpan:DOY) <doy at tozt dot net>
 463
 464 perigrin - Chris Prather (cpan:PERIGRIN) <chris@prather.org>
 465
 466 =head1 COPYRIGHT
 467
 468 Copyright (c) 2010-2012 the Role::Tiny L</AUTHOR> and L</CONTRIBUTORS>
 469 as listed above.
 470
 471 =head1 LICENSE
 472
 473 This library is free software and may be distributed under the same terms
 474 as perl itself.
 475
 476 =cut