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