deprecated Mojo::IOLoop::Delay::end in favor of generated callbacks

mojolicious · Apr 4, 2013 · f63ec86 · f63ec86
1 parent 71f6603
commit f63ec86
Show file tree

Hide file tree

Showing 11 changed files with 80 additions and 77 deletions.
diff --git a/Changes b/Changes
@@ -1,5 +1,8 @@
 
 3.93  2013-04-04
+  - Deprecated Mojo::IOLoop::Delay::end in favor of generated callbacks.
+  - Improved Mojo::IOLoop::Delay to be able to generate callbacks that can
+    capture all arguments.
   - Improved prefork command to allow -a and -L values below 1 second.
   - Improved documentation.
   - Fixed multiple timing bugs in Mojo::IOLoop::Delay.

diff --git a/lib/Mojo/IOLoop.pm b/lib/Mojo/IOLoop.pm
@@ -467,10 +467,10 @@ ones as a chain of steps.
   # Synchronize multiple events
   my $delay = Mojo::IOLoop->delay(sub { say 'BOOM!' });
   for my $i (1 .. 10) {
-    $delay->begin;
+    my $end = $delay->begin;
     Mojo::IOLoop->timer($i => sub {
       say 10 - $i;
-      $delay->end;
+      $end->();
     });
   }
 

diff --git a/lib/Mojo/IOLoop/Delay.pm b/lib/Mojo/IOLoop/Delay.pm
@@ -2,17 +2,23 @@ package Mojo::IOLoop::Delay;
 use Mojo::Base 'Mojo::EventEmitter';
 
 use Mojo::IOLoop;
