rewrite nonMoo detection

[gitmo/Role-Tiny.git] / lib / Sub / Defer.pm

diff --git a/lib/Sub/Defer.pm b/lib/Sub/Defer.pm
index 11430fa..4f2db1f 100644 (file)
--- a/lib/Sub/Defer.pm
+++ b/lib/Sub/Defer.pm
@@ -2,34 +2,85 @@ package Sub::Defer;
 
 use strictures 1;
 use base qw(Exporter);
+use Moo::_Utils;
 
-our @EXPORT = qw(defer undefer);
+our @EXPORT = qw(defer_sub undefer_sub);
 
 our %DEFERRED;
 
-sub _getglob { no strict 'refs'; \*{$_[0]} }
-
-sub undefer {
+sub undefer_sub {
   my ($deferred) = @_;
   my ($target, $maker, $undeferred_ref) = @{
     $DEFERRED{$deferred}||return $deferred
   };
   ${$undeferred_ref} = my $made = $maker->();
-  { no warnings 'redefine'; *{_getglob($target)} = $made }
+  if (defined($target)) {
+    no warnings 'redefine';
+    *{_getglob($target)} = $made;
+  }
+  push @{$DEFERRED{$made} = $DEFERRED{$deferred}}, $made;
   return $made;
 }
 
-sub defer {
+sub defer_info {
+  my ($deferred) = @_;
+  $DEFERRED{$deferred||''};
+}
+
+sub defer_sub {
   my ($target, $maker) = @_;
   my $undeferred;
   my $deferred_string;
-  my $deferred = bless(sub {
-    goto &{$undeferred ||= undefer($deferred_string)};
-  }, 'Sub::Defer::Deferred');
+  my $deferred = sub {
+    goto &{$undeferred ||= undefer_sub($deferred_string)};
+  };
   $deferred_string = "$deferred";
   $DEFERRED{$deferred} = [ $target, $maker, \$undeferred ];
-  *{_getglob $target} = $deferred;
+  *{_getglob $target} = $deferred if defined($target);
   return $deferred;
 }
 
 1;
+
+=head1 NAME
+
+Sub::Defer - defer generation of subroutines until they are first called
+
+=head1 SYNOPSIS
+
+ use Sub::Defer;
+
+ my $deferred = defer_sub 'Logger::time_since_first_log' => sub {
+    my $t = time;
+    sub { time - $t };
+ };
+
+  Logger->time_since_first_log; # returns 0 and replaces itself
+  Logger->time_since_first_log; # returns time - $t
+
+=head1 DESCRIPTION
+
+These subroutines provide the user with a convenient way to defer creation of
+subroutines and methods until they are first called.
+
+=head1 SUBROUTINES
+
+=head2 defer_sub
+
+ my $coderef = defer_sub $name => sub { ... };
+
+This subroutine returns a coderef that encapsulates the provided sub - when
+it is first called, the provided sub is called and is -itself- expected to
+return a subroutine which will be goto'ed to on subsequent calls.
+
+If a name is provided, this also installs the sub as that name - and when
+the subroutine is undeferred will re-install the final version for speed.
+
+=head2 undefer_sub
+
+ my $coderef = undefer_sub \&Foo::name;
+
+If the passed coderef has been L<deferred|/defer_sub> this will "undefer" it.
+If the passed coderef has not been deferred, this will just return it.
+
+If this is confusing, take a look at the example in the L</SYNOPSIS>.