File Coverage

blib/lib/Mojolicious/Plugin/Util/RandomString.pm

Criterion	Covered	Total	%
statement	49	53	92.4
branch	28	32	87.5
condition	14	15	93.3
subroutine	5	5	100.0
pod	1	1	100.0
total	97	106	91.5

package Mojolicious::Plugin::Util::RandomString;
use Mojo::Base 'Mojolicious::Plugin';
use Session::Token;

our $VERSION = '0.08_1';

our (%generator, %setting, %default, %param);
our $read_config;
our $ok = 1;

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

  $ok--;

  if (ref $param ne 'HASH') {
    $mojo->log->fatal(__PACKAGE__ . ' expects a hash reference');
    return;
  };

  if ($param) {
    $param{$_} = $param->{$_} foreach keys %$param;
  };


  # Load parameter from Config file
  unless ($read_config) {
    if (my $config_param = $mojo->config('Util-RandomString')) {
      %param =  ( %$config_param, %param );
    };
    $read_config = 1;
  };


  # Reseed on fork
  Mojo::IOLoop->timer(
    0 => sub {
      my %created = ();

      # Create generators by param
      foreach (keys %param) {

        # Named generator
        if (ref $param{$_} && ref $param{$_} eq 'HASH') {

          next if $created{$_};

          # Construct object
          unless ($generator{$_} = Session::Token->new(
            %{ $param{$_} }
          )) {

            # Unable to construct object
            $mojo->log->fatal(qq!Unable to create generator for "$_"!);
            next;
          };
          $setting{$_} = { %{$param{$_}} };
          $created{$_} = 1;
        }

        # Default parameter
        else {
          $default{$_} = $param{$_};
        };
      };

      # Plugin registered
      $ok++;

      # Create default generator
      unless (exists $generator{default}) {
        $generator{default} = Session::Token->new( %default );
      };
    });


  # Establish 'random_string' helper
  $mojo->helper(
    random_string => sub {
      my $c = shift;
      my $gen = $_[0];

      # One tick for loop until the plugin is registered
      Mojo::IOLoop->one_tick until Mojo::IOLoop->is_running || $ok > 0;

      # Generate from generator
      unless ($_[1]) {

        # Generator doesn't exist
        if ($gen && !exists $generator{$gen}) {
          $c->app->log->warn(qq!RandomString generator "$gen" is unknown!);
          return '';
        };

        # Get from generator
        return $generator{$gen || 'default'}->get;
      };

      $gen = @_ % 2 ? shift : 'default';

      # Overwrite configuration
      my %overwrite = @_;

      if (exists $overwrite{entropy}) {
        $overwrite{length} //= undef;
      }
      elsif (exists $overwrite{length}) {
        $overwrite{entropy} //= undef;
      };

      # Take default configuration
      if ($gen eq 'default') {
        return Session::Token->new(%default, %overwrite)->get;
      }

      # Overwrite specific configuration
      elsif ($setting{ $gen }) {
        return Session::Token->new( %{ $setting{ $gen } }, %overwrite)->get;
      };

      # Generator is unknown
      $c->app->log->warn(qq!RandomString generator "$gen" is unknown!);
      return '';
    }
  ) unless exists $mojo->renderer->helpers->{random_string};
};


1;


__END__