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.002005'; # 1.2.5
  10 $VERSION = eval $VERSION;
  11
  12 our %INFO;
  13 our %APPLIED_TO;
  14 our %COMPOSED;
  15 our %COMPOSITE_INFO;
  16
  17 # Module state workaround totally stolen from Zefram's Module::Runtime.
  18
  19 BEGIN {
  20   *_WORK_AROUND_BROKEN_MODULE_STATE = "$]" < 5.009 ? sub(){1} : sub(){0};
  21 }
  22
  23 sub Role::Tiny::__GUARD__::DESTROY {
  24   delete $INC{$_[0]->[0]} if @{$_[0]};
  25 }
  26
  27 sub _load_module {
  28   (my $proto = $_[0]) =~ s/::/\//g;
  29   $proto .= '.pm';
  30   return 1 if $INC{$proto};
  31   # can't just ->can('can') because a sub-package Foo::Bar::Baz
  32   # creates a 'Baz::' key in Foo::Bar's symbol table
  33   return 1 if grep !/::$/, keys %{_getstash($_[0])||{}};
  34   my $guard = _WORK_AROUND_BROKEN_MODULE_STATE
  35     && bless([ $proto ], 'Role::Tiny::__GUARD__');
  36   require $proto;
  37   pop @$guard if _WORK_AROUND_BROKEN_MODULE_STATE;
  38   return 1;
  39 }
  40
  41 sub import {
  42   my $target = caller;
  43   my $me = shift;
  44   strict->import;
  45   warnings->import(FATAL => 'all');
  46   return if $INFO{$target}; # already exported into this package
  47   $INFO{$target}{is_role} = 1;
  48   # get symbol table reference
  49   my $stash = _getstash($target);
  50   # install before/after/around subs
  51   foreach my $type (qw(before after around)) {
  52     *{_getglob "${target}::${type}"} = sub {
  53       require Class::Method::Modifiers;
  54       push @{$INFO{$target}{modifiers}||=[]}, [ $type => @_ ];
  55       return;
  56     };
  57   }
  58   *{_getglob "${target}::requires"} = sub {
  59     push @{$INFO{$target}{requires}||=[]}, @_;
  60     return;
  61   };
  62   *{_getglob "${target}::with"} = sub {
  63     $me->apply_roles_to_package($target, @_);
  64     return;
  65   };
  66   # grab all *non-constant* (stash slot is not a scalarref) subs present
  67   # in the symbol table and store their refaddrs (no need to forcibly
  68   # inflate constant subs into real subs) with a map to the coderefs in
  69   # case of copying or re-use
  70   my @not_methods = (map { *$_{CODE}||() } grep !ref($_), values %$stash);
  71   @{$INFO{$target}{not_methods}={}}{@not_methods} = @not_methods;
  72   # a role does itself
  73   $APPLIED_TO{$target} = { $target => undef };
  74 }
  75
  76 sub apply_single_role_to_package {
  77   my ($me, $to, $role) = @_;
  78
  79   _load_module($role);
  80
  81   die "This is apply_role_to_package" if ref($to);
  82   die "${role} is not a Role::Tiny" unless my $info = $INFO{$role};
  83
  84   $me->_check_requires($to, $role, @{$info->{requires}||[]});
  85
  86   $me->_install_methods($to, $role);
  87
  88   $me->_install_modifiers($to, $info->{modifiers});
  89
  90   # copy our role list into the target's
  91   @{$APPLIED_TO{$to}||={}}{keys %{$APPLIED_TO{$role}}} = ();
  92 }
  93
  94 sub apply_roles_to_object {
  95   my ($me, $object, @roles) = @_;
  96   die "No roles supplied!" unless @roles;
  97   my $class = ref($object);
  98   bless($object, $me->create_class_with_roles($class, @roles));
  99   $object;
 100 }
 101
 102 sub create_class_with_roles {
 103   my ($me, $superclass, @roles) = @_;
 104
 105   die "No roles supplied!" unless @roles;
 106
 107   _load_module($superclass);
 108   {
 109     my %seen;
 110     $seen{$_}++ for @roles;
 111     if (my @dupes = grep $seen{$_} > 1, @roles) {
 112       die "Duplicated roles: ".join(', ', @dupes);
 113     }
 114   }
 115
 116   my $new_name = join(
 117     '__WITH__', $superclass, my $compose_name = join '__AND__', @roles
 118   );
 119
 120   return $new_name if $COMPOSED{class}{$new_name};
 121
 122   foreach my $role (@roles) {
 123     _load_module($role);
 124     die "${role} is not a Role::Tiny" unless $INFO{$role};
 125   }
 126
 127   if ($] >= 5.010) {
 128     require mro;
 129   } else {
 130     require MRO::Compat;
 131   }
 132
 133   my %conflicts = %{$me->_composite_info_for(@roles)->{conflicts}};
 134   if (keys %conflicts) {
 135     my $fail =
 136       join "\n",
 137         map {
 138           "Method name conflict for '$_' between roles "
 139           ."'".join(' and ', sort values %{$conflicts{$_}})."'"
 140           .", cannot apply these simultaneously to an object."
 141         } keys %conflicts;
 142     die $fail;
 143   }
 144
 145   my @composable = map $me->_composable_package_for($_), reverse @roles;
 146
 147   *{_getglob("${new_name}::ISA")} = [ @composable, $superclass ];
 148
 149   my @info = map $INFO{$_}, @roles;
 150
 151   $me->_check_requires(
 152     $new_name, $compose_name,
 153     do { my %h; @h{map @{$_->{requires}||[]}, @info} = (); keys %h }
 154   );
 155
 156   @{$APPLIED_TO{$new_name}||={}}{
 157     map keys %{$APPLIED_TO{$_}}, @roles
 158   } = ();
 159
 160   $COMPOSED{class}{$new_name} = 1;
 161   return $new_name;
 162 }
 163
 164 # preserved for compat, and apply_roles_to_package calls it to allow an
 165 # updated Role::Tiny to use a non-updated Moo::Role
 166
 167 sub apply_role_to_package { shift->apply_single_role_to_package(@_) }
 168
 169 sub apply_roles_to_package {
 170   my ($me, $to, @roles) = @_;
 171
 172   return $me->apply_role_to_package($to, $roles[0]) if @roles == 1;
 173
 174   my %conflicts = %{$me->_composite_info_for(@roles)->{conflicts}};
 175   delete $conflicts{$_} for keys %{ $me->_concrete_methods_of($to) };
 176   if (keys %conflicts) {
 177     my $fail =
 178       join "\n",
 179         map {
 180           "Due to a method name conflict between roles "
 181           ."'".join(' and ', sort values %{$conflicts{$_}})."'"
 182           .", the method '$_' must be implemented by '${to}'"
 183         } keys %conflicts;
 184     die $fail;
 185   }
 186
 187   # the if guard here is essential since otherwise we accidentally create
 188   # a $INFO for something that isn't a Role::Tiny (or Moo::Role) because
 189   # autovivification hates us and wants us to die()
 190   if ($INFO{$to}) {
 191     delete $INFO{$to}{methods}; # reset since we're about to add methods
 192   }
 193
 194   foreach my $role (@roles) {
 195     $me->apply_single_role_to_package($to, $role);
 196   }
 197   $APPLIED_TO{$to}{join('|',@roles)} = 1;
 198 }
 199
 200 sub _composite_info_for {
 201   my ($me, @roles) = @_;
 202   $COMPOSITE_INFO{join('|', sort @roles)} ||= do {
 203     foreach my $role (@roles) {
 204       _load_module($role);
 205     }
 206     my %methods;
 207     foreach my $role (@roles) {
 208       my $this_methods = $me->_concrete_methods_of($role);
 209       $methods{$_}{$this_methods->{$_}} = $role for keys %$this_methods;
 210     }
 211     delete $methods{$_} for grep keys(%{$methods{$_}}) == 1, keys %methods;
 212     +{ conflicts => \%methods }
 213   };
 214 }
 215
 216 sub _composable_package_for {
 217   my ($me, $role) = @_;
 218   my $composed_name = 'Role::Tiny::_COMPOSABLE::'.$role;
 219   return $composed_name if $COMPOSED{role}{$composed_name};
 220   $me->_install_methods($composed_name, $role);
 221   my $base_name = $composed_name.'::_BASE';
 222   # Not using _getglob, since setting @ISA via the typeglob breaks
 223   # inheritance on 5.10.0 if the stash has previously been accessed an
 224   # then a method called on the class (in that order!), which
 225   # ->_install_methods (with the help of ->_install_does) ends up doing.
 226   { no strict 'refs'; @{"${composed_name}::ISA"} = ( $base_name ); }
 227   my $modifiers = $INFO{$role}{modifiers}||[];
 228   my @mod_base;
 229   foreach my $modified (
 230     do { my %h; @h{map $_->[1], @$modifiers} = (); keys %h }
 231   ) {
 232     push @mod_base, "sub ${modified} { shift->next::method(\@_) }";
 233   }
 234   my $e;
 235   {
 236     local $@;
 237     eval(my $code = join "\n", "package ${base_name};", @mod_base);
 238     $e = "Evaling failed: $@\nTrying to eval:\n${code}" if $@;
 239   }
 240   die $e if $e;
 241   $me->_install_modifiers($composed_name, $modifiers);
 242   $COMPOSED{role}{$composed_name} = 1;
 243   return $composed_name;
 244 }
 245
 246 sub _check_requires {
 247   my ($me, $to, $name, @requires) = @_;
 248   if (my @requires_fail = grep !$to->can($_), @requires) {
 249     # role -> role, add to requires, role -> class, error out
 250     if (my $to_info = $INFO{$to}) {
 251       push @{$to_info->{requires}||=[]}, @requires_fail;
 252     } else {
 253       die "Can't apply ${name} to ${to} - missing ".join(', ', @requires_fail);
 254     }
 255   }
 256 }
 257
 258 sub _concrete_methods_of {
 259   my ($me, $role) = @_;
 260   my $info = $INFO{$role};
 261   # grab role symbol table
 262   my $stash = _getstash($role);
 263   # reverse so our keys become the values (captured coderefs) in case
 264   # they got copied or re-used since
 265   my $not_methods = { reverse %{$info->{not_methods}||{}} };
 266   $info->{methods} ||= +{
 267     # grab all code entries that aren't in the not_methods list
 268     map {
 269       my $code = *{$stash->{$_}}{CODE};
 270       ( ! $code or exists $not_methods->{$code} ) ? () : ($_ => $code)
 271     } grep !ref($stash->{$_}), keys %$stash
 272   };
 273 }
 274
 275 sub methods_provided_by {
 276   my ($me, $role) = @_;
 277   die "${role} is not a Role::Tiny" unless my $info = $INFO{$role};
 278   (keys %{$me->_concrete_methods_of($role)}, @{$info->{requires}||[]});
 279 }
 280
 281 sub _install_methods {
 282   my ($me, $to, $role) = @_;
 283
 284   my $info = $INFO{$role};
 285
 286   my $methods = $me->_concrete_methods_of($role);
 287
 288   # grab target symbol table
 289   my $stash = _getstash($to);
 290
 291   # determine already extant methods of target
 292   my %has_methods;
 293   @has_methods{grep
 294     +(ref($stash->{$_}) || *{$stash->{$_}}{CODE}),
 295     keys %$stash
 296   } = ();
 297
 298   foreach my $i (grep !exists $has_methods{$_}, keys %$methods) {
 299     no warnings 'once';
 300     *{_getglob "${to}::${i}"} = $methods->{$i};
 301   }
 302
 303   $me->_install_does($to);
 304 }
 305
 306 sub _install_modifiers {
 307   my ($me, $to, $modifiers) = @_;
 308   if (my $info = $INFO{$to}) {
 309     push @{$info->{modifiers}}, @{$modifiers||[]};
 310   } else {
 311     foreach my $modifier (@{$modifiers||[]}) {
 312       $me->_install_single_modifier($to, @$modifier);
 313     }
 314   }
 315 }
 316
 317 my $vcheck_error;
 318
 319 sub _install_single_modifier {
 320   my ($me, @args) = @_;
 321   defined($vcheck_error) or $vcheck_error = do {
 322     local $@;
 323     eval { Class::Method::Modifiers->VERSION(1.05); 1 }
 324       ? 0
 325       : $@
 326   };
 327   $vcheck_error and die $vcheck_error;
 328   Class::Method::Modifiers::install_modifier(@args);
 329 }
 330
 331 my $FALLBACK = sub { 0 };
 332 sub _install_does {
 333   my ($me, $to) = @_;
 334
 335   # only add does() method to classes
 336   return if $INFO{$to};
 337
 338   # add does() only if they don't have one
 339   *{_getglob "${to}::does"} = \&does_role unless $to->can('does');
 340
 341   return if ($to->can('DOES') and $to->can('DOES') != (UNIVERSAL->can('DOES') || 0));
 342
 343   my $existing = $to->can('DOES') || $to->can('isa') || $FALLBACK;
 344   my $new_sub = sub {
 345     my ($proto, $role) = @_;
 346     Role::Tiny::does_role($proto, $role) or $proto->$existing($role);
 347   };
 348   no warnings 'redefine';
 349   *{_getglob "${to}::DOES"} = $new_sub;
 350 }
 351
 352 sub does_role {
 353   my ($proto, $role) = @_;
 354   if ($] >= 5.010) {
 355     require mro;
 356   } else {
 357     require MRO::Compat;
 358   }
 359   foreach my $class (@{mro::get_linear_isa(ref($proto)||$proto)}) {
 360     return 1 if exists $APPLIED_TO{$class}{$role};
 361   }
 362   return 0;
 363 }
 364
 365 sub is_role {
 366   my ($me, $role) = @_;
 367   return !!$INFO{$role};
 368 }
 369
 370 1;
 371
 372 =encoding utf-8
 373
 374 =head1 NAME
 375
 376 Role::Tiny - Roles. Like a nouvelle cuisine portion size slice of Moose.
 377
 378 =head1 SYNOPSIS
 379
 380  package Some::Role;
 381
 382  use Role::Tiny;
 383
 384  sub foo { ... }
 385
 386  sub bar { ... }
 387
 388  around baz => sub { ... }
 389
 390  1;
 391
 392 else where
 393
 394  package Some::Class;
 395
 396  use Role::Tiny::With;
 397
 398  # bar gets imported, but not foo
 399  with 'Some::Role';
 400
 401  sub foo { ... }
 402
 403  # baz is wrapped in the around modifier by Class::Method::Modifiers
 404  sub baz { ... }
 405
 406  1;
 407
 408 If you wanted attributes as well, look at L<Moo::Role>.
 409
 410 =head1 DESCRIPTION
 411
 412 C<Role::Tiny> is a minimalist role composition tool.
 413
 414 =head1 ROLE COMPOSITION
 415
 416 Role composition can be thought of as much more clever and meaningful multiple
 417 inheritance.  The basics of this implementation of roles is:
 418
 419 =over 2
 420
 421 =item *
 422
 423 If a method is already defined on a class, that method will not be composed in
 424 from the role.
 425
 426 =item *
 427
 428 If a method that the role L</requires> to be implemented is not implemented,
 429 role application will fail loudly.
 430
 431 =back
 432
 433 Unlike L<Class::C3>, where the B<last> class inherited from "wins," role
 434 composition is the other way around, where the class wins. If multiple roles
 435 are applied in a single call (single with statement), then if any of their
 436 provided methods clash, an exception is raised unless the class provides
 437 a method since this conflict indicates a potential problem.
 438
 439 =head1 IMPORTED SUBROUTINES
 440
 441 =head2 requires
 442
 443  requires qw(foo bar);
 444
 445 Declares a list of methods that must be defined to compose role.
 446
 447 =head2 with
 448
 449  with 'Some::Role1';
 450
 451  with 'Some::Role1', 'Some::Role2';
 452
 453 Composes another role into the current role (or class via L<Role::Tiny::With>).
 454
 455 If you have conflicts and want to resolve them in favour of Some::Role1 you
 456 can instead write:
 457
 458  with 'Some::Role1';
 459  with 'Some::Role2';
 460
 461 If you have conflicts and want to resolve different conflicts in favour of
 462 different roles, please refactor your codebase.
 463
 464 =head2 before
 465
 466  before foo => sub { ... };
 467
 468 See L<< Class::Method::Modifiers/before method(s) => sub { ... } >> for full
 469 documentation.
 470
 471 Note that since you are not required to use method modifiers,
 472 L<Class::Method::Modifiers> is lazily loaded and we do not declare it as
 473 a dependency. If your L<Role::Tiny> role uses modifiers you must depend on
 474 both L<Class::Method::Modifiers> and L<Role::Tiny>.
 475
 476 =head2 around
 477
 478  around foo => sub { ... };
 479
 480 See L<< Class::Method::Modifiers/around method(s) => sub { ... } >> for full
 481 documentation.
 482
 483 Note that since you are not required to use method modifiers,
 484 L<Class::Method::Modifiers> is lazily loaded and we do not declare it as
 485 a dependency. If your L<Role::Tiny> role uses modifiers you must depend on
 486 both L<Class::Method::Modifiers> and L<Role::Tiny>.
 487
 488 =head2 after
 489
 490  after foo => sub { ... };
 491
 492 See L<< Class::Method::Modifiers/after method(s) => sub { ... } >> for full
 493 documentation.
 494
 495 Note that since you are not required to use method modifiers,
 496 L<Class::Method::Modifiers> is lazily loaded and we do not declare it as
 497 a dependency. If your L<Role::Tiny> role uses modifiers you must depend on
 498 both L<Class::Method::Modifiers> and L<Role::Tiny>.
 499
 500 =head1 SUBROUTINES
 501
 502 =head2 does_role
 503
 504  if (Role::Tiny::does_role($foo, 'Some::Role')) {
 505    ...
 506  }
 507
 508 Returns true if class has been composed with role.
 509
 510 This subroutine is also installed as ->does on any class a Role::Tiny is
 511 composed into unless that class already has an ->does method, so
 512
 513   if ($foo->does('Some::Role')) {
 514     ...
 515   }
 516
 517 will work for classes but to test a role, one must use ::does_role directly.
 518
 519 Additionally, Role::Tiny will override the standard Perl C<DOES> method
 520 for your class. However, if C<any> class in your class' inheritance
 521 hierarchy provides C<DOES>, then Role::Tiny will not override it.
 522
 523 =head1 METHODS
 524
 525 =head2 apply_roles_to_package
 526
 527  Role::Tiny->apply_roles_to_package(
 528    'Some::Package', 'Some::Role', 'Some::Other::Role'
 529  );
 530
 531 Composes role with package.  See also L<Role::Tiny::With>.
 532
 533 =head2 apply_roles_to_object
 534
 535  Role::Tiny->apply_roles_to_object($foo, qw(Some::Role1 Some::Role2));
 536
 537 Composes roles in order into object directly.  Object is reblessed into the
 538 resulting class.
 539
 540 =head2 create_class_with_roles
 541
 542  Role::Tiny->create_class_with_roles('Some::Base', qw(Some::Role1 Some::Role2));
 543
 544 Creates a new class based on base, with the roles composed into it in order.
 545 New class is returned.
 546
 547 =head2 is_role
 548
 549  Role::Tiny->is_role('Some::Role1')
 550
 551 Returns true if the given package is a role.
 552
 553 =head1 SEE ALSO
 554
 555 L<Role::Tiny> is the attribute-less subset of L<Moo::Role>; L<Moo::Role> is
 556 a meta-protocol-less subset of the king of role systems, L<Moose::Role>.
 557
 558 If you don't want method modifiers and do want to be forcibly restricted
 559 to a single role application per class, Ovid's L<Role::Basic> exists. But
 560 Stevan Little (the L<Moose> author) and I don't find the additional
 561 restrictions to be amazingly helpful in most cases; L<Role::Basic>'s choices
 562 are more a guide to what you should prefer doing, to our mind, rather than
 563 something that needs to be enforced.
 564
 565 =head1 AUTHOR
 566
 567 mst - Matt S. Trout (cpan:MSTROUT) <mst@shadowcat.co.uk>
 568
 569 =head1 CONTRIBUTORS
 570
 571 dg - David Leadbeater (cpan:DGL) <dgl@dgl.cx>
 572
 573 frew - Arthur Axel "fREW" Schmidt (cpan:FREW) <frioux@gmail.com>
 574
 575 hobbs - Andrew Rodland (cpan:ARODLAND) <arodland@cpan.org>
 576
 577 jnap - John Napiorkowski (cpan:JJNAPIORK) <jjn1056@yahoo.com>
 578
 579 ribasushi - Peter Rabbitson (cpan:RIBASUSHI) <ribasushi@cpan.org>
 580
 581 chip - Chip Salzenberg (cpan:CHIPS) <chip@pobox.com>
 582
 583 ajgb - Alex J. G. Burzyński (cpan:AJGB) <ajgb@cpan.org>
 584
 585 doy - Jesse Luehrs (cpan:DOY) <doy at tozt dot net>
 586
 587 perigrin - Chris Prather (cpan:PERIGRIN) <chris@prather.org>
 588
 589 Mithaldu - Christian Walde (cpan:MITHALDU) <walde.christian@googlemail.com>
 590
 591 ilmari - Dagfinn Ilmari Mannsåker (cpan:ILMARI) <ilmari@ilmari.org>
 592
 593 tobyink - Toby Inkster (cpan:TOBYINK) <tobyink@cpan.org>
 594
 595 =head1 COPYRIGHT
 596
 597 Copyright (c) 2010-2012 the Role::Tiny L</AUTHOR> and L</CONTRIBUTORS>
 598 as listed above.
 599
 600 =head1 LICENSE
 601
 602 This library is free software and may be distributed under the same terms
 603 as perl itself.
 604
 605 =cut