package namespace::clean;
-
-=head1 NAME
-
-namespace::clean - Keep imports and functions out of your namespace
-
-=cut
+# ABSTRACT: Keep imports and functions out of your namespace
use warnings;
use strict;
-use vars qw( $VERSION $STORAGE_VAR $SCOPE_HOOK_KEY $SCOPE_EXPLICIT );
-use Symbol qw( qualify_to_ref );
-use B::Hooks::EndOfScope;
-
-=head1 VERSION
+use vars qw( $STORAGE_VAR $SCOPE_HOOK_KEY $SCOPE_EXPLICIT );
+use Sub::Name 0.04 qw(subname);
+use Sub::Identify 0.04 qw(sub_fullname);
+use Package::Stash 0.03;
+use B::Hooks::EndOfScope 0.07;
-0.10
-
-=cut
-
-$VERSION = '0.10';
$STORAGE_VAR = '__NAMESPACE_CLEAN_STORAGE';
=head1 SYNOPSIS
When you define a function, or import one, into a Perl package, it will
naturally also be available as a method. This does not per se cause
problems, but it can complicate subclassing and, for example, plugin
-classes that are included via multiple inheritance by loading them as
+classes that are included via multiple inheritance by loading them as
base classes.
The C<namespace::clean> pragma will remove all previously declared or
Same goes for L<Moose::Role>.
-=head1 METHODS
+=head2 Cleaning other packages
-You shouldn't need to call any of these. Just C<use> the package at the
-appropriate place.
+You can tell C<namespace::clean> that you want to clean up another package
+instead of the one importing. To do this you have to pass in the C<-cleanee>
+option like this:
-=cut
+ package My::MooseX::namespace::clean;
+ use strict;
-=head2 import
+ use namespace::clean (); # no cleanup, just load
-Makes a snapshot of the current defined functions and installs a
-L<B::Hooks::EndOfScope> hook in the current scope to invoke the cleanups.
+ sub import {
+ namespace::clean->import(
+ -cleanee => scalar(caller),
+ -except => 'meta',
+ );
+ }
+
+If you don't care about C<namespace::clean>s discover-and-C<-except> logic, and
+just want to remove subroutines, try L</clean_subroutines>.
+
+=method clean_subroutines
+
+This exposes the actual subroutine-removal logic.
+
+ namespace::clean->clean_subroutines($cleanee, qw( subA subB ));
+
+will remove C<subA> and C<subB> from C<$cleanee>. Note that this will remove the
+subroutines B<immediately> and not wait for scope end. If you want to have this
+effect at a specific time (e.g. C<namespace::clean> acts on scope compile end)
+it is your responsibility to make sure it runs at that time.
=cut
my $RemoveSubs = sub {
+
my $cleanee = shift;
my $store = shift;
+ my $cleanee_stash = Package::Stash->new($cleanee);
+ my $deleted_stash = Package::Stash->new("namespace::clean::deleted::$cleanee");
SYMBOL:
for my $f (@_) {
-
+ my $variable = "&$f";
# ignore already removed symbols
next SYMBOL if $store->{exclude}{ $f };
- no strict 'refs';
- # keep original value to restore non-code slots
- { no warnings 'uninitialized'; # fix possible unimports
- local *__tmp = *{ ${ "${cleanee}::" }{ $f } };
- delete ${ "${cleanee}::" }{ $f };
+ next SYMBOL unless $cleanee_stash->has_package_symbol($variable);
+
+ if (ref(\$cleanee_stash->namespace->{$f}) eq 'GLOB') {
+ # convince the Perl debugger to work
+ # it assumes that sub_fullname($sub) can always be used to find the CV again
+ # since we are deleting the glob where the subroutine was originally
+ # defined, that assumption no longer holds, so we need to move it
+ # elsewhere and point the CV's name to the new glob.
+ my $sub = $cleanee_stash->get_package_symbol($variable);
+ if ( sub_fullname($sub) eq ($cleanee_stash->name . "::$f") ) {
+ my $new_fq = $deleted_stash->name . "::$f";
+ subname($new_fq, $sub);
+ $deleted_stash->add_package_symbol($variable, $sub);
+ }
}
- SLOT:
- # restore non-code slots to symbol
- for my $t (qw( SCALAR ARRAY HASH IO FORMAT )) {
- next SLOT unless defined *__tmp{ $t };
- *{ "${cleanee}::$f" } = *__tmp{ $t };
- }
+ $cleanee_stash->remove_package_symbol($variable);
}
};
+sub clean_subroutines {
+ my ($nc, $cleanee, @subs) = @_;
+ $RemoveSubs->($cleanee, {}, @subs);
+}
+
+=method import
+
+Makes a snapshot of the current defined functions and installs a
+L<B::Hooks::EndOfScope> hook in the current scope to invoke the cleanups.
+
+=cut
+
sub import {
my ($pragma, @args) = @_;
my (%args, $is_explicit);
- if (@args and $args[0] =~ /^\-/) {
- %args = @args;
- @args = ();
- }
- elsif (@args) {
- $is_explicit++;
+
+ ARG:
+ while (@args) {
+
+ if ($args[0] =~ /^\-/) {
+ my $key = shift @args;
+ my $value = shift @args;
+ $args{ $key } = $value;
+ }
+ else {
+ $is_explicit++;
+ last ARG;
+ }
}
- my $cleanee = caller;
+ my $cleanee = exists $args{ -cleanee } ? $args{ -cleanee } : scalar caller;
if ($is_explicit) {
on_scope_end {
$RemoveSubs->($cleanee, {}, @args);
# calling class, all current functions and our storage
my $functions = $pragma->get_functions($cleanee);
my $store = $pragma->get_class_store($cleanee);
+ my $stash = Package::Stash->new($cleanee);
# except parameter can be array ref or single value
my %except = map {( $_ => 1 )} (
# register symbols for removal, if they have a CODE entry
for my $f (keys %$functions) {
next if $except{ $f };
- next unless $functions->{ $f }
- and *{ $functions->{ $f } }{CODE};
+ next unless $stash->has_package_symbol("&$f");
$store->{remove}{ $f } = 1;
}
}
}
-=head2 unimport
+=method unimport
This method will be called when you do a
=cut
sub unimport {
- my ($pragma) = @_;
+ my ($pragma, %args) = @_;
# the calling class, the current functions and our storage
- my $cleanee = caller;
+ my $cleanee = exists $args{ -cleanee } ? $args{ -cleanee } : scalar caller;
my $functions = $pragma->get_functions($cleanee);
my $store = $pragma->get_class_store($cleanee);
return 1;
}
-=head2 get_class_store
+=method get_class_store
-This returns a reference to a hash in a passed package containing
+This returns a reference to a hash in a passed package containing
information about function names included and excluded from removal.
=cut
sub get_class_store {
my ($pragma, $class) = @_;
- no strict 'refs';
- return \%{ "${class}::${STORAGE_VAR}" };
+ my $stash = Package::Stash->new($class);
+ return $stash->get_package_symbol("%$STORAGE_VAR");
}
-=head2 get_functions
+=method get_functions
Takes a class as argument and returns all currently defined functions
in it as a hash reference with the function name as key and a typeglob
sub get_functions {
my ($pragma, $class) = @_;
+ my $stash = Package::Stash->new($class);
return {
- map { @$_ } # key => value
- grep { *{ $_->[1] }{CODE} } # only functions
- map { [$_, qualify_to_ref( $_, $class )] } # get globref
- grep { $_ !~ /::$/ } # no packages
- do { no strict 'refs'; keys %{ "${class}::" } } # symbol entries
+ map { $_ => $stash->get_package_symbol("&$_") }
+ $stash->list_all_package_symbols('CODE')
};
}
=head1 IMPLEMENTATION DETAILS
-This module works through the effect that a
+This module works through the effect that a
delete $SomePackage::{foo};
L<B::Hooks::EndOfScope>
-=head1 AUTHOR AND COPYRIGHT
-
-Robert 'phaylon' Sedlacek C<E<lt>rs@474.atE<gt>>, with many thanks to
-Matt S Trout for the inspiration on the whole idea.
-
-=head1 LICENSE
+=head1 THANKS
-This program is free software; you can redistribute it and/or modify
-it under the same terms as perl itself.
+Many thanks to Matt S Trout for the inspiration on the whole idea.
=cut
projects / p5sagit/namespace-clean.git / blobdiff