File Coverage

blib/lib/Mojolicious/Plugin/Notifications.pm

Criterion	Covered	Total	%
statement	69	73	94.5
branch	26	34	76.4
condition	13	20	65.0
subroutine	9	9	100.0
pod	1	1	100.0
total	118	137	86.1

package Mojolicious::Plugin::Notifications;
use Mojo::Base 'Mojolicious::Plugin';
use Mojo::Collection qw/c/;
use Mojolicious::Plugin::Notifications::Assets;
use Mojo::Util qw/camelize/;
use Scalar::Util qw/blessed/;

our $TYPE_RE = qr/^[-a-zA-Z_]+$/;

our $VERSION = '1.07';

# TODO:
#   Maybe revert to tx-handler and use session instead of flash!
# TODO:
#   Support Multiple Times Loading
# TODO:
#   Subroutines for Engines should be given directly
# TODO:
#   Engines may use hooks in addition

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

  $param ||= {};

  my $debug = $app->mode eq 'development' ? 1 : 0;

  # Load parameter from Config file
  if (my $config_param = $app->config('Notifications')) {
    $param = { %$param, %$config_param };
  };

  $param->{HTML} = 1 unless keys %$param;

  # Add engines from configuration
  my %engine;
  foreach my $name (keys %$param) {
    my $engine = camelize $name;
    if (index($engine,'::') < 0) {
      $engine = __PACKAGE__ . '::' . $engine;
    };

    # Load engine
    my $e = $app->plugins->load_plugin($engine);
    $e->register($app, ref $param->{$name} ? $param->{$name} : undef);
    $engine{lc $name} = $e;
  };

  # Create asset object
  my $asset = Mojolicious::Plugin::Notifications::Assets->new;

  # Set assets
  foreach (values %engine) {
    $asset->styles($_->styles)   if $_->can('styles');
    $asset->scripts($_->scripts) if $_->can('scripts');
  };


  # Add notifications
  $app->helper(
    notify => sub {
      my $c = shift;
      my $type = shift;
      my @msg = @_;

      # Ignore debug messages in production
      return if $type !~ $TYPE_RE || (!$debug && $type eq 'debug');

      my $notes;

      # Notifications already set
      if ($notes = $c->stash('notify.array')) {
        push @$notes, [$type => @msg];
      }

      # New notifications as a Mojo::Collection
      else {
        $c->stash('notify.array' => c([$type => @msg]));
      };
    }
  );


  # Embed notification display
  $app->helper(
    notifications => sub {
      my $c = shift;

      return $asset unless @_;

      my $e_type = lc shift;
      my @param = @_;

      # Get stash notifications
      my $notes = ($c->stash->{'notify.array'} //= c());

      # Get flash notifications
      my $flash = $c->flash('n!.a');

      if ($flash && ref $flash eq 'ARRAY') {

        # Ensure that no harmful types are injected
        unshift @$notes, grep { $_->[0] =~ $TYPE_RE } @$flash;
      };

      # Emit hook for further flexibility
      $app->plugins->emit_hook(
        before_notifications => $c, $notes
      );

      # Delete from stash
      delete $c->stash->{'notify.array'};

      # Nothing to do
      return '' unless $notes->size || @_;

      # Forward messages to notification center
      if (exists $engine{$e_type}) {

        my %rule;
        while ($param[-1] && index($param[-1], '-') == 0) {
          $rule{lc(substr(pop @param, 1))} = 1;
        };

        return $engine{$e_type}->notifications($c, $notes, \%rule, @param);
      }
      else {
        $c->app->log->error(qq{Unknown notification engine "$e_type"});
        return;
      };
    }
  );


  # Add hook for redirects
  $app->hook(
    after_dispatch => sub {
      my $c = shift;

      if ($c->res->is_redirect) {
        # Get notify array from stash
        my $notes = delete $c->stash->{'notify.array'};

        # Check flash notes
        if ($c->flash('n!.a')) {

          # Merge notes with flash
          if ($notes) {
            unshift @$notes, @{$c->flash('n!.a')};
          }

          # Get notes from flash
          else {
            $notes = $c->flash('n!.a');
          };
        };

        if ($notes) {
          $c->flash('n!.a' => $notes);
        };
      };
    });
};


1;


__END__