File Coverage

blib/lib/Mojolicious/Plugin/MoreUtilHelpers.pm

Criterion	Covered	Total	%
statement	99	100	99.0
branch	36	42	85.7
condition	24	32	75.0
subroutine	12	13	92.3
pod	1	1	100.0
total	172	188	91.4

package Mojolicious::Plugin::MoreUtilHelpers;

use Mojo::Base 'Mojolicious::Plugin';
use Mojo::Collection;
use Mojo::DOM;
use Mojo::Util;

use Lingua::EN::Inflect;

our $VERSION = '0.06';

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

    $app->helper(count => sub {
	my ($c, $item, $type) = @_;
	my $count = $item;
	return unless defined $item;

	my $tr    = sub { lc( (split /::/, ref(shift))[-1] ) };

	if(ref($item) eq 'ARRAY') {
	    $count = @$item;
	    $type  = $tr->($item->[0]) unless $type;
	}

	$type ||= $tr->($item);
	return "$count " . Lingua::EN::Inflect::PL($type, $count);
    });

    $app->helper(paragraphs => sub {
	my ($c, $text) = @_;
	return unless $text;

	my $html = join '', map $c->tag('p', $_), split /^\s*\015?\012/m, $text;
	return $c->b($html);
    });


    my $maxwords = $defaults->{maxwords};
    $app->helper(maxwords => sub {
	my $c    = shift;
	my $text = shift;
	my $n    = shift // $maxwords->{max};

	return $text unless $text and $n and $n > 0;

	my $omited = shift // $maxwords->{omit} // '...';
	my @words  = split /\s+/, $text;
	return $text unless @words > $n;

	$text = join ' ', @words[0..$n-1];

	if(@words > $n) {
	    $text =~ s/[[:punct:]]$//;
	    $text .= $omited;
	}

	return $text;
    });

    my $sanitize = $defaults->{sanitize};
    $app->helper(sanitize => sub {
	my $c    = shift;
	my $html = shift;
	return unless $html;

	my %options = @_;

	my (%tags, %attr);
	my $names = $options{tags} // $sanitize->{tags};
	@tags{@$names} = (1) x @$names if ref $names eq 'ARRAY';

	$names = $options{attr} // $sanitize->{attr};
	@attr{@$names} = (1) x @$names if ref $names eq 'ARRAY';

	my $doc = Mojo::DOM->new($html);
        if (! %tags) {
	    my $txt = $doc->all_text;
            $txt =~ s/\s+/ /g;
            $txt =~ s/^ //;
            $txt =~ s/ $//;
            return $txt;
        }

	for my $node (@{$doc->descendant_nodes}) {
	    if($node->tag && !$tags{ $node->tag }) {
		$node->strip;
		next;
	    }

	    if(%attr) {
		for my $name (keys %{$node->attr}) {
		    delete $node->attr->{$name} unless $attr{$name};
		}
	    }
	}

	return $c->b($doc->to_string);
    });

    $app->helper(trim_param => sub {
	my $c = shift;
	return unless @_;

	my $trim = sub {
	    my $name = shift;
	    my $vals = $c->every_param($name);

	    $c->param($name => @$vals == 1 ?
		      Mojo::Util::trim($vals->[0]) :
		      [ map Mojo::Util::trim($_), @$vals ]);
	};

	my %params;
	my $names = $c->req->params->names;
	@params{ @$names } = (1) x @$names;

	for my $name (@_) {
	    if(ref($name) ne 'Regexp') {
		$trim->($name);
		next;
	    }

	    for(keys %params) {
		next unless $_ =~ $name;

		$trim->($_);
		delete $params{$_};
	    }
	}
    });

    $app->helper(collection => sub {
	my $c = shift;
	my @data = ( @_ == 1 && ref($_[0]) eq 'ARRAY' ? @{$_[0]} : @_ );
	return Mojo::Collection->new(@data == 1 && !defined $data[0] ? () : @data );
    });

    if($defaults->{collection}->{patch}) {
	$app->helper(c => sub { shift->collection(@_) });
    }

}

1;

__END__