File Coverage

blib/lib/YADA.pm

Criterion	Covered	Total	%
statement	25	27	92.5
branch			n/a
condition			n/a
subroutine	9	9	100.0
pod			n/a
total	34	36	94.4

package YADA;
# ABSTRACT: "Yet Another Download Accelerator": alias for AnyEvent::Net::Curl::Queued


use feature qw(switch);
use strict;
use utf8;
use warnings qw(all);

use Digest::SHA qw(sha256_base64);
use Moo;
use MooX::Types::MooseLike::Base qw(
    ArrayRef
    HashRef
    Object
    Str
);
use URI;

extends 'AnyEvent::Net::Curl::Queued';

use YADA::Worker;

no if ($] >= 5.017010), warnings => q(experimental);

our $VERSION = '0.047'; # VERSION

has _queue      => (
    is          => 'ro',
    isa         => ArrayRef[Object],
    default     => sub { [] },
);

has _unique_url => (
    is          => 'ro',
    isa         => HashRef[Str],
    default     => sub { {} },
);

# serious DWIMmery ahead!

## no critic (RequireArgUnpacking)
around append   => sub { _dwim(append => @_) };
around prepend  => sub { _dwim(prepend => @_) };

sub _dwim {
    my $type = shift;
    my $orig = shift;
    my $self = shift;

    if (1 < scalar @_) {
        my (%init, @url);
        for my $arg (@_) {
            for (ref $arg) {
                when ($_ eq '' or m{^URI::}x) {
                    push @url, $arg;
                } when ('ARRAY') {
                    push @url, @{$arg};
                } when ('CODE') {
                    unless (exists $init{on_finish}) {
                        $init{on_finish} = $arg;
                    } else {
                        @init{qw{on_init on_finish}} = ($init{on_finish}, $arg);
                    }
                } when ('HASH') {
                    $init{$_} = $arg->{$_}
                        for keys %{$arg};
                }
            }
        }

        for my $url (@url) {
            $url = URI->new($url);
            next
                if not $self->allow_dups
                and ++$self->_unique_url->{sha256_base64($url->canonical->as_string)} > 1;

            my %copy = %init;
            $copy{initial_url} = $url;
            if ($type eq q(append)) {
                push    @{$self->_queue} => [ $type => \%copy ];
            } elsif ($type eq q(prepend)) {
                unshift @{$self->_queue} => [ $type => \%copy ];
            }
        }
    } else {
        $orig->($self => @_);
    }

    return $self;
}

sub _shift_worker {
    my ($self) = @_;
    my $queue = $self->_queue;
    my $max = $self->max << 2;
    while (@{$queue} and ($self->count < $max)) {
        my ($type, $params) = @{shift @{$queue}};
        $self->$type(sub { YADA::Worker->new($params) });
    }
    return;
}

before wait => sub { shift->_shift_worker };


1;

__END__