File Coverage

blib/lib/Mojolicious/Plugin/Parallol.pm

Criterion	Covered	Total	%
statement	46	54	85.1
branch	20	26	76.9
condition	6	7	85.7
subroutine	7	7	100.0
pod	1	1	100.0
total	80	95	84.2

package Mojolicious::Plugin::Parallol;

use Mojo::Base 'Mojolicious::Plugin';
use Scalar::Util 'weaken';
use Carp;

sub register {
  my ($plugin, $app) = @_;

  $app->helper(on_parallol => sub {
    my $p = shift->stash('parallol');
    carp "Can't call on_parallol outside of Parallol" unless $p;

    # Setter.
    return $p->{done} = shift if @_;

    # Getter w/ default.
    return $p->{done} ||= sub {
      my $self = shift;
      $self->render unless $self->stash('mojo.finished');
    }
  });

  $app->hook(around_dispatch => sub {
    my ($next, $self) = @_;

    my $p = {};
    $self->stash(parallol => $p);

    # This number represents the number of pending calls (that is, calls
    # that have been done, but the callback hasn't been called yet).
    # Every time this number gets decremented to zero, you must also
    # call $self->on_parallol->($self) to signal that everything is
    # done.
    #
    # This number starts at 1 because we consider the action itself a
    # pending call.
    $p->{paralloling} = 1;

    # Call action.
    $next->();

    # If the action didn't call $self->parallol, don't do anything more.
    return unless $p->{paralloled};

    # The action is now done. As mentioned above, we must call
    # on_parallol if there's nothing left to do.
    return $self->on_parallol->($self) if --$p->{paralloling} == 0;

    # If the IO loop is not running  ...
    return if Mojo::IOLoop->is_running;

    # ... we want to run the IO loop and stop it again when it's done.
    my $cb = $self->on_parallol;
    $self->on_parallol(sub {
      # Run the callback; capture any errors.
      eval { $cb->(@_); 1 } or my $e = $@;
      Mojo::IOLoop->stop;
      # Re-throw the error.
      die $e if $e;
    });

    Mojo::IOLoop->start;
  });

  $app->helper(
    parallol => sub {
      my $callback = pop;
      my ($self, %opts) = @_;
      my $p = $self->stash('parallol');

      if (ref $callback && ref $callback eq 'CODE') {
        weaken($self) if $opts{weaken} // 1;
      } else {
        my $name = $callback;
        $callback = sub { $self->stash($name => pop) }
      }

      # Mark the request as async and paralloled.
      $self->render_later;
      $p->{paralloled} = 1;

      # Increment pending calls.
      $p->{paralloling}++;


      sub {
        # Run the callback.
        eval { $callback->(@_); 1 } or $self->render_exception($@);

        # Run on_parallol if it's finished.
        if (--$p->{paralloling} == 0) {
          eval { $self->on_parallol->($self); 1 } or $self->render_exception($@);
        }
      }
    }
  );
}

"Parallolololololololololol";

__END__