Simplify double negations

[perl/modules/subs-auto.git] / lib / subs / auto.pm

diff --git a/lib/subs/auto.pm b/lib/subs/auto.pm
index c5ef078af547f10148289d00fcda0c455677a20c..d93706aa5f632e6e9137f90f5220924ce39426f7 100644 (file)
--- a/lib/subs/auto.pm
+++ b/lib/subs/auto.pm
@@ -16,11 +16,11 @@ subs::auto - Read barewords as subroutine names.
 
 =head1 VERSION
 
-Version 0.01
+Version 0.02
 
 =cut
 
-our $VERSION = '0.01';
+our $VERSION = '0.02';
 
 =head1 SYNOPSIS
 
@@ -53,7 +53,7 @@ You can pass options to C<import> as key / value pairs :
 
 C<< in => $pkg >>
 
-Specifies on which package the pragma should act. Defaults to the current package.
+Specifies on which package the pragma should act. Setting C<$pkg> to C<Some::Package> allows you to resolve all functions name of the type C<Some::Package::func ...> in the current scope. You can use the pragma several times with different package names to allow resolution of all the corresponding barewords. Defaults to the current package.
 
 =back
 
@@ -88,7 +88,7 @@ my @core = qw/abs accept alarm atan2 bind binmode bless break caller chdir
               time times truncate uc ucfirst umask undef unlink unpack unshift
               untie use utime values vec wait waitpid wantarray warn when
               write/;
-push @core,qw/not __LINE__ __FILE__/;
+push @core,qw/not __LINE__ __FILE__ DATA/;
 
 my %core;
 @core{@core} = ();
@@ -119,15 +119,14 @@ sub _reset {
 
 sub _fetch {
  (undef, my $data, my $func) = @_;
- return if $data->{guard};
- return unless $func !~ /::/ and not exists $core{$func};
- local $data->{guard} = 1;
+ return if $data->{guard} or $func =~ /::/ or exists $core{$func};
+ $data->{guard} = 1;
  my $hints = (caller 0)[10];
- if ($hints and $hints->{bareword}) {
+ if ($hints and $hints->{subs__auto}) {
   my $mod = $func . '.pm';
   if (not exists $INC{$mod}) {
    my $fqn = $data->{pkg} . '::' . $func;
-   if (do { no strict 'refs'; not *$fqn{CODE} and not *$fqn{IO}}) {
+   if (do { no strict 'refs'; not *$fqn{CODE} || *$fqn{IO}}) {
     my $cb = sub {
      my ($file, $line) = (caller 0)[1, 2];
      ($file, $line) = ('(eval 0)', 0) unless $file && $line;
@@ -141,14 +140,16 @@ sub _fetch {
  } else {
   _reset($data->{pkg}, $func);
  }
+ $data->{guard} = 0;
  return;
 }
 
 sub _store {
  (undef, my $data, my $func) = @_;
  return if $data->{guard};
- local $data->{guard} = 1;
+ $data->{guard} = 1;
  _reset($data->{pkg}, $func);
+ $data->{guard} = 0;
  return;
 }
 
@@ -175,14 +176,14 @@ sub import {
  my %args = @_;
  my $cur  = (caller 1)[0];
  my $in   = _validate_pkg $args{in}, $cur;
- $^H{bareword} = 1;
+ $^H{subs__auto} = 1;
  ++$pkgs{$in};
  no strict 'refs';
  cast %{$in . '::'}, $wiz, $in;
 }
 
 sub unimport {
- $^H{bareword} = 0;
+ $^H{subs__auto} = 0;
 }
 
 {
@@ -201,6 +202,8 @@ None.
 
 C<*{'::foo'}{CODE}> will appear as defined in a scope where the pragma is enabled, C<foo> is used as a bareword, but is never actually defined afterwards. This may or may not be considered as Doing The Right Thing. However, C<*{'::foo'}{CODE}> will always return the right value if you fetch it outside the pragma's scope. Actually, you can make it return the right value even in the pragma's scope by reading C<*{'::foo'}{CODE}> outside (or by actually defining C<foo>, which is ultimately why you use this pragma, right ?).
 
+You have to open global filehandles outside of the scope of this pragma if you want them not to be treated as function calls. Or just use lexical filehandles and default ones as you should be.
+
 =head1 DEPENDENCIES
 
 L<perl> 5.10.0.