extra testing for extending create_class_with_roles

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

diff --git a/lib/Role/Tiny.pm b/lib/Role/Tiny.pm
index 8cf0da5..751527d 100644 (file)
--- a/lib/Role/Tiny.pm
+++ b/lib/Role/Tiny.pm
@@ -73,20 +73,25 @@ sub import {
   $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};
-
-  $me->_check_requires($to, $role, @{$info->{requires}||[]});
+  die "${role} is not a Role::Tiny" unless $INFO{$role};
 
-  $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}}} = ();
 }
@@ -130,7 +135,10 @@ sub create_class_with_roles {
     require MRO::Compat;
   }
 
-  my %conflicts = %{$me->_composite_info_for(@roles)->{conflicts}};
+  my @composable = map $me->_composable_package_for($_), reverse @roles;
+
+  my $composite_info = $me->_composite_info_for(@roles);
+  my %conflicts = %{$composite_info->{conflicts}};
   if (keys %conflicts) {
     my $fail = 
       join "\n",
@@ -142,17 +150,18 @@ sub create_class_with_roles {
     die $fail;
   }
 
-  my @composable = map $me->_composable_package_for($_), reverse @roles;
-
-  *{_getglob("${new_name}::ISA")} = [ @composable, $superclass ];
-
-  my @info = map $INFO{$_}, @roles;
+  my @requires = grep {
+    my $method = $_;
+    !grep $_->can($method) && !$COMPOSED{role}{$_}{modifiers_only}{$method},
+      @composable
+  } @{$composite_info->{requires}};
 
   $me->_check_requires(
-    $new_name, $compose_name,
-    do { my %h; @h{map @{$_->{requires}||[]}, @info} = (); keys %h }
+    $superclass, $compose_name, \@requires
   );
 
+  *{_getglob("${new_name}::ISA")} = [ @composable, $superclass ];
+
   @{$APPLIED_TO{$new_name}||={}}{
     map keys %{$APPLIED_TO{$_}}, @roles
   } = ();
@@ -191,8 +200,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;
 }
@@ -208,8 +236,11 @@ sub _composite_info_for {
       my $this_methods = $me->_concrete_methods_of($role);
       $methods{$_}{$this_methods->{$_}} = $role for keys %$this_methods;
     }
+    my %requires;
+    @requires{map @{$INFO{$_}{requires}||[]}, @roles} = ();
+    delete $requires{$_} for keys %methods;
     delete $methods{$_} for grep keys(%{$methods{$_}}) == 1, keys %methods;
-    +{ conflicts => \%methods }
+    +{ conflicts => \%methods, requires => [keys %requires] }
   };
 }
 
@@ -219,6 +250,8 @@ sub _composable_package_for {
   return $composed_name if $COMPOSED{role}{$composed_name};
   $me->_install_methods($composed_name, $role);
   my $base_name = $composed_name.'::_BASE';
+  # force stash to exist
+  _getstash($base_name);
   # Not using _getglob, since setting @ISA via the typeglob breaks
   # inheritance on 5.10.0 if the stash has previously been accessed an
   # then a method called on the class (in that order!), which
@@ -226,9 +259,9 @@ sub _composable_package_for {
   { no strict 'refs'; @{"${composed_name}::ISA"} = ( $base_name ); }
   my $modifiers = $INFO{$role}{modifiers}||[];
   my @mod_base;
-  foreach my $modified (
-    do { my %h; @h{map $_->[1], @$modifiers} = (); keys %h }
-  ) {
+  my @modifiers = grep !$composed_name->can($_),
+    do { my %h; @h{map @{$_}[1..$#$_-1], @$modifiers} = (); keys %h };
+  foreach my $modified (@modifiers) {
     push @mod_base, "sub ${modified} { shift->next::method(\@_) }";
   }
   my $e;
@@ -238,13 +271,16 @@ sub _composable_package_for {
     $e = "Evaling failed: $@\nTrying to eval:\n${code}" if $@;
   }
   die $e if $e;
-  $me->_install_modifiers($composed_name, $modifiers);
-  $COMPOSED{role}{$composed_name} = 1;
+  $me->_install_modifiers($composed_name, $role);
+  $COMPOSED{role}{$composed_name} = {
+    modifiers_only => { map { $_ => 1 } @modifiers },
+  };
   return $composed_name;
 }
 
 sub _check_requires {
-  my ($me, $to, $name, @requires) = @_;
+  my ($me, $to, $name, $requires) = @_;
+  return unless my @requires = @{$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}) {
@@ -304,7 +340,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 {