changelog/delta for shallow_clone

[gitmo/Moose.git] / lib / Moose / Exporter.pm

diff --git a/lib/Moose/Exporter.pm b/lib/Moose/Exporter.pm
index 9bf666c..fad3c25 100644 (file)
--- a/lib/Moose/Exporter.pm
+++ b/lib/Moose/Exporter.pm
@@ -28,6 +28,8 @@ sub build_import_methods {
 
     my $exporting_package = $args{exporting_package} ||= caller();
 
+    my $meta_lookup = $args{meta_lookup} || sub { Class::MOP::class_of(shift) };
+
     $EXPORT_SPEC{$exporting_package} = \%args;
 
     my @exports_from = $class->_follow_also($exporting_package);
@@ -39,28 +41,36 @@ sub build_import_methods {
         [ @exports_from, $exporting_package ],
         $export_recorder,
         $is_reexport,
+        $meta_lookup,
     );
 
-    my $exporter = $class->_make_exporter($exports, $is_reexport);
+    my $exporter = $class->_make_exporter(
+        $exports,
+        $is_reexport,
+        $meta_lookup,
+    );
 
     my %methods;
     $methods{import} = $class->_make_import_sub(
         $exporting_package,
         $exporter,
         \@exports_from,
-        $is_reexport
+        $is_reexport,
+        $meta_lookup,
     );
 
     $methods{unimport} = $class->_make_unimport_sub(
         $exporting_package,
         $exports,
         $export_recorder,
-        $is_reexport
+        $is_reexport,
+        $meta_lookup,
     );
 
     $methods{init_meta} = $class->_make_init_meta(
         $exporting_package,
-        \%args
+        \%args,
+        $meta_lookup,
     );
 
     my $package = Class::MOP::Package->initialize($exporting_package);
@@ -76,7 +86,7 @@ sub build_import_methods {
 }
 
 sub _make_exporter {
-    my ($class, $exports, $is_reexport) = @_;
+    my ($class, $exports, $is_reexport, $meta_lookup) = @_;
 
     return Sub::Exporter::build_exporter(
         {
@@ -84,7 +94,7 @@ sub _make_exporter {
             groups    => { default => [':all'] },
             installer => sub {
                 my ($arg, $to_export) = @_;
-                my $meta = Class::MOP::class_of($arg->{into});
+                my $meta = $meta_lookup->($arg->{into});
 
                 goto &Sub::Exporter::default_installer unless $meta;
 
@@ -188,6 +198,7 @@ sub _make_sub_exporter_params {
     my $packages        = shift;
     my $export_recorder = shift;
     my $is_reexport     = shift;
+    my $meta_lookup     = shift;
 
     my %exports;
 
@@ -205,6 +216,7 @@ sub _make_sub_exporter_params {
                 $fq_name,
                 $sub,
                 $export_recorder,
+                $meta_lookup,
             );
         }
 
@@ -303,13 +315,14 @@ sub _make_wrapped_sub_with_meta {
     my $fq_name         = shift;
     my $sub             = shift;
     my $export_recorder = shift;
+    my $meta_lookup     = shift;
 
     return sub {
         my $caller = $CALLER;
 
         my $wrapper = $self->_late_curry_wrapper(
             $sub, $fq_name,
-            sub { Class::MOP::class_of(shift) } => $caller
+            $meta_lookup => $caller
         );
 
         my $sub = subname( $fq_name => $wrapper );
@@ -365,6 +378,7 @@ sub _make_import_sub {
     my $exporter          = shift;
     my $exports_from      = shift;
     my $is_reexport       = shift;
+    my $meta_lookup       = shift;
 
     return sub {
 
@@ -425,7 +439,7 @@ sub _make_import_sub {
             # Moose::Exporter, which in turn sets $CALLER, so we need
             # to protect against that.
             local $CALLER = $CALLER;
-            _apply_meta_traits( $CALLER, $traits );
+            _apply_meta_traits( $CALLER, $traits, $meta_lookup );
         }
         elsif ( @{$traits} ) {
             require Moose;
@@ -486,11 +500,11 @@ sub _strip_meta_name {
 }
 
 sub _apply_meta_traits {
-    my ( $class, $traits ) = @_;
+    my ( $class, $traits, $meta_lookup ) = @_;
 
     return unless @{$traits};
 
-    my $meta = Class::MOP::class_of($class);
+    my $meta = $meta_lookup->($class);
 
     my $type = ( split /::/, ref $meta )[-1]
         or Moose->throw_error(
@@ -536,6 +550,7 @@ sub _make_unimport_sub {
     my $exports           = shift;
     my $export_recorder   = shift;
     my $is_reexport       = shift;
+    my $meta_lookup       = shift;
 
     return sub {
         my $caller = scalar caller();
@@ -579,8 +594,9 @@ sub _remove_keywords {
 
 sub _make_init_meta {
     shift;
-    my $class = shift;
-    my $args  = shift;
+    my $class          = shift;
+    my $args           = shift;
+    my $meta_lookup    = shift;
 
     my %old_style_roles;
     for my $role (
@@ -613,7 +629,7 @@ sub _make_init_meta {
         shift;
         my %options = @_;
 
-        return unless Class::MOP::class_of( $options{for_class} );
+        return unless $meta_lookup->( $options{for_class} );
 
         if ( %new_style_roles || %old_style_roles ) {
             Moose::Util::MetaRole::apply_metaroles(
@@ -627,10 +643,10 @@ sub _make_init_meta {
             for_class => $options{for_class},
             %base_class_roles,
             )
-            if Class::MOP::class_of( $options{for_class} )
+            if $meta_lookup->( $options{for_class} )
                 ->isa('Moose::Meta::Class');
 
-        return Class::MOP::class_of( $options{for_class} );
+        return $meta_lookup->( $options{for_class} );
     };
 }
 
@@ -765,6 +781,23 @@ can selectively override functions exported by another module.
 C<Moose::Exporter> also makes sure all these functions get removed
 when C<unimport> is called.
 
+=item * meta_lookup => sub { ... }
+
+This is a function which will be called to provide the metaclass
+to be operated upon by the exporter. This is an advanced feature
+intended for use by package generator modules in the vein of
+L<MooseX::Role::Parameterized> in order to simplify reusing sugar
+from other modules that use C<Moose::Exporter>. This function is
+used, for example, to select the metaclass to bind to functions
+that are exported using the C<with_meta> option.
+
+This function will receive one parameter: the class name into which
+the sugar is being exported. The default implementation is:
+
+    sub { Class::MOP::class_of(shift) }
+
+Accordingly, this function is expected to return a metaclass.
+
 =back
 
 You can also provide parameters for C<Moose::Util::MetaRole::apply_metaroles>