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