From fa28785153da58de0024597ef6f360c9382aa478 Mon Sep 17 00:00:00 2001
From: Jesse Luehrs <doy@tozt.net>
Date: Tue, 2 Aug 2011 01:15:43 -0500
Subject: but... that breaks memoization, so disable that for now

---
 lib/Eval/Closure.pm   | 27 +++++++--------------------
 t/compiling-package.t | 10 ++++++++++
 t/memoize.t           |  6 ++++++
 3 files changed, 23 insertions(+), 20 deletions(-)

diff --git a/lib/Eval/Closure.pm b/lib/Eval/Closure.pm
index 42c20da..4a39ed2 100644
--- a/lib/Eval/Closure.pm
+++ b/lib/Eval/Closure.pm
@@ -36,16 +36,11 @@ String eval is often used for dynamic code generation. For instance, C<Moose>
 uses it heavily, to generate inlined versions of accessors and constructors,
 which speeds code up at runtime by a significant amount. String eval is not
 without its issues however - it's difficult to control the scope it's used in
-(which determines which variables are in scope inside the eval), and it can be
-quite slow, especially if doing a large number of evals.
+(which determines which variables are in scope inside the eval).
 
-This module attempts to solve both of those problems. It provides an
-C<eval_closure> function, which evals a string in a clean environment, other
-than a fixed list of specified variables. It also caches the result of the
-eval, so that doing repeated evals of the same source, even with a different
-environment, will be much faster (but note that the description is part of the
-string to be evaled, so it must also be the same (or non-existent) if caching
-is to work properly).
+This module attempts to solve this problem. It provides an C<eval_closure>
+function, which evals a string in a clean environment, other than a fixed list
+of specified variables.
 
 =cut
 
@@ -193,18 +188,10 @@ sub _clean_eval_closure {
     return ($code, $e);
 }
 
-{
-    my %compiler_cache;
+sub _make_compiler {
+    my $source = _make_compiler_source(@_);
 
-    sub _make_compiler {
-        my $source = _make_compiler_source(@_);
-
-        unless (exists $compiler_cache{$source}) {
-            $compiler_cache{$source} = _clean_eval($source);
-        }
-
-        return @{ $compiler_cache{$source} };
-    }
+    return @{ _clean_eval($source) };
 }
 
 $Eval::Closure::SANDBOX_ID = 0;
diff --git a/t/compiling-package.t b/t/compiling-package.t
index 09b4d0b..fa27d0e 100644
--- a/t/compiling-package.t
+++ b/t/compiling-package.t
@@ -31,4 +31,14 @@ use Eval::Closure;
     is($c2->(), -2);
 }
 
+{
+    my $source = 'no strict "vars"; sub { ++$foo }';
+    my $c1 = eval_closure(source => $source);
+    my $c2 = eval_closure(source => $source);
+    is($c1->(), 1);
+    is($c1->(), 2);
+    is($c2->(), 1);
+    is($c2->(), 2);
+}
+
 done_testing;
diff --git a/t/memoize.t b/t/memoize.t
index 02fd11f..b012596 100644
--- a/t/memoize.t
+++ b/t/memoize.t
@@ -7,6 +7,12 @@ use Test::Requires 'Test::Output';
 
 use Eval::Closure;
 
+# XXX this whole test isn't very useful anymore, since we no longer do
+# memoization. it would be nice to bring it back at some point though, if there
+# was a way to do this without breaking the other tests
+
+plan skip_all => "disabling this test for now";
+
 {
     my $source = 'BEGIN { warn "foo\n" } sub { $foo * 2 }';
 
-- 
cgit v1.2.3-54-g00ecf