File Coverage

blib/lib/Types/Mojo.pm

Criterion	Covered	Total	%
statement	32	32	100.0
branch			n/a
condition			n/a
subroutine	11	11	100.0
pod			n/a
total	43	43	100.0

package Types::Mojo;

# ABSTRACT: Types related to Mojo

use v5.10;

use strict;
use warnings;

use Type::Library
   -base,
   -declare => qw( MojoCollection MojoFile MojoFileList MojoUserAgent MojoURL );

use Type::Utils -all;
use Types::Standard -types;

use Mojo::File;
use Mojo::Collection;
use Mojo::URL;
use Scalar::Util qw(blessed);
use List::Util qw(first);

Type::Utils::extends(qw/Types::Standard/);

our $VERSION = 0.04;

my $meta = __PACKAGE__->meta;

$meta->add_type(
    name => 'MojoCollection',
    parent => InstanceOf['Mojo::Collection'],
    constraint_generator => sub {
        return $meta->get_type('MojoCollection') if !@_;

        my $type  = $_[0];
        my $check = $meta->get_type( $_[0] );

        return sub {
            return if !blessed $_ and $_->isa('Mojo::Collection');

            my $fail = $_->first( sub {
                !$check->( $_ );
            });

            !$fail;
        };
    },
    coercion_generator => sub {
        my ($parent, $child, $param) = @_;
        return $parent->coercion;
    },
    #inline_generator => sub {},
    #deep_explanation => sub {},
);

coerce MojoCollection,
    from ArrayRef, via { Mojo::Collection->new( @{$_} ) }
;

class_type MojoUserAgent, { class => 'Mojo::UserAgent' };

class_type MojoFile, { class => 'Mojo::File' };

coerce MojoFile,
    from Str, via { Mojo::File->new( $_ ) }
;

declare MojoFileList,
    as MojoCollection[MojoFile];

coerce MojoFileList,
    from MojoCollection[Str],
        via {
            my $new = $_->map( sub { Mojo::File->new($_) } );
            $new;
        },
    from ArrayRef[Str],
        via {
            my @list = @{$_};
            Mojo::Collection->new( map{ Mojo::File->new( $_ ) } @list );
        },
    from ArrayRef[MojoFile],
        via {
            Mojo::Collection->new( @{ $_ } );
        }
;

$meta->add_type(
    name => 'MojoURL',
    parent => InstanceOf['Mojo::URL'],
    constraint_generator => sub {
        return $meta->get_type('MojoURL') if !@_;

        my $type  = $_[0];
        my ($scheme, $secure) = $type =~ m{(.*?)(s\?)?\z};

        return sub {
            return if !blessed $_ and $_->isa('Mojo::URL');

            return 1 if $_->scheme eq $scheme;
            return 1 if $secure && $_->scheme eq $scheme . 's';

            return;
        };
    },
    coercion_generator => sub {
        my ($parent, $child, $param) = @_;
        return $parent->coercion;
    },
);

coerce MojoURL,
    from Str, via { Mojo::URL->new( $_ ) }
;

coerce MojoCollection,
    from ArrayRef, via { Mojo::Collection->new( @{$_} ) }
;

__PACKAGE__->meta->make_immutable;

1;

__END__