X-Git-Url: http://git.vpit.fr/?a=blobdiff_plain;f=lib%2FScope%2FUpper.pm;h=4fb21d543a3f1adcfb791adf73fe7c79c144f9c5;hb=e4bb8d889bcaaf2a3c9f1f9cd2a8185115db5db0;hp=f4e276daa3d00a4890aa37681cf30052b3cdefc8;hpb=5d565c2feed583ba26f5451a0b25f1a5df2be4ed;p=perl%2Fmodules%2FScope-Upper.git

diff --git a/lib/Scope/Upper.pm b/lib/Scope/Upper.pm
index f4e276d..4fb21d5 100644
--- a/lib/Scope/Upper.pm
+++ b/lib/Scope/Upper.pm
@@ -9,20 +9,20 @@ Scope::Upper - Act on upper scopes.
 
 =head1 VERSION
 
-Version 0.02
+Version 0.05
 
 =cut
 
 our $VERSION;
 BEGIN {
- $VERSION = '0.02';
+ $VERSION = '0.05';
 }
 
 =head1 SYNOPSIS
 
     package X;
 
-    use Scope::Upper qw/reap localize localize_elem/;
+    use Scope::Upper qw/reap localize localize_elem localize_delete/;
 
     sub desc { shift->{desc} }
 
@@ -43,21 +43,44 @@ BEGIN {
       my $x = do { no strict 'refs'; ${$pkg.'::x'} }; # Get the $x in the scope
       CORE::warn($x->desc . ': ' . join('', @_));
      } => 1;
+
+     localize_delete '@ARGV', $#ARGV => 1; # delete last @ARGV element
     }
 
     package Y;
 
     {
      X::set_tag('pie');
-     # $x is now a X object
+     # $x is now a X object, and @ARGV has one element less
      warn 'what'; # warns "pie: what at ..."
      ...
     } # "pie: done" is printed
 
+    package Z;
+
+    use Scope::Upper qw/unwind want_at :words/;
+
+    sub try (&) {
+     my @result = shift->();
+     my $cx = SUB UP SUB;
+     unwind +(want_at($cx) ? @result : scalar @result) => $cx;
+    }
+
+    ...
+
+    sub zap {
+     try {
+      return @things; # returns to try() and then outside zap()
+     }
+    }
+
+    my @what = zap(); # @what contains @things
+
 =head1 DESCRIPTION
 
 This module lets you defer actions that will take place when the control flow returns into an upper scope.
-Currently, you can hook an upper scope end, or localize variables and array/hash values in higher contexts.
+Currently, you can hook an upper scope end, or localize variables, array/hash values or deletions of elements in higher contexts.
+You can also return to an upper level and know which context was in use then.
 
 =head1 FUNCTIONS
 
@@ -111,13 +134,100 @@ Similar to L</localize> but for array and hash elements.
 If C<$what> is a glob, the slot to fill is determined from which type of reference C<$value> is ; otherwise it's inferred from the sigil.
 C<$key> is either an array index or a hash key, depending of which kind of variable you localize.
 
-=head2 C<TOPLEVEL>
+=head2 C<localize_delete $what, $key, $level>
+
+Similiar to L</localize>, but for deleting variables or array/hash elements.
+C<$what> can be:
+
+=over 4
+
+=item *
+
+A glob, in which case C<$key> is ignored and the call is equivalent to C<local *x>.
+
+=item *
+
+A string beginning with C<'@'> or C<'%'>, for which the call is equivalent to respectiveley C<local $a[$key]; delete $a[$key]> and C<local $h{$key}; delete $h{$key}>.
+
+=item *
+
+A string beginning with C<'&'>, which more or less does C<undef &func> in the upper scope.
+It's actually more powerful, as C<&func> won't even C<exists> anymore.
+C<$key> is ignored.
+
+=back
+
+=head2 C<unwind @values, $level>
+
+Returns C<@values> I<from> the context indicated by C<$level>, i.e. from the subroutine, eval or format just above C<$level>.
+
+The upper level isn't coerced onto C<@values>, which is hence always evaluated in list context.
+This means that
+
+    my $num = sub {
+     my @a = ('a' .. 'z');
+     unwind @a => 0;
+    }->();
+
+will set C<$num> to C<'z'>.
+You can use L</want_at> to handle these cases.
+
+=head2 C<want_at $level>
+
+Like C<wantarray>, but for the subroutine/eval/format context just above C<$level>.
+
+The previous example can then be "corrected" :
+
+    my $num = sub {
+     my @a = ('a' .. 'z');
+     unwind +(want_at(0) ? @a : scalar @a) => 0;
+    }->();
+
+will righteously set C<$num> to C<26>.
+
+=head1 WORDS
+
+=head2 C<TOP>
 
 Returns the level that currently represents the highest scope.
 
+=head2 C<HERE>
+
+The current level - i.e. C<0>.
+
+=head2 C<UP $from>
+
+The level of the scope just above C<$from>.
+
+=head2 C<DOWN $from>
+
+The level of the scope just below C<$from>.
+
+=head2 C<SUB $from>
+
+The level of the closest subroutine context above C<$from>.
+
+=head2 C<EVAL $from>
+
+The level of the closest eval context above C<$from>.
+
+If C<$from> is omitted in any of those functions, the current level is used as the reference level.
+
+=head2 C<CALLER $stack>
+
+The level of the C<$stack>-th upper subroutine/eval/format context.
+It kind of corresponds to the context represented by C<caller $stack>, but while e.g. C<caller 0> refers to the caller context, C<CALLER 0> will refer to the top scope in the current context.
+For example,
+
+    reap ... => CALLER(0)
+
+will fire the destructor when the current subroutine/eval/format ends.
+
 =head1 EXPORT
 
-The functions L</reap>, L</localize>, L</localize_elem> and L</TOPLEVEL> are only exported on request, either individually or by the tags C<':funcs'> and C<':all'>.
+The functions L</reap>, L</localize>, L</localize_elem>, L</localize_delete>,  L</unwind> and L</want_at> are only exported on request, either individually or by the tags C<':funcs'> and C<':all'>.
+
+Same goes for the words L</TOP>, L</HERE>, L</UP>, L</DOWN>, L</SUB>, L</EVAL> and L</CALLER> that are only exported on request, individually or by the tags C<':words'> and C<':all'>.
 
 =cut
 
@@ -125,7 +235,8 @@ use base qw/Exporter/;
 
 our @EXPORT      = ();
 our %EXPORT_TAGS = (
- funcs => [ qw/reap localize localize_elem TOPLEVEL/ ],
+ funcs => [ qw/reap localize localize_elem localize_delete unwind want_at/ ],
+ words => [ qw/TOP HERE UP DOWN SUB EVAL CALLER/ ],
 );
 our @EXPORT_OK   = map { @$_ } values %EXPORT_TAGS;
 $EXPORT_TAGS{'all'} = [ @EXPORT_OK ];
@@ -187,7 +298,7 @@ Inspired by Ricardo Signes.
 
 =head1 COPYRIGHT & LICENSE
 
-Copyright 2008 Vincent Pit, all rights reserved.
+Copyright 2008-2009 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.