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.21';
+our $VERSION = '0.25';
+our $STORAGE_VAR = '__NAMESPACE_CLEAN_STORAGE';
-$STORAGE_VAR = '__NAMESPACE_CLEAN_STORAGE';
+use B::Hooks::EndOfScope 'on_scope_end';
-BEGIN {
-
- use warnings;
- use strict;
-
- # when changing also change in Makefile.PL
- my $b_h_eos_req = '0.07';
-
- if (eval {
- require B::Hooks::EndOfScope;
- B::Hooks::EndOfScope->VERSION($b_h_eos_req);
- 1
- } ) {
- B::Hooks::EndOfScope->import('on_scope_end');
- }
- else {
- eval <<'PP' or die $@;
-
- use Tie::Hash ();
-
- {
- package namespace::clean::_TieHintHash;
-
- use warnings;
- use strict;
-
- use base 'Tie::ExtraHash';
- }
-
- {
- package namespace::clean::_ScopeGuard;
-
- use warnings;
- use strict;
-
- sub arm { bless [ $_[1] ] }
-
- sub DESTROY { $_[0]->[0]->() }
- }
-
-
- sub on_scope_end (&) {
- $^H |= 0x020000;
-
- 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 !!!
-
- foreign tie() of %^H detected
-========================================================================
-
-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
-
-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.
-
-EOE
- }
- push @$stack, namespace::clean::_ScopeGuard->arm(shift);
- }
- else {
- tie( %^H, 'namespace::clean::_TieHintHash', namespace::clean::_ScopeGuard->arm(shift) );
- }
- }
-
- 1;
-
-PP
-
- }
-}
-
-=head1 NAME
-
-namespace::clean - Keep imports and functions out of your namespace
-
-=head1 SYNOPSIS
-
- package Foo;
- use warnings;
- use strict;
-
- use Carp qw(croak); # 'croak' will be removed
-
- sub bar { 23 } # 'bar' will be removed
-
- # remove all previously defined functions
- use namespace::clean;
-
- sub baz { bar() } # 'baz' still defined, 'bar' still bound
-
- # begin to collection function names from here again
- no namespace::clean;
-
- sub quux { baz() } # 'quux' will be removed
-
- # remove all functions defined after the 'no' unimport
- use namespace::clean;
-
- # Will print: 'No', 'No', 'Yes' and 'No'
- print +(__PACKAGE__->can('croak') ? 'Yes' : 'No'), "\n";
- print +(__PACKAGE__->can('bar') ? 'Yes' : 'No'), "\n";
- print +(__PACKAGE__->can('baz') ? 'Yes' : 'No'), "\n";
- print +(__PACKAGE__->can('quux') ? 'Yes' : 'No'), "\n";
-
- 1;
-
-=head1 DESCRIPTION
-
-=head2 Keeping packages clean
-
-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
-base classes.
-
-The C<namespace::clean> pragma will remove all previously declared or
-imported symbols at the end of the current package's compile cycle.
-Functions called in the package itself will still be bound by their
-name, but they won't show up as methods on your class or instances.
-
-By unimporting via C<no> you can tell C<namespace::clean> to start
-collecting functions for the next C<use namespace::clean;> specification.
-
-You can use the C<-except> flag to tell C<namespace::clean> that you
-don't want it to remove a certain function or method. A common use would
-be a module exporting an C<import> method along with some functions:
-
- use ModuleExportingImport;
- use namespace::clean -except => [qw( import )];
-
-If you just want to C<-except> a single sub, you can pass it directly.
-For more than one value you have to use an array reference.
-
-=head2 Explicitly removing functions when your scope is compiled
-
-It is also possible to explicitly tell C<namespace::clean> what packages
-to remove when the surrounding scope has finished compiling. Here is an
-example:
-
- package Foo;
- use strict;
-
- # blessed NOT available
-
- sub my_class {
- use Scalar::Util qw( blessed );
- use namespace::clean qw( blessed );
-
- # blessed available
- return blessed shift;
- }
-
- # blessed NOT available
-
-=head2 Moose
-
-When using C<namespace::clean> together with L<Moose> you want to keep
-the installed C<meta> method. So your classes should look like:
-
- package Foo;
- use Moose;
- use namespace::clean -except => 'meta';
- ...
-
-Same goes for L<Moose::Role>.
-
-=head2 Cleaning other packages
-
-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:
-
- package My::MooseX::namespace::clean;
- use strict;
-
- use namespace::clean (); # no cleanup, just load
-
- 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>.
-
-=head1 METHODS
-
-=head2 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
# Constant to optimise away the unused code branches
-use constant RENAME_SUB => $] > 5.008_008_9 && $] < 5.013_006_1;
-{ no strict; delete ${__PACKAGE__."::"}{RENAME_SUB} }
+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
my $DebuggerFixup = sub {
my ($f, $sub, $cleanee_stash, $deleted_stash) = @_;
- if (RENAME_SUB) {
+ if (FIXUP_RENAME_SUB) {
if (! defined $sub_utils_loaded ) {
$sub_utils_loaded = do {
or next SYMBOL;
my $need_debugger_fixup =
+ FIXUP_NEEDED
+ &&
$^P
&&
ref(my $globref = \$cleanee_stash->namespace->{$f}) eq 'GLOB'
;
- if ($need_debugger_fixup) {
+ if (FIXUP_NEEDED && $need_debugger_fixup) {
# convince the Perl debugger to work
# see the comment on top of $DebuggerFixup
$DebuggerFixup->(
# if this perl needs no renaming trick we need to
# rename the original glob after the fact
# (see commend of $DebuggerFixup
- if (!RENAME_SUB && $need_debugger_fixup) {
+ if (FIXUP_NEEDED && !FIXUP_RENAME_SUB && $need_debugger_fixup) {
*$globref = $deleted_stash->namespace->{$f};
}
$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) = @_;
}
}
-=head2 unimport
-
-This method will be called when you do a
-
- no namespace::clean;
-
-It will start a new section of code that defines functions to clean up.
-
-=cut
-
sub unimport {
my ($pragma, %args) = @_;
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);
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) = @_;
};
}
+'Danger! Laws of Thermodynamics may not apply.'
+
+__END__
+
+=head1 NAME
+
+namespace::clean - Keep imports and functions out of your namespace
+
+=head1 SYNOPSIS
+
+ package Foo;
+ use warnings;
+ use strict;
+
+ use Carp qw(croak); # 'croak' will be removed
+
+ sub bar { 23 } # 'bar' will be removed
+
+ # remove all previously defined functions
+ use namespace::clean;
+
+ sub baz { bar() } # 'baz' still defined, 'bar' still bound
+
+ # begin to collection function names from here again
+ no namespace::clean;
+
+ sub quux { baz() } # 'quux' will be removed
+
+ # remove all functions defined after the 'no' unimport
+ use namespace::clean;
+
+ # Will print: 'No', 'No', 'Yes' and 'No'
+ print +(__PACKAGE__->can('croak') ? 'Yes' : 'No'), "\n";
+ print +(__PACKAGE__->can('bar') ? 'Yes' : 'No'), "\n";
+ print +(__PACKAGE__->can('baz') ? 'Yes' : 'No'), "\n";
+ print +(__PACKAGE__->can('quux') ? 'Yes' : 'No'), "\n";
+
+ 1;
+
+=head1 DESCRIPTION
+
+=head2 Keeping packages clean
+
+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
+base classes.
+
+The C<namespace::clean> pragma will remove all previously declared or
+imported symbols at the end of the current package's compile cycle.
+Functions called in the package itself will still be bound by their
+name, but they won't show up as methods on your class or instances.
+
+By unimporting via C<no> you can tell C<namespace::clean> to start
+collecting functions for the next C<use namespace::clean;> specification.
+
+You can use the C<-except> flag to tell C<namespace::clean> that you
+don't want it to remove a certain function or method. A common use would
+be a module exporting an C<import> method along with some functions:
+
+ use ModuleExportingImport;
+ use namespace::clean -except => [qw( import )];
+
+If you just want to C<-except> a single sub, you can pass it directly.
+For more than one value you have to use an array reference.
+
+=head2 Explicitly removing functions when your scope is compiled
+
+It is also possible to explicitly tell C<namespace::clean> what packages
+to remove when the surrounding scope has finished compiling. Here is an
+example:
+
+ package Foo;
+ use strict;
+
+ # blessed NOT available
+
+ sub my_class {
+ use Scalar::Util qw( blessed );
+ use namespace::clean qw( blessed );
+
+ # blessed available
+ return blessed shift;
+ }
+
+ # blessed NOT available
+
+=head2 Moose
+
+When using C<namespace::clean> together with L<Moose> you want to keep
+the installed C<meta> method. So your classes should look like:
+
+ package Foo;
+ use Moose;
+ use namespace::clean -except => 'meta';
+ ...
+
+Same goes for L<Moose::Role>.
+
+=head2 Cleaning other packages
+
+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:
+
+ package My::MooseX::namespace::clean;
+ use strict;
+
+ use namespace::clean (); # no cleanup, just load
+
+ 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>.
+
+=head1 METHODS
+
+=head2 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.
+
+=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.
+
+
+=head2 unimport
+
+This method will be called when you do a
+
+ no namespace::clean;
+
+It will start a new section of code that defines functions to clean up.
+
+=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.
+
+=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.
+
=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