check requires before installing modifiers

[gitmo/Role-Tiny.git] / lib / Role / Tiny.pm

diff --git a/lib/Role/Tiny.pm b/lib/Role/Tiny.pm
index 6f6a97d..21688d4 100644 (file)
--- a/lib/Role/Tiny.pm
+++ b/lib/Role/Tiny.pm
@@ -6,7 +6,7 @@ sub _getstash { \%{"$_[0]::"} }
 use strict;
 use warnings FATAL => 'all';
 
-our $VERSION = '1.002004'; # 1.2.4
+our $VERSION = '1.002005'; # 1.2.5
 $VERSION = eval $VERSION;
 
 our %INFO;
@@ -44,6 +44,7 @@ sub import {
   strict->import;
   warnings->import(FATAL => 'all');
   return if $INFO{$target}; # already exported into this package
+  $INFO{$target}{is_role} = 1;
   # get symbol table reference
   my $stash = _getstash($target);
   # install before/after/around subs
@@ -64,28 +65,33 @@ sub import {
   };
   # grab all *non-constant* (stash slot is not a scalarref) subs present
   # in the symbol table and store their refaddrs (no need to forcibly
-  # inflate constant subs into real subs) - also add '' to here (this
-  # is used later) with a map to the coderefs in case of copying or re-use
-  my @not_methods = ('', map { *$_{CODE}||() } grep !ref($_), values %$stash);
+  # inflate constant subs into real subs) with a map to the coderefs in
+  # case of copying or re-use
+  my @not_methods = (map { *$_{CODE}||() } grep !ref($_), values %$stash);
   @{$INFO{$target}{not_methods}={}}{@not_methods} = @not_methods;
   # a role does itself
   $APPLIED_TO{$target} = { $target => undef };
 }
 
+sub role_application_steps {
+  qw(_install_methods _check_requires _install_modifiers _copy_applied_list);
+}
+
 sub apply_single_role_to_package {
   my ($me, $to, $role) = @_;
 
   _load_module($role);
 
   die "This is apply_role_to_package" if ref($to);
-  die "${role} is not a Role::Tiny" unless my $info = $INFO{$role};
+  die "${role} is not a Role::Tiny" unless $INFO{$role};
 
-  $me->_check_requires($to, $role, @{$info->{requires}||[]});
-
-  $me->_install_methods($to, $role);
-
-  $me->_install_modifiers($to, $info->{modifiers});
+  foreach my $step ($me->role_application_steps) {
+    $me->$step($to, $role);
+  }
+}
 
+sub _copy_applied_list {
+  my ($me, $to, $role) = @_;
   # copy our role list into the target's
   @{$APPLIED_TO{$to}||={}}{keys %{$APPLIED_TO{$role}}} = ();
 }
@@ -171,7 +177,7 @@ sub apply_roles_to_package {
   return $me->apply_role_to_package($to, $roles[0]) if @roles == 1;
 
   my %conflicts = %{$me->_composite_info_for(@roles)->{conflicts}};
-  delete $conflicts{$_} for $me->_concrete_methods_of($to);
+  delete $conflicts{$_} for keys %{ $me->_concrete_methods_of($to) };
   if (keys %conflicts) {
     my $fail = 
       join "\n",
@@ -190,8 +196,27 @@ sub apply_roles_to_package {
     delete $INFO{$to}{methods}; # reset since we're about to add methods
   }
 
-  foreach my $role (@roles) {
-    $me->apply_single_role_to_package($to, $role);
+  # backcompat: allow subclasses to use apply_single_role_to_package
+  # to apply changes.  set a local var so ours does nothing.
+  our %BACKCOMPAT_HACK;
+  if($me ne __PACKAGE__
+      and exists $BACKCOMPAT_HACK{$me} ? $BACKCOMPAT_HACK{$me} :
+      $BACKCOMPAT_HACK{$me} =
+        $me->can('role_application_steps')
+          == \&role_application_steps
+        && $me->can('apply_single_role_to_package')
+          != \&apply_single_role_to_package
+  ) {
+    foreach my $role (@roles) {
+      $me->apply_single_role_to_package($to, $role);
+    }
+  }
+  else {
+    foreach my $step ($me->role_application_steps) {
+      foreach my $role (@roles) {
+        $me->$step($to, $role);
+      }
+    }
   }
   $APPLIED_TO{$to}{join('|',@roles)} = 1;
 }
@@ -237,13 +262,14 @@ sub _composable_package_for {
     $e = "Evaling failed: $@\nTrying to eval:\n${code}" if $@;
   }
   die $e if $e;
-  $me->_install_modifiers($composed_name, $modifiers);
+  $me->_install_modifiers($composed_name, $role);
   $COMPOSED{role}{$composed_name} = 1;
   return $composed_name;
 }
 
 sub _check_requires {
-  my ($me, $to, $name, @requires) = @_;
+  my ($me, $to, $name) = @_;
+  return unless my @requires = @{$INFO{$name}{requires}||[]};
   if (my @requires_fail = grep !$to->can($_), @requires) {
     # role -> role, add to requires, role -> class, error out
     if (my $to_info = $INFO{$to}) {
@@ -266,8 +292,7 @@ sub _concrete_methods_of {
     # grab all code entries that aren't in the not_methods list
     map {
       my $code = *{$stash->{$_}}{CODE};
-      # rely on the '' key we added in import for "no code here"
-      exists $not_methods->{$code||''} ? () : ($_ => $code)
+      ( ! $code or exists $not_methods->{$code} ) ? () : ($_ => $code)
     } grep !ref($stash->{$_}), keys %$stash
   };
 }
@@ -304,7 +329,8 @@ sub _install_methods {
 }
 
 sub _install_modifiers {
-  my ($me, $to, $modifiers) = @_;
+  my ($me, $to, $name) = @_;
+  return unless my $modifiers = $INFO{$name}{modifiers};
   if (my $info = $INFO{$to}) {
     push @{$info->{modifiers}}, @{$modifiers||[]};
   } else {
@@ -362,8 +388,15 @@ sub does_role {
   return 0;
 }
 
+sub is_role {
+  my ($me, $role) = @_;
+  return !!$INFO{$role};
+}
+
 1;
 
+=encoding utf-8
+
 =head1 NAME
 
 Role::Tiny - Roles. Like a nouvelle cuisine portion size slice of Moose.
@@ -511,7 +544,7 @@ will work for classes but to test a role, one must use ::does_role directly.
 
 Additionally, Role::Tiny will override the standard Perl C<DOES> method
 for your class. However, if C<any> class in your class' inheritance
-heirarchy provides C<DOES>, then Role::Tiny will not override it.
+hierarchy provides C<DOES>, then Role::Tiny will not override it.
 
 =head1 METHODS
 
@@ -537,6 +570,12 @@ resulting class.
 Creates a new class based on base, with the roles composed into it in order.
 New class is returned.
 
+=head2 is_role
+
+ Role::Tiny->is_role('Some::Role1')
+
+Returns true if the given package is a role.
+
 =head1 SEE ALSO
 
 L<Role::Tiny> is the attribute-less subset of L<Moo::Role>; L<Moo::Role> is