changed Mojo::IOLoop->client arguments from ($loop, $stream, $err) to…

… ($loop, $err, $stream)
mojolicious · Dec 16, 2011 · 0eccdc7 · 0eccdc7
1 parent 7122097
commit 0eccdc7
Show file tree

Hide file tree

Showing 23 changed files with 87 additions and 85 deletions.
diff --git a/Changes b/Changes
@@ -1,6 +1,8 @@
 This file documents the revision history for Perl extension Mojolicious.
 
-2.38    2011-12-16 00:00:00
+2.38    2011-12-17 00:00:00
+        - Changed Mojo::IOLoop->client arguments from ($loop, $stream, $err)
+          to ($loop, $err, $stream).
         - Improved documentation. (marcus, sri)
         - Improved tests.
         - Fixed memory leaks caused by named capture groups bug in Perl.

diff --git a/examples/connect-proxy.pl b/examples/connect-proxy.pl
@@ -29,9 +29,9 @@
             my $server;
             $server = Mojo::IOLoop->client(
               {address => $address, port => $port} => sub {
-                my ($loop, $stream, $error) = @_;
-                if ($error) {
-                  say "Connection error for $address:$port: $error";
+                my ($loop, $err, $stream) = @_;
+                if ($err) {
+                  say "Connection error for $address:$port: $err";
                   Mojo::IOLoop->drop($client);
                   return delete $c->{$client};
                 }

diff --git a/lib/Mojo/IOLoop.pm b/lib/Mojo/IOLoop.pm
@@ -57,13 +57,13 @@ sub client {
       $self->stream($stream => $id);
 
       # Connected
-      $self->$cb($stream);
+      $self->$cb(undef, $stream);
     }
   );
   $client->on(
     error => sub {
       my $c = delete $self->{connections}->{$id};
-      $self->$cb(undef, pop);
+      $self->$cb(pop);
     }
   );
 
@@ -87,13 +87,13 @@ sub connect {
   my $id;
   $id = $self->client(
     $args => sub {
-      my ($self, $stream, $error) = @_;
+      my ($self, $err, $stream) = @_;
 
       my $c = $self->{connections}->{$id};
       $c->{$_} = delete($args->{"on_$_"}) || $c->{$_}
         for qw/close connect error read/;
-      if ($error) {
-        $c->{error}->($self, $id, $error) if $c->{error};
+      if ($err) {
+        $c->{error}->($self, $id, $err) if $c->{error};
         return;
       }
 
@@ -481,7 +481,7 @@ Mojo::IOLoop - Minimalistic reactor for non-blocking TCP clients and servers
 
   # Connect to port 3000
   my $id = Mojo::IOLoop->client({port => 3000} => sub {
-    my ($loop, $stream) = @_;
+    my ($loop, $err, $stream) = @_;
 
     $stream->on(read => sub {
       my ($stream, $chunk) = @_;
@@ -622,7 +622,7 @@ L<Mojo::IOLoop::Client/"connect">. Note that this method is EXPERIMENTAL and
 might change without warning!
 
   Mojo::IOLoop->client({port => 3000} => sub {
-    my ($loop, $stream, $error) = @_;
+    my ($loop, $err, $stream) = @_;
   });
 
 =head2 C<defer>

diff --git a/lib/Mojo/IOLoop/Client.pm b/lib/Mojo/IOLoop/Client.pm
@@ -125,9 +125,9 @@ sub _connecting {
   my $handle  = $self->{handle};
   my $watcher = $self->iowatcher;
   if ($self->{tls} && !$handle->connect_SSL) {
-    my $error = $IO::Socket::SSL::SSL_ERROR;
-    if    ($error == TLS_READ)  { $watcher->change($handle, 1, 0) }
-    elsif ($error == TLS_WRITE) { $watcher->change($handle, 1, 1) }
+    my $err = $IO::Socket::SSL::SSL_ERROR;
+    if    ($err == TLS_READ)  { $watcher->change($handle, 1, 0) }
+    elsif ($err == TLS_WRITE) { $watcher->change($handle, 1, 1) }
     return;
   }
 
@@ -159,7 +159,7 @@ Mojo::IOLoop::Client - Non-blocking TCP client
     ...
   });
   $client->on(error => sub {
-    my ($client, $error) = @_;
+    my ($client, $err) = @_;
     ...
   });
   $client->connect(address => 'mojolicio.us', port => 80);
@@ -184,7 +184,7 @@ Emitted safely once the connection is established.
 =head2 C<error>
 
   $client->on(error => sub {
-    my ($client, $error) = @_;
+    my ($client, $err) = @_;
   });
 
 Emitted safely if an error happens on the connection.

diff --git a/lib/Mojo/IOLoop/Server.pm b/lib/Mojo/IOLoop/Server.pm
@@ -253,9 +253,9 @@ sub _tls {
   }
 
   # Switch between reading and writing
-  my $error = $IO::Socket::SSL::SSL_ERROR;
-  if    ($error == TLS_READ)  { $self->iowatcher->change($handle, 1, 0) }
-  elsif ($error == TLS_WRITE) { $self->iowatcher->change($handle, 1, 1) }
+  my $err = $IO::Socket::SSL::SSL_ERROR;
+  if    ($err == TLS_READ)  { $self->iowatcher->change($handle, 1, 0) }
+  elsif ($err == TLS_WRITE) { $self->iowatcher->change($handle, 1, 1) }
 }
 
 1;

diff --git a/lib/Mojo/IOLoop/Stream.pm b/lib/Mojo/IOLoop/Stream.pm
@@ -186,7 +186,7 @@ Mojo::IOLoop::Stream - Non-blocking I/O stream
     ...
   });
   $stream->on(error => sub {
-    my ($stream, $error) = @_;
+    my ($stream, $err) = @_;
     ...
   });
 
@@ -223,7 +223,7 @@ Emitted safely once all data has been written.
 =head2 C<error>
 
   $stream->on(error => sub {
-    my ($stream, $error) = @_;
+    my ($stream, $err) = @_;
   });
 
 Emitted safely if an error happens on the stream.

diff --git a/lib/Mojo/IOWatcher.pm b/lib/Mojo/IOWatcher.pm
@@ -171,7 +171,7 @@ L<Mojo::IOWatcher> can emit the following events.
 =head2 C<error>
 
   $watcher->on(error => sub {
-    my ($watcher, $error) = @_;
+    my ($watcher, $err) = @_;
   });
 
 Emitted safely if an error happens.

diff --git a/lib/Mojo/JSON.pm b/lib/Mojo/JSON.pm
@@ -407,8 +407,8 @@ L<Mojo::JSON> implements the following attributes.
 
 =head2 C<error>
 
-  my $error = $json->error;
-  $json     = $json->error('Oops!');
+  my $err = $json->error;
+  $json   = $json->error('Oops!');
 
 Parser errors.
 

diff --git a/lib/Mojo/Message.pm b/lib/Mojo/Message.pm
@@ -191,8 +191,8 @@ sub error {
 
   # Get
   unless (@_) {
-    return unless my $error = $self->{error};
-    return wantarray ? @$error : $error->[0];
+    return unless my $err = $self->{error};
+    return wantarray ? @$err : $err->[0];
   }
 
   # Set

diff --git a/lib/Mojo/Server/Daemon.pm b/lib/Mojo/Server/Daemon.pm
@@ -131,8 +131,8 @@ sub _drop {
 }
 
 sub _error {
-  my ($self, $id, $error) = @_;
-  $self->app->log->error($error);
+  my ($self, $id, $err) = @_;
+  $self->app->log->error($err);
   $self->_drop($id);
 }
 

diff --git a/lib/Mojo/UserAgent.pm b/lib/Mojo/UserAgent.pm
@@ -223,10 +223,10 @@ sub _connect {
     tls_cert => $self->cert,
     tls_key  => $self->key,
     sub {
-      my ($loop, $stream, $error) = @_;
+      my ($loop, $err, $stream) = @_;
 
       # Events
-      return $self->_error($id, $error) if $error;
+      return $self->_error($id, $err) if $err;
       $self->_events($stream, $id);
       $self->_connected($id);
     }
@@ -265,10 +265,10 @@ sub _connect_proxy {
           tls_cert => $self->cert,
           tls_key  => $self->key,
           sub {
-            my ($loop, $stream, $error) = @_;
+            my ($loop, $err, $stream) = @_;
 
             # Events
-            return $self->_error($id, $error) if $error;
+            return $self->_error($id, $err) if $err;
             $self->_events($stream, $id);
 
             # Start real transaction
@@ -326,10 +326,10 @@ sub _drop {
 }
 
 sub _error {
-  my ($self, $id, $error, $log) = @_;
-  if (my $tx = $self->{connections}->{$id}->{tx}) { $tx->res->error($error) }
-  $self->log->error($error) if $log;
-  $self->_handle($id, $error);
+  my ($self, $id, $err, $log) = @_;
+  if (my $tx = $self->{connections}->{$id}->{tx}) { $tx->res->error($err) }
+  $self->log->error($err) if $log;
+  $self->_handle($id, $err);
 }
 
 sub _events {

diff --git a/lib/Mojolicious/Plugin/JSONConfig.pm b/lib/Mojolicious/Plugin/JSONConfig.pm
@@ -16,8 +16,8 @@ sub parse {
   # Parse
   my $json   = Mojo::JSON->new;
   my $config = $json->decode($content);
-  my $error  = $json->error;
-  die qq/Couldn't parse config "$file": $error/ if !$config && $error;
+  my $err    = $json->error;
+  die qq/Couldn't parse config "$file": $err/ if !$config && $err;
   die qq/Invalid config "$file"./ if !$config || ref $config ne 'HASH';
 
   return $config;

diff --git a/lib/Test/Mojo.pm b/lib/Test/Mojo.pm
@@ -335,8 +335,8 @@ sub _request_ok {
   # Perform request against application
   $self->tx($self->ua->$method($url, %$headers, $body));
   local $Test::Builder::Level = $Test::Builder::Level + 2;
-  my ($error, $code) = $self->tx->error;
-  Test::More::diag $error if !(my $ok = !$error || $code) && $error;
+  my ($err, $code) = $self->tx->error;
+  Test::More::diag $err if !(my $ok = !$err || $code) && $err;
   Test::More::ok $ok, encode('UTF-8', "$method $url");
 
   return $self;

diff --git a/t/mojo/app.t b/t/mojo/app.t
@@ -70,7 +70,7 @@ my $buffer = '';
 my $id;
 $id = Mojo::IOLoop->client(
   {port => $port} => sub {
-    my ($loop, $stream) = @_;
+    my ($loop, $err, $stream) = @_;
     $stream->on(
       read => sub {
         my ($stream, $chunk) = @_;
@@ -93,7 +93,7 @@ like $buffer, qr#HTTP/1.1 100 Continue.*Mojo$#s, 'request was continued';
 $buffer = '';
 $id     = Mojo::IOLoop->client(
   {port => $port} => sub {
-    my ($loop, $stream) = @_;
+    my ($loop, $err, $stream) = @_;
     $stream->on(
       read => sub {
         my ($stream, $chunk) = @_;

diff --git a/t/mojo/eventemitter.t b/t/mojo/eventemitter.t
@@ -18,8 +18,8 @@ eval { $e->emit('die') };
 is $@, "works!\n", 'right error';
 
 # Error fallback
-my ($echo, $error);
-$e->on(error => sub { $error = pop });
+my ($echo, $err);
+$e->on(error => sub { $err = pop });
 $e->on(test2 => sub { $echo .= 'echo: ' . pop });
 $e->on(
   test2 => sub {
@@ -31,14 +31,14 @@ my $cb = sub { $echo .= 'echo2: ' . pop };
 $e->on(test2 => $cb);
 $e->emit_safe('test2', 'works!');
 is $echo, 'echo: works!echo2: works!', 'right echo';
-is $error, qq/Event "test2" failed: test2: works!\n/, 'right error';
-$echo = $error = undef;
+is $err, qq/Event "test2" failed: test2: works!\n/, 'right error';
+$echo = $err = undef;
 is scalar @{$e->subscribers('test2')}, 3, 'three subscribers';
 $e->unsubscribe(test2 => $cb);
 is scalar @{$e->subscribers('test2')}, 2, 'two subscribers';
 $e->emit_safe('test2', 'works!');
 is $echo, 'echo: works!', 'right echo';
-is $error, qq/Event "test2" failed: test2: works!\n/, 'right error';
+is $err, qq/Event "test2" failed: test2: works!\n/, 'right error';
 
 # Normal event again
 $e->emit('test1');

diff --git a/t/mojo/ioloop.t b/t/mojo/ioloop.t
@@ -33,16 +33,16 @@ $loop = Mojo::IOLoop->new;
 is ref $loop->iowatcher, 'MyWatcher', 'right class';
 
 # Double start
-my $error;
+my $err;
 Mojo::IOLoop->defer(
   sub {
     eval { Mojo::IOLoop->start };
-    $error = $@;
+    $err = $@;
     Mojo::IOLoop->stop;
   }
 );
 Mojo::IOLoop->start;
-like $error, qr/^Mojo::IOLoop already running/, 'right error';
+like $err, qr/^Mojo::IOLoop already running/, 'right error';
 
 # Ticks
 my $ticks = 0;
@@ -140,7 +140,7 @@ my $delay = Mojo::IOLoop->delay;
 $delay->begin;
 Mojo::IOLoop->client(
   {port => $port} => sub {
-    my ($loop, $stream, $error) = @_;
+    my ($loop, $err, $stream) = @_;
     $delay->end($stream);
     $stream->on(close => sub { $buffer .= 'should not happen' });
     $stream->on(error => sub { $buffer .= 'should not happen either' });
@@ -165,7 +165,7 @@ $id = $loop->server({port => $port} => sub { });
 my $connected;
 $loop->client(
   {port => $port} => sub {
-    my ($loop, $stream) = @_;
+    my ($loop, $err, $stream) = @_;
     $loop->drop($id);
     $loop->stop;
     $connected = 1;
@@ -175,15 +175,15 @@ like $ENV{MOJO_REUSE}, qr/(?:^|\,)$port\:/, 'file descriptor can be reused';
 $loop->start;
 unlike $ENV{MOJO_REUSE}, qr/(?:^|\,)$port\:/, 'environment is clean';
 ok $connected, 'connected';
-$error = undef;
+$err = undef;
 $loop->client(
   (port => $port) => sub {
     shift->stop;
-    $error = pop;
+    $err = pop;
   }
 );
 $loop->start;
-ok $error, 'has error';
+ok $err, 'has error';
 
 # Dropped connection
 $port = Mojo::IOLoop->generate_port;
@@ -196,7 +196,7 @@ Mojo::IOLoop->server(
 );
 $id = Mojo::IOLoop->client(
   (port => $port) => sub {
-    my ($loop, $stream) = @_;
+    my ($loop, $err, $stream) = @_;
     $stream->on(close => sub { $client_close++ });
     $loop->drop($id);
   }
@@ -237,7 +237,7 @@ Mojo::IOLoop->server(
 );
 Mojo::IOLoop->client(
   {port => $port} => sub {
-    my ($loop, $stream) = @_;
+    my ($loop, $err, $stream) = @_;
     my $drain;
     $drain = sub { shift->write('1', $drain) };
     $stream->$drain();

diff --git a/t/mojo/ioloop_tls.t b/t/mojo/ioloop_tls.t
@@ -52,7 +52,7 @@ $loop->server(
 );
 $loop->client(
   {port => $port, tls => 1} => sub {
-    my ($loop, $stream) = @_;
+    my ($loop, $err, $stream) = @_;
     $stream->write('tset', sub { shift->write('123') });
     $stream->on(read => sub { $client .= pop });
   }
@@ -91,7 +91,7 @@ my $id = $loop->client(
   tls_cert => 't/mojo/certs/client.crt',
   tls_key  => 't/mojo/certs/client.key',
   sub {
-    my ($loop, $stream) = @_;
+    my ($loop, $err, $stream) = @_;
     $stream->write('tset', sub { shift->write('123') });
     $stream->on(close => sub { $client_close++ });
     $stream->on(read => sub { $client .= pop });
@@ -175,7 +175,7 @@ $id = $loop->client(
   tls_cert => 't/mojo/certs/client.crt',
   tls_key  => 't/mojo/certs/client.key',
   sub {
-    my ($loop, $stream) = @_;
+    my ($loop, $err, $stream) = @_;
     $stream->write('tset', sub { shift->write('123') });
     $stream->on(close => sub { $client_close++ });
     $stream->on(read => sub { $client .= pop });