use Scalar::Util qw(weaken);
use base qw(Exporter);
+our $VERSION = '1.003001';
+$VERSION = eval $VERSION;
+
our @EXPORT = qw(quote_sub unquote_sub quoted_from_sub);
our %QUOTED;
$do.'my ('.$code_args.') = ('.$args.'); '.$body.' }';
}
} else {
- $do.($local ? 'local ' : '').'@_ = ('.$args.'); '.$code.' }';
+ my $assign = '';
+ if ($local || $args ne '@_') {
+ $assign = ($local ? 'local ' : '').'@_ = ('.$args.'); ';
+ }
+ $do.$assign.$code.' }';
}
}
undef($captures) if $captures && !keys %$captures;
my $code = pop;
my $name = $_[0];
- my $outstanding;
+ my $quoted_info;
my $deferred = defer_sub +($options->{no_install} ? undef : $name) => sub {
- unquote_sub($outstanding);
+ unquote_sub($quoted_info->[4]);
};
- $outstanding = "$deferred";
- $QUOTED{$outstanding} = [ $name, $code, $captures ];
- weaken($WEAK_REFS{$outstanding} = $deferred);
+ $quoted_info = [ $name, $code, $captures, undef, $deferred ];
+ weaken($QUOTED{$deferred} = $quoted_info);
return $deferred;
}
sub quoted_from_sub {
my ($sub) = @_;
- $WEAK_REFS{$sub||''} and $QUOTED{$sub||''};
+ $QUOTED{$sub||''};
}
sub unquote_sub {
my $make_sub = "{\n";
- if (keys %$captures) {
- $make_sub .= capture_unroll("\$_[1]", $captures, 2);
- }
+ my %captures = $captures ? %$captures : ();
+ $captures{'$_QUOTED'} = \$QUOTED{$sub};
+ $make_sub .= capture_unroll("\$_[1]", \%captures, 2);
- my $o_quoted = perlstring $sub;
$make_sub .= (
$name
# disable the 'variable $x will not stay shared' warning since
# we're not letting it escape from this scope anyway so there's
# nothing trying to share it
? " no warnings 'closure';\n sub ${name} {\n"
- : " \$Sub::Quote::QUOTED{${o_quoted}}[3] = sub {\n"
+ : " \$_QUOTED->[3] = sub {\n"
);
$make_sub .= $code;
$make_sub .= " }".($name ? '' : ';')."\n";
if ($name) {
- $make_sub .= " \$Sub::Quote::QUOTED{${o_quoted}}[3] = \\&${name}\n";
+ $make_sub .= " \$_QUOTED->[3] = \\&${name}\n";
}
$make_sub .= "}\n1;\n";
$ENV{SUB_QUOTE_DEBUG} && warn $make_sub;
local $@;
no strict 'refs';
local *{$name} if $name;
- unless (_clean_eval $make_sub, $captures) {
+ unless (_clean_eval $make_sub, \%captures) {
die "Eval went very, very wrong:\n\n${make_sub}\n\n$@";
}
}
$QUOTED{$sub}[3];
}
+sub CLONE {
+ %QUOTED = map { defined $_ ? ($_->[4] => $_) : () } values %QUOTED;
+ weaken($_) for values %QUOTED;
+}
+
1;
+__END__
=head1 NAME
my $sound = 0;
- quote_sub 'Silly::dragon',
+ quote_sub 'Silly::dagron',
q{ print ++$sound % 2 ? 'burninate' : 'roar' },
{ '$sound' => \$sound };
Silly->kitty; # meow
Silly->doggy; # woof
- Silly->dragon; # burninate
- Silly->dragon; # roar
- Silly->dragon; # burninate
+ Silly->dagron; # burninate
+ Silly->dagron; # roar
+ Silly->dagron; # burninate
=head1 DESCRIPTION
C<$code> is a string that will be turned into code.
C<\%captures> is a hashref of variables that will be made available to the
-code. See the L</SYNOPSIS>'s C<Silly::dragon> for an example using captures.
+code. The keys should be the full name of the variable to be made available,
+including the sigil. The values should be references to the values. The
+variables will contain copies of the values. See the L</SYNOPSIS>'s
+C<Silly::dagron> for an example using captures.
=head3 options
my $coderef = unquote_sub $sub;
-Forcibly replace subroutine with actual code. Note that for performance
-reasons all quoted subs declared so far will be globally unquoted/parsed in
-a single eval. This means that if you have a syntax error in one of your
-quoted subs you may find out when some other sub is unquoted.
+Forcibly replace subroutine with actual code.
If $sub is not a quoted sub, this is a no-op.
=head2 inlinify
- my $prelude = capture_unroll {
+ my $prelude = capture_unroll '$captures', {
'$x' => 1,
'$y' => 2,
};
=head2 capture_unroll
- my $prelude = capture_unroll {
+ my $prelude = capture_unroll '$captures', {
'$x' => 1,
'$y' => 2,
- };
+ }, 4;
+
+Arguments: $from, \%captures, $indent
Generates a snippet of code which is suitable to be used as a prelude for
-L</inlinify>. The keys are the names of the variables and the values are (duh)
-the values. Note that references work as values.
+L</inlinify>. C<$from> is a string will be used as a hashref in the resulting
+code. The keys of C<%captures> are the names of the variables and the values
+are ignored. C<$indent> is the number of spaces to indent the result by.
=head1 CAVEATS
Which will obviously return from foo, when all you meant to do was return from
the code context in quote_sub and proceed with running important code b.
+
+=head2 strictures
+
+Sub::Quote compiles quoted subs in an environment where C<< use strictures >>
+is in effect. L<strictures> enables L<strict> and FATAL L<warnings>.
+
+The following dies I<< Use of uninitialized value in print... >>
+
+ no warnings;
+ quote_sub 'Silly::kitty', q{ print undef };
+
+If you need to disable parts of strictures, do it within the quoted sub:
+
+ quote_sub 'Silly::kitty', q{ no warnings; print undef };
+
+=head1 SUPPORT
+
+See L<Moo> for support and contact information.
+
+=head1 AUTHORS
+
+See L<Moo> for authors.
+
+=head1 COPYRIGHT AND LICENSE
+
+See L<Moo> for the copyright and license.
+
+=cut
projects / gitmo/Moo.git / blobdiff