package namespace::clean;
-# ABSTRACT: Keep imports and functions out of your namespace
use warnings;
use strict;
-use vars qw( $STORAGE_VAR );
-use Package::Stash;
+our $VERSION = '0.25';
+our $STORAGE_VAR = '__NAMESPACE_CLEAN_STORAGE';
-our $VERSION = '0.21';
-
-$STORAGE_VAR = '__NAMESPACE_CLEAN_STORAGE';
+use B::Hooks::EndOfScope 'on_scope_end';
+# FIXME This is a crock of shit, needs to go away
+# currently here to work around https://rt.cpan.org/Ticket/Display.html?id=74151
+# kill with fire when PS::XS is *finally* fixed
BEGIN {
+ my $provider;
- use warnings;
- use strict;
+ if ( $] < 5.008007 ) {
+ require Package::Stash::PP;
+ $provider = 'Package::Stash::PP';
+ }
+ else {
+ require Package::Stash;
+ $provider = 'Package::Stash';
+ }
+ eval <<"EOS" or die $@;
+
+sub stash_for (\$) {
+ $provider->new(\$_[0]);
+}
+
+1;
+
+EOS
+}
+
+# Constant to optimise away the unused code branches
+use constant FIXUP_NEEDED => $] < 5.015_005_1;
+use constant FIXUP_RENAME_SUB => $] > 5.008_008_9 && $] < 5.013_005_1;
+{
+ no strict;
+ delete ${__PACKAGE__."::"}{FIXUP_NEEDED};
+ delete ${__PACKAGE__."::"}{FIXUP_RENAME_SUB};
+}
+
+# Debugger fixup necessary before perl 5.15.5
+#
+# In perl 5.8.9-5.12, it assumes that sub_fullname($sub) can
+# always be used to find the CV again.
+# In perl 5.8.8 and 5.14, it assumes that the name of the glob
+# passed to entersub can be used to find the CV.
+# since we are deleting the glob where the subroutine was originally
+# defined, those assumptions no longer hold.
+#
+# So in 5.8.9-5.12 we need to move it elsewhere and point the
+# CV's name to the new glob.
+#
+# In 5.8.8 and 5.14 we move it elsewhere and rename the
+# original glob by assigning the new glob back to it.
+my $sub_utils_loaded;
+my $DebuggerFixup = sub {
+ my ($f, $sub, $cleanee_stash, $deleted_stash) = @_;
+
+ if (FIXUP_RENAME_SUB) {
+ if (! defined $sub_utils_loaded ) {
+ $sub_utils_loaded = do {
+
+ # when changing version also change in Makefile.PL
+ my $sn_ver = 0.04;
+ eval { require Sub::Name; Sub::Name->VERSION($sn_ver) }
+ or die "Sub::Name $sn_ver required when running under -d or equivalent: $@";
- # when changing also change in Makefile.PL
- my $b_h_eos_req = '0.07';
+ # when changing version also change in Makefile.PL
+ my $si_ver = 0.04;
+ eval { require Sub::Identify; Sub::Identify->VERSION($si_ver) }
+ or die "Sub::Identify $si_ver required when running under -d or equivalent: $@";
- if (eval {
- require B::Hooks::EndOfScope;
- B::Hooks::EndOfScope->VERSION($b_h_eos_req);
- 1
- } ) {
- B::Hooks::EndOfScope->import('on_scope_end');
+ 1;
+ } ? 1 : 0;
+ }
+
+ if ( Sub::Identify::sub_fullname($sub) eq ($cleanee_stash->name . "::$f") ) {
+ my $new_fq = $deleted_stash->name . "::$f";
+ Sub::Name::subname($new_fq, $sub);
+ $deleted_stash->add_symbol("&$f", $sub);
+ }
}
else {
- eval <<'PP' or die $@;
+ $deleted_stash->add_symbol("&$f", $sub);
+ }
+};
- use Tie::Hash ();
+my $RemoveSubs = sub {
+ my $cleanee = shift;
+ my $store = shift;
+ my $cleanee_stash = stash_for($cleanee);
+ my $deleted_stash;
- {
- package namespace::clean::_TieHintHash;
+ SYMBOL:
+ for my $f (@_) {
- use warnings;
- use strict;
+ # ignore already removed symbols
+ next SYMBOL if $store->{exclude}{ $f };
- use base 'Tie::ExtraHash';
- }
+ my $sub = $cleanee_stash->get_symbol("&$f")
+ or next SYMBOL;
- {
- package namespace::clean::_ScopeGuard;
+ my $need_debugger_fixup =
+ FIXUP_NEEDED
+ &&
+ $^P
+ &&
+ ref(my $globref = \$cleanee_stash->namespace->{$f}) eq 'GLOB'
+ ;
+
+ if (FIXUP_NEEDED && $need_debugger_fixup) {
+ # convince the Perl debugger to work
+ # see the comment on top of $DebuggerFixup
+ $DebuggerFixup->(
+ $f,
+ $sub,
+ $cleanee_stash,
+ $deleted_stash ||= stash_for("namespace::clean::deleted::$cleanee"),
+ );
+ }
- use warnings;
- use strict;
+ my @symbols = map {
+ my $name = $_ . $f;
+ my $def = $cleanee_stash->get_symbol($name);
+ defined($def) ? [$name, $def] : ()
+ } '$', '@', '%', '';
- sub arm { bless [ $_[1] ] }
+ $cleanee_stash->remove_glob($f);
- sub DESTROY { $_[0]->[0]->() }
- }
+ # if this perl needs no renaming trick we need to
+ # rename the original glob after the fact
+ # (see commend of $DebuggerFixup
+ if (FIXUP_NEEDED && !FIXUP_RENAME_SUB && $need_debugger_fixup) {
+ *$globref = $deleted_stash->namespace->{$f};
+ }
+ $cleanee_stash->add_symbol(@$_) for @symbols;
+ }
+};
- sub on_scope_end (&) {
- $^H |= 0x020000;
+sub clean_subroutines {
+ my ($nc, $cleanee, @subs) = @_;
+ $RemoveSubs->($cleanee, {}, @subs);
+}
- if( my $stack = tied( %^H ) ) {
- if ( (my $c = ref $stack) ne 'namespace::clean::_TieHintHash') {
- die <<EOE;
-========================================================================
- !!! F A T A L E R R O R !!!
+sub import {
+ my ($pragma, @args) = @_;
- foreign tie() of %^H detected
-========================================================================
+ my (%args, $is_explicit);
-namespace::clean is currently operating in pure-perl fallback mode, because
-your system is lacking the necessary dependency B::Hooks::EndOfScope $b_h_eos_req.
-In this mode namespace::clean expects to be able to tie() the hinthash %^H,
-however it is apparently already tied by means unknown to the tie-class
-$c
+ ARG:
+ while (@args) {
-Since this is a no-win situation execution will abort here and now. Please
-try to find out which other module is relying on hinthash tie() ability,
-and file a bug for both the perpetrator and namespace::clean, so that the
-authors can figure out an acceptable way of moving forward.
+ if ($args[0] =~ /^\-/) {
+ my $key = shift @args;
+ my $value = shift @args;
+ $args{ $key } = $value;
+ }
+ else {
+ $is_explicit++;
+ last ARG;
+ }
+ }
-EOE
- }
- push @$stack, namespace::clean::_ScopeGuard->arm(shift);
+ my $cleanee = exists $args{ -cleanee } ? $args{ -cleanee } : scalar caller;
+ if ($is_explicit) {
+ on_scope_end {
+ $RemoveSubs->($cleanee, {}, @args);
+ };
}
else {
- tie( %^H, 'namespace::clean::_TieHintHash', namespace::clean::_ScopeGuard->arm(shift) );
+
+ # calling class, all current functions and our storage
+ my $functions = $pragma->get_functions($cleanee);
+ my $store = $pragma->get_class_store($cleanee);
+ my $stash = stash_for($cleanee);
+
+ # except parameter can be array ref or single value
+ my %except = map {( $_ => 1 )} (
+ $args{ -except }
+ ? ( ref $args{ -except } eq 'ARRAY' ? @{ $args{ -except } } : $args{ -except } )
+ : ()
+ );
+
+ # register symbols for removal, if they have a CODE entry
+ for my $f (keys %$functions) {
+ next if $except{ $f };
+ next unless $stash->has_symbol("&$f");
+ $store->{remove}{ $f } = 1;
+ }
+
+ # register EOF handler on first call to import
+ unless ($store->{handler_is_installed}) {
+ on_scope_end {
+ $RemoveSubs->($cleanee, $store, keys %{ $store->{remove} });
+ };
+ $store->{handler_is_installed} = 1;
+ }
+
+ return 1;
}
- }
+}
- 1;
+sub unimport {
+ my ($pragma, %args) = @_;
-PP
+ # the calling class, the current functions and our storage
+ my $cleanee = exists $args{ -cleanee } ? $args{ -cleanee } : scalar caller;
+ my $functions = $pragma->get_functions($cleanee);
+ my $store = $pragma->get_class_store($cleanee);
- }
+ # register all unknown previous functions as excluded
+ for my $f (keys %$functions) {
+ next if $store->{remove}{ $f }
+ or $store->{exclude}{ $f };
+ $store->{exclude}{ $f } = 1;
+ }
+
+ return 1;
}
+sub get_class_store {
+ my ($pragma, $class) = @_;
+ my $stash = stash_for($class);
+ my $var = "%$STORAGE_VAR";
+ $stash->add_symbol($var, {})
+ unless $stash->has_symbol($var);
+ return $stash->get_symbol($var);
+}
+
+sub get_functions {
+ my ($pragma, $class) = @_;
+
+ my $stash = stash_for($class);
+ return {
+ map { $_ => $stash->get_symbol("&$_") }
+ $stash->list_all_symbols('CODE')
+ };
+}
+
+'Danger! Laws of Thermodynamics may not apply.'
+
+__END__
+
=head1 NAME
namespace::clean - Keep imports and functions out of your namespace
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 $sub_utils_loaded;
-my $DebuggerRename = sub {
- my ($f, $sub, $cleanee_stash, $deleted_stash) = @_;
-
- if (! defined $sub_utils_loaded ) {
- $sub_utils_loaded = do {
- my $sn_ver = 0.04;
- eval { require Sub::Name; Sub::Name->VERSION($sn_ver) }
- or die "Sub::Name $sn_ver required when running under -d or equivalent: $@";
-
- my $si_ver = 0.04;
- eval { require Sub::Identify; Sub::Identify->VERSION($si_ver) }
- or die "Sub::Identify $si_ver required when running under -d or equivalent: $@";
-
- 1;
- } ? 1 : 0;
- }
-
- if ( Sub::Identify::sub_fullname($sub) eq ($cleanee_stash->name . "::$f") ) {
- my $new_fq = $deleted_stash->name . "::$f";
- Sub::Name::subname($new_fq, $sub);
- $deleted_stash->add_symbol("&$f", $sub);
- }
-};
-
-my $RemoveSubs = sub {
- my $cleanee = shift;
- my $store = shift;
- my $cleanee_stash = Package::Stash->new($cleanee);
- my $deleted_stash;
-
- SYMBOL:
- for my $f (@_) {
-
- # ignore already removed symbols
- next SYMBOL if $store->{exclude}{ $f };
-
- my $sub = $cleanee_stash->get_symbol("&$f")
- or next SYMBOL;
-
- if ($^P and 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.
- $DebuggerRename->(
- $f,
- $sub,
- $cleanee_stash,
- $deleted_stash ||= Package::Stash->new("namespace::clean::deleted::$cleanee"),
- );
- }
-
- my @symbols = map {
- my $name = $_ . $f;
- my $def = $cleanee_stash->get_symbol($name);
- defined($def) ? [$name, $def] : ()
- } '$', '@', '%', '';
-
- $cleanee_stash->remove_glob($f);
-
- $cleanee_stash->add_symbol(@$_) for @symbols;
- }
-};
-
-sub clean_subroutines {
- my ($nc, $cleanee, @subs) = @_;
- $RemoveSubs->($cleanee, {}, @subs);
-}
-
=head2 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);
-
- ARG:
- while (@args) {
-
- if ($args[0] =~ /^\-/) {
- my $key = shift @args;
- my $value = shift @args;
- $args{ $key } = $value;
- }
- else {
- $is_explicit++;
- last ARG;
- }
- }
-
- my $cleanee = exists $args{ -cleanee } ? $args{ -cleanee } : scalar caller;
- if ($is_explicit) {
- on_scope_end {
- $RemoveSubs->($cleanee, {}, @args);
- };
- }
- else {
-
- # 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 )} (
- $args{ -except }
- ? ( ref $args{ -except } eq 'ARRAY' ? @{ $args{ -except } } : $args{ -except } )
- : ()
- );
-
- # register symbols for removal, if they have a CODE entry
- for my $f (keys %$functions) {
- next if $except{ $f };
- next unless $stash->has_symbol("&$f");
- $store->{remove}{ $f } = 1;
- }
-
- # register EOF handler on first call to import
- unless ($store->{handler_is_installed}) {
- on_scope_end {
- $RemoveSubs->($cleanee, $store, keys %{ $store->{remove} });
- };
- $store->{handler_is_installed} = 1;
- }
-
- return 1;
- }
-}
=head2 unimport
It will start a new section of code that defines functions to clean up.
-=cut
-
-sub unimport {
- my ($pragma, %args) = @_;
-
- # the calling class, the current functions and our storage
- my $cleanee = exists $args{ -cleanee } ? $args{ -cleanee } : scalar caller;
- my $functions = $pragma->get_functions($cleanee);
- my $store = $pragma->get_class_store($cleanee);
-
- # register all unknown previous functions as excluded
- for my $f (keys %$functions) {
- next if $store->{remove}{ $f }
- or $store->{exclude}{ $f };
- $store->{exclude}{ $f } = 1;
- }
-
- return 1;
-}
-
=head2 get_class_store
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) = @_;
- my $stash = Package::Stash->new($class);
- my $var = "%$STORAGE_VAR";
- $stash->add_symbol($var, {})
- unless $stash->has_symbol($var);
- return $stash->get_symbol($var);
-}
-
=head2 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
reference to the symbol as value.
-=cut
-
-sub get_functions {
- my ($pragma, $class) = @_;
-
- my $stash = Package::Stash->new($class);
- return {
- map { $_ => $stash->get_symbol("&$_") }
- $stash->list_all_symbols('CODE')
- };
-}
-
=head1 IMPLEMENTATION DETAILS
This module works through the effect that a
Just for completeness sake, if you want to remove the symbol completely,
use C<undef> instead.
-=head1 CAVEATS
-
-This module is fully functional in a pure-perl environment, where
-L<B::Hooks::EndOfScope> (with the XS dependency L<Variable::Magic>), may
-not be available. However in this case this module falls back to a
-L<tie()|perlfunc/tie> of L<%^H|perlvar/%^H> which may or may not interfere
-with some crack you may be doing independently of namespace::clean.
-
-If you want to ensure that your codebase is protected from this unlikely
-clash, you need to explicitly depend on L<B::Hooks::EndOfScope>.
-
=head1 SEE ALSO
L<B::Hooks::EndOfScope>
Peter Rabbitson <ribasushi@cpan.org>
+=item *
+
+Father Chrysostomos <sprout@cpan.org>
+
=back
=head1 COPYRIGHT AND LICENSE
-This software is copyright (c) 2011 by Robert 'phaylon' Sedlacek.
+This software is copyright (c) 2011 by L</AUTHORS>
This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.
-
-=cut
-
-no warnings;
-'Danger! Laws of Thermodynamics may not apply.'
projects / p5sagit/namespace-clean.git / blobdiff