X-Git-Url: http://git.vpit.fr/?p=perl%2Fmodules%2Findirect.git;a=blobdiff_plain;f=lib%2Findirect.pm;h=ff3d34e02b2e8ad8f608f9b22d715a3dcfcad414;hp=34920db30092002a79bbf1a6b8282c91b0f8612d;hb=c88f53009246bbc1af1789f746acc5d841fc0ae8;hpb=2635de8af7a889878b35ebed184d2f7b3c9c4ac0 diff --git a/lib/indirect.pm b/lib/indirect.pm index 34920db..ff3d34e 100644 --- a/lib/indirect.pm +++ b/lib/indirect.pm @@ -1,6 +1,6 @@ package indirect; -use 5.008; +use 5.008001; use strict; use warnings; @@ -11,13 +11,13 @@ indirect - Lexically warn about using the indirect object syntax. =head1 VERSION -Version 0.18 +Version 0.25 =cut our $VERSION; BEGIN { - $VERSION = '0.18'; + $VERSION = '0.25'; } =head1 SYNOPSIS @@ -29,26 +29,31 @@ BEGIN { use indirect; my $y = new Pear; # ok { - no indirect hook => sub { die "You really wanted $_[0]\->$_[1] at $_[2]:$_[3]" }; - my $z = new Pineapple 'fresh'; # croaks 'You really wanted Pineapple->new at blurp.pm:13' + no indirect hook => sub { + die "You really wanted $_[0]\->$_[1] at $_[2]:$_[3]" + }; + # croaks 'You really wanted Pineapple->new at blurp.pm:13' + my $z = new Pineapple 'fresh'; } } try { ... }; # warns - no indirect ':fatal'; + no indirect ':fatal'; # or 'FATAL', or ':Fatal' ... if (defied $foo) { ... } # croaks, note the typo - # From the command-line - perl -M-indirect -e 'my $x = new Banana;' # warns + # Globally enabled from the command-line + perl -M-indirect=global -e 'my $x = new Banana;' # warns - # Or each time perl is ran - export PERL5OPT="-M-indirect" + # Or globally enabled each time perl is executed + export PERL5OPT="-M-indirect=global" perl -e 'my $y = new Coconut;' # warns =head1 DESCRIPTION When enabled (or disabled as some may prefer to say, since you actually turn it on by calling C), this pragma warns about indirect object syntax constructs that may have slipped into your code. -This syntax is now considered harmful, since its parsing has many quirks and its use is error prone (when C isn't defined, C actually compiles to C<< $x->swoosh >>). + +This syntax is now considered harmful, since its parsing has many quirks and its use is error prone (when C is not defined, C actually compiles to C<< $x->swoosh >>). +In L, Matt S. Trout gives an example of an indirect construct that can cause a particularly bewildering error. It currently does not warn for core functions (C, C, C or C). This may change in the future, or may be added as optional features that would be enabled by passing options to C. @@ -70,7 +75,7 @@ BEGIN { =head1 METHODS -=head2 C<< unimport [ hook => $hook | ':fatal' ] >> +=head2 C<< unimport [ 'global', hook => $hook | 'fatal' ] >> Magically called when C is encountered. Turns the module on. @@ -80,7 +85,7 @@ The policy to apply depends on what is first found in C<@opts> : =item * -If it's the string C<':fatal'>, the compilation will croak on the first indirect syntax met. +If it is a string that matches C, the compilation will croak on the first indirect syntax met. =item * @@ -89,7 +94,28 @@ If and only if the object is actually a block, C<$_[0]> is assured to start by C =item * -Otherwise, a warning will be emitted for each indirect construct. +If none of C and C are specified, a warning will be emitted for each indirect construct. + +=item * + +If C<@opts> contains a string that matches C, the pragma will be globally enabled for B code compiled after the current C statement, except for code that is in the lexical scope of C. +This option may come indifferently before or after the C or C options, in the case they are also passed to L. + +The global policy applied is the one resulting of the C or C options, thus defaults to a warning when none of those are specified : + + no indirect 'global'; # warn for any indirect call + no indirect qw; # die on any indirect call + no indirect 'global', hook => \&hook # custom global action + +Note that if another policy is installed by a C statement further in the code, it will overrule the global policy : + + no indirect 'global'; # warn globally + { + no indirect 'fatal'; # throw exceptions for this lexical scope + ... + require Some::Module; # the global policy will apply for the + # compilation phase of this module + } =back @@ -99,32 +125,45 @@ sub unimport { shift; my $hook; + my $global; while (@_) { my $arg = shift; if ($arg eq 'hook') { + last if $hook; $hook = shift; - } elsif ($arg eq ':fatal') { + } elsif ($arg =~ /^:?fatal$/i) { + last if $hook; $hook = sub { die msg(@_) }; + } elsif ($arg =~ /^:?global$/i) { + $global = 1; } - last if $hook; } $hook = sub { warn msg(@_) } unless defined $hook; $^H |= 0x00020000; - $^H{+(__PACKAGE__)} = _tag($hook); + if ($global) { + delete $^H{+(__PACKAGE__)}; + _global($hook); + } else { + $^H{+(__PACKAGE__)} = _tag($hook); + } - (); + return; } =head2 C Magically called at each C. Turns the module off. +As explained in L's description, an C statement will lexically override a global policy previously installed by C (if there's one). + =cut sub import { - $^H{+(__PACKAGE__)} = undef; - (); + $^H |= 0x00020000; + $^H{+(__PACKAGE__)} = _tag(undef); + + return; } =head1 FUNCTIONS @@ -173,13 +212,14 @@ In this case, the pragma will always be considered to be thread-safe, and as suc This is useful for disabling C in production environments. Note that clearing this variable after C was loaded has no effect. -If you want to reenable the pragma later, you also need to reload it by deleting the C<'indirect.pm'> entry from C<%INC>. +If you want to re-enable the pragma later, you also need to reload it by deleting the C<'indirect.pm'> entry from C<%INC>. =head1 CAVEATS -The implementation was tweaked to work around several limitations of vanilla C pragmas : it's thread safe, and doesn't suffer from a C bug that causes all pragmas to propagate into Cd scopes. +The implementation was tweaked to work around several limitations of vanilla C pragmas : it's thread safe, and does not suffer from a C bug that causes all pragmas to propagate into Cd scopes. -C (no semicolon) at the end of a file won't be seen as an indirect object syntax, although it will as soon as there is another token before the end (as in C or C). +Before C 5.12, C (no semicolon) at the end of a file is not seen as an indirect object syntax, although it is as soon as there is another token before the end (as in C or C). +If you use C 5.12 or greater, those constructs are correctly reported. With 5.8 perls, the pragma does not propagate into C. This is due to a shortcoming in the way perl handles the hints hash, which is addressed in perl 5.10. @@ -189,7 +229,10 @@ Hence C will be caught. =head1 DEPENDENCIES -L 5.8. +L 5.8.1. + +A C compiler. +This module may happen to build with a C++ compiler as well, but don't rely on it, as no guarantee is made in this regard. L (standard since perl 5.006). @@ -220,7 +263,7 @@ Andrew Main and Florian Ragwitz, for testing on real-life code and reporting iss =head1 COPYRIGHT & LICENSE -Copyright 2008-2009 Vincent Pit, all rights reserved. +Copyright 2008,2009,2010,2011 Vincent Pit, all rights reserved. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.