+use Mojo::Util 'deprecated';
 
 has ioloop => sub { Mojo::IOLoop->singleton };
 
 sub begin {
-  my $self = shift;
+  my ($self, $ignore) = @_;
   $self->{counter}++;
   my $id = $self->{id}++;
-  return sub { shift; $self->_step($id, @_) };
+  return sub { $ignore // 1 and shift; $self->_step($id, @_) };
 }
 
-sub end { shift->_step(undef, @_) }
+# DEPRECATED in Rainbow!
+sub end {
+  deprecated
+    'Mojo::IOLoop::Delay::end is DEPRECATED in favor of generated callbacks';
+  shift->_step(undef, @_);
+}
 
 sub steps {
   my $self = shift;
@@ -32,18 +38,18 @@ sub wait {
 sub _step {
   my ($self, $id) = (shift, shift);
 
-  # Arguments
-  my $ordered   = $self->{ordered}   ||= [];
-  my $unordered = $self->{unordered} ||= [];
-  if (defined $id) { $ordered->[$id] = [@_] }
-  else             { push @$unordered, @_ }
+  if (defined $id) { $self->{args}[$id] = [@_] }
+
+  # DEPRECATED in Rainbow!
+  else { push @{$self->{unordered}}, @_ }
 
-  # Wait for more events
   return $self->{counter} if --$self->{counter} || $self->{step};
 
-  # Next step
-  $self->{$_} = [] for qw(ordered unordered);
-  my @args = ((map {@$_} grep {defined} @$ordered), @$unordered);
+  my @args = (map {@$_} grep {defined} @{delete($self->{args}) || []});
+
+  # DEPRECATED in Rainbow!
+  push @args, @{delete($self->{unordered}) || []};
+
   local $self->{step} = 1;
   if (my $cb = shift @{$self->{steps} ||= []}) { $self->$cb(@args) }
   $self->emit(finish => @args) unless $self->{counter};
@@ -65,10 +71,10 @@ Mojo::IOLoop::Delay - Control the flow of events
   my $delay = Mojo::IOLoop::Delay->new;
   $delay->on(finish => sub { say 'BOOM!' });
   for my $i (1 .. 10) {
-    $delay->begin;
+    my $end = $delay->begin;
     Mojo::IOLoop->timer($i => sub {
       say 10 - $i;
-      $delay->end;
+      $end->();
     });
   }
 
@@ -139,23 +145,17 @@ implements the following new ones.
 =head2 begin
 
   my $cb = $delay->begin;
+  my $cb = $delay->begin(0);
 
-Increment active event counter, the returned callback can be used instead of
-C<end>, which has the advantage of preserving the order of arguments. Note
-that the first argument passed to the callback will be ignored.
+Increment active event counter, the returned callback can be used to decrement
+the active event counter again, all arguments are queued in the right order
+for the next step or C<finish> event and C<wait> method. The first argument
+passed to the callback will be ignored by default.
 
   my $delay = Mojo::IOLoop->delay;
   Mojo::UserAgent->new->get('mojolicio.us' => $delay->begin);
   my $tx = $delay->wait;
 
-=head2 end
-
-  my $remaining = $delay->end;
-  my $remaining = $delay->end(@args);
-
-Decrement active event counter, all arguments are queued for the next step or
-C<finish> event and C<wait> method.
-
 =head2 steps
 
   $delay = $delay->steps(sub {...}, sub {...});

diff --git a/lib/Mojo/UserAgent.pm b/lib/Mojo/UserAgent.pm
@@ -550,10 +550,10 @@ Mojo::UserAgent - Non-blocking I/O HTTP and WebSocket user agent
   # Blocking parallel requests (does not work inside a running event loop)
   my $delay = Mojo::IOLoop->delay;
   for my $url ('mojolicio.us', 'cpan.org') {
-    $delay->begin;
+    my $end = $delay->begin(0);
     $ua->get($url => sub {
       my ($ua, $tx) = @_;
-      $delay->end($tx->res->dom->at('title')->text);
+      $end->($tx->res->dom->at('title')->text);
     });
   }
   my @titles = $delay->wait;
@@ -564,10 +564,10 @@ Mojo::UserAgent - Non-blocking I/O HTTP and WebSocket user agent
     ...
   });
   for my $url ('mojolicio.us', 'cpan.org') {
-    $delay->begin;
+    my $end = $delay->begin(0);
     $ua->get($url => sub {
       my ($ua, $tx) = @_;
-      $delay->end($tx->res->dom->at('title')->text);
+      $end->($tx->res->dom->at('title')->text);
     });
   }
   $delay->wait unless Mojo::IOLoop->is_running;

diff --git a/lib/Mojolicious/Controller.pm b/lib/Mojolicious/Controller.pm
@@ -929,10 +929,10 @@ Get L<Mojo::UserAgent> object from L<Mojo/"ua">.
     $c->render_json(\@titles);
   });
   for my $url ('http://mojolicio.us', 'https://metacpan.org') {
-    $delay->begin;
+    my $end = $delay->begin(0);
     $c->ua->get($url => sub {
       my ($ua, $tx) = @_;
-      $delay->end($tx->res->dom->html->head->title->text);
+      $end->($tx->res->dom->html->head->title->text);
     });
   }
 

diff --git a/t/mojo/delay.t b/t/mojo/delay.t
@@ -14,13 +14,13 @@ use Mojo::IOLoop::Delay;
 my $delay = Mojo::IOLoop::Delay->new;
 my @results;
 for my $i (1, 1) {
-  $delay->begin;
-  Mojo::IOLoop->timer(0 => sub { push @results, $i; $delay->end });
+  my $end = $delay->begin;
+  Mojo::IOLoop->timer(0 => sub { push @results, $i; $end->() });
 }
-my $end = $delay->begin;
-$delay->begin;
-is $end->(), 3, 'three remaining';
-is $delay->end, 2, 'two remaining';
+my $end  = $delay->begin;
+my $end2 = $delay->begin;
+is $end->(),  3, 'three remaining';
+is $end2->(), 2, 'two remaining';
 $delay->wait;
 is_deeply \@results, [1, 1], 'right results';
 
@@ -29,17 +29,17 @@ $delay = Mojo::IOLoop::Delay->new;
 my $result;
 $delay->on(finish => sub { shift; $result = [@_] });
 for my $i (2, 2) {
-  $delay->begin;
-  Mojo::IOLoop->timer(0 => sub { $delay->end($i) });
+  my $end = $delay->begin(0);
+  Mojo::IOLoop->timer(0 => sub { $end->($i) });
 }
 is_deeply [$delay->wait], [2, 2], 'right results';
 is_deeply $result, [2, 2], 'right results';
 
 # Scalar context
 $delay = Mojo::IOLoop::Delay->new;
 for my $i (3, 3) {
-  $delay->begin;
-  Mojo::IOLoop->timer(0 => sub { $delay->end($i) });
+  my $end = $delay->begin(0);
+  Mojo::IOLoop->timer(0 => sub { $end->($i) });
 }
 is $delay->wait, 3, 'right results';
 
@@ -130,18 +130,18 @@ $delay = Mojo::IOLoop->delay(
     my $second = Mojo::IOLoop->delay($first->begin);
     Mojo::IOLoop->timer(0 => $second->begin);
     Mojo::IOLoop->timer(0 => $first->begin);
-    $second->begin;
-    Mojo::IOLoop->timer(0 => sub { $second->end(1, 2, 3) });
+    my $end = $second->begin(0);
+    Mojo::IOLoop->timer(0 => sub { $end->(1, 2, 3) });
   },
   sub {
     my ($first, @numbers) = @_;
     $result = \@numbers;
     my $end = $first->begin;
     $first->begin->(3, 2, 1);
-    $first->begin;
-    $first->begin;
-    $first->end(4);
-    $first->end(5, 6);
+    my $end2 = $first->begin(0);
+    my $end3 = $first->begin(0);
+    $end2->(4);
+    $end3->(5, 6);
     $end->(1, 2, 3);
     Mojo::IOLoop->timer(0 => $first->begin);
   },

diff --git a/t/mojo/ioloop.t b/t/mojo/ioloop.t
@@ -120,11 +120,11 @@ Mojo::IOLoop->server(
   }
 );
 my $delay = Mojo::IOLoop->delay;
-$delay->begin;
+my $end   = $delay->begin(0);
 Mojo::IOLoop->client(
   {port => $port} => sub {
     my ($loop, $err, $stream) = @_;
-    $delay->end($stream);
+    $end->($stream);
     $stream->on(close => sub { $buffer .= 'should not happen' });
     $stream->on(error => sub { $buffer .= 'should not happen either' });
   }
@@ -171,19 +171,19 @@ ok $err, 'has error';
 # Removed connection (with delay)
 my $removed;
 $delay = Mojo::IOLoop->delay(sub { $removed++ });
-$port = Mojo::IOLoop->generate_port;
-$delay->begin;
+$port  = Mojo::IOLoop->generate_port;
+$end   = $delay->begin;
 Mojo::IOLoop->server(
   (address => '127.0.0.1', port => $port) => sub {
     my ($loop, $stream) = @_;
-    $stream->on(close => sub { $delay->end });
+    $stream->on(close => $end);
   }
 );
-$delay->begin;
+my $end2 = $delay->begin;
 $id = Mojo::IOLoop->client(
   (port => $port) => sub {
     my ($loop, $err, $stream) = @_;
-    $stream->on(close => sub { $delay->end });
+    $stream->on(close => $end2);
     $loop->remove($id);
   }
 );

diff --git a/t/mojo/ioloop_ipv6.t b/t/mojo/ioloop_ipv6.t
@@ -17,21 +17,21 @@ use Mojo::IOLoop;
 my $delay = Mojo::IOLoop->delay;
 my $port  = Mojo::IOLoop->generate_port;
 my ($server, $client);
-$delay->begin;
+my $end = $delay->begin;
 Mojo::IOLoop->server(
   {address => '[::1]', port => $port} => sub {
     my ($loop, $stream) = @_;
     $stream->write('test' => sub { shift->write('321') });
-    $stream->on(close => sub { $delay->end });
+    $stream->on(close => $end);
     $stream->on(read => sub { $server .= pop });
   }
 );
-$delay->begin;
+my $end2 = $delay->begin;
 Mojo::IOLoop->client(
   {address => '[::1]', port => $port} => sub {
     my ($loop, $err, $stream) = @_;
     $stream->write('tset' => sub { shift->write('123') });
-    $stream->on(close => sub { $delay->end });
+    $stream->on(close => $end);
     $stream->on(read => sub { $client .= pop });
     $stream->timeout(0.5);
   }

diff --git a/t/mojo/ioloop_tls.t b/t/mojo/ioloop_tls.t
@@ -41,21 +41,21 @@ my $loop  = Mojo::IOLoop->new;
 my $delay = $loop->delay;
 my $port  = Mojo::IOLoop->generate_port;
 my ($server, $client);
-$delay->begin;
+my $end = $delay->begin;
 $loop->server(
   {address => '127.0.0.1', port => $port, tls => 1} => sub {
     my ($loop, $stream) = @_;
     $stream->write('test' => sub { shift->write('321') });
-    $stream->on(close => sub { $delay->end });
+    $stream->on(close => $end);
     $stream->on(read => sub { $server .= pop });
   }
 );
-$delay->begin;
+my $end2 = $delay->begin;
 $loop->client(
   {port => $port, tls => 1} => sub {
     my ($loop, $err, $stream) = @_;
     $stream->write('tset' => sub { shift->write('123') });
-    $stream->on(close => sub { $delay->end });
+    $stream->on(close => $end2);
     $stream->on(read => sub { $client .= pop });
     $stream->timeout(0.5);
   }
@@ -70,7 +70,7 @@ $port  = Mojo::IOLoop->generate_port;
 ($server, $client) = ();
 my ($remove, $running, $timeout, $server_err, $server_close, $client_close);
 Mojo::IOLoop->remove(Mojo::IOLoop->recurring(0 => sub { $remove++ }));
-$delay->begin;
+$end = $delay->begin;
 Mojo::IOLoop->server(
   address  => '127.0.0.1',
   port     => $port,
@@ -86,15 +86,15 @@ Mojo::IOLoop->server(
     $stream->on(
       close => sub {
         $server_close++;
-        $delay->end;
+        $end->();
       }
     );
     $stream->on(error => sub { $server_err = pop });
     $stream->on(read => sub { $server .= pop });
     $stream->timeout(0.5);
   }
 );
-$delay->begin;
+$end2 = $delay->begin;
 Mojo::IOLoop->client(
   port     => $port,
   tls      => 1,
@@ -106,7 +106,7 @@ Mojo::IOLoop->client(
     $stream->on(
       close => sub {
         $client_close++;
-        $delay->end;
+        $end2->();
       }
     );
     $stream->on(read => sub { $client .= pop });
@@ -181,7 +181,7 @@ $delay = Mojo::IOLoop->delay;
 $port  = Mojo::IOLoop->generate_port;
 ($running, $timeout, $server, $server_err, $server_close) = ();
 ($client, $client_close) = ();
-$delay->begin;
+$end = $delay->begin;
 Mojo::IOLoop->server(
   address  => '127.0.0.1',
   port     => $port,
@@ -196,14 +196,14 @@ Mojo::IOLoop->server(
     $stream->on(
       close => sub {
         $server_close++;
-        $delay->end;
+        $end->();
       }
     );
     $stream->on(error => sub { $server_err = pop });
     $stream->on(read => sub { $server .= pop });
   }
 );
-$delay->begin;
+$end2 = $delay->begin;
 Mojo::IOLoop->client(
   port     => $port,
   tls      => 1,
@@ -217,7 +217,7 @@ Mojo::IOLoop->client(
     $stream->on(
       close => sub {
         $client_close++;
-        $delay->end;
+        $end2->();
       }
     );
     $stream->on(read => sub { $client .= pop });