File Coverage

blib/lib/Mojo/Feed/Reader.pm

Criterion	Covered	Total	%
statement	68	71	95.7
branch	36	44	81.8
condition	9	14	64.2
subroutine	14	15	93.3
pod	3	3	100.0
total	130	147	88.4

package Mojo::Feed::Reader;
use Mojo::Base -base;

use Mojo::UserAgent;
use Mojo::Feed;
use Mojo::File 'path';
use Mojo::Util 'decode', 'trim';
use Carp qw(carp croak);
use Scalar::Util qw(blessed);

has charset => 'UTF-8';

has ua            => sub { Mojo::UserAgent->new };

sub parse {
    my ( $self, $xml, $charset ) = @_;
    return undef unless ($xml);
    my ( $body, $source, $url, $file, $feed );
    if ( $body = $self->_from_string($xml) ) {
        $feed = Mojo::Feed->new( body => $body );
    }
    elsif ( $file = $self->_from_file($xml) ) {
        $feed = Mojo::Feed->new( file => $file );
    }
    elsif ( $url = $self->_from_url($xml) ) {
        $feed = Mojo::Feed->new( url => $url, ua => $self->ua );
    }
    else {
        croak "unknown argument $xml";
    }
    $feed->charset($charset) if ($charset);
    return ( $feed->is_valid ) ? $feed : undef;
}

sub _from_string {
    my ( $self, $xml ) = @_;
    my $str = ( !ref $xml ) ? $xml : ( ref $xml eq 'SCALAR' ) ? $$xml : '';
    return ( $str =~ /^\s*\
}

sub _from_url {
    my ( $self, $xml ) = @_;
    my $url =
        ( blessed $xml && $xml->isa('Mojo::URL') ) ? $xml->clone()
      : ( $xml =~ /^https?\:/ ) ? Mojo::URL->new("$xml")
      :                           undef;
    return $url;
}

sub _from_file {
    my ( $self, $xml ) = @_;
    my $file =
        ( ref $xml )
      ? ( blessed $xml && $xml->can('slurp') )
          ? $xml
          : undef
      : ( -r "$xml" ) ? Mojo::File->new($xml)
      :                 undef;
    return $file;
}

# discover - get RSS/Atom feed URL from argument.
# Code adapted to use Mojolicious from Feed::Find by Benjamin Trott
# Any stupid mistakes are my own
sub discover {
    my ( $self, $url ) = @_;

    #  $self->ua->max_redirects(5)->connect_timeout(30);
    return $self->ua->get_p($url)
      ->catch( sub { my ($err) = shift; croak "Connection Error: $err" } )
      ->then(
        sub {
            my ($tx) = @_;
            if ( $tx->res->is_success && $tx->res->code == 200 ) {
                my $feed = Mojo::Feed->new(url => $tx->req->url);
                return $feed->url if ($feed->is_feed_content_type($tx->res->headers->content_type));
                my @feeds = $feed->find_feed_links($tx->res);
                return @feeds if (@feeds);
                $feed->body($tx->res->body);
                $feed->charset($tx->res->content->charset) if ($tx->res->content->charset);
                return $feed->url if ($feed->is_valid);
            }
            return;
        }
      );
}

sub parse_opml {
    my ( $self, $opml_file ) = @_;
    my $opml_str = decode $self->charset,
      ( ref $opml_file )
      ? $opml_file->slurp
      : Mojo::File->new($opml_file)->slurp;
    my $d = Mojo::DOM->new->parse($opml_str);
    my ( %subscriptions, %categories );
    for my $item ( $d->find(q{outline})->each ) {
        my $node = $item->attr;
        if ( !defined $node->{xmlUrl} ) {
            my $cat = $node->{title} || $node->{text};
            $categories{$cat} =
              $item->children('[xmlUrl]')->map( 'attr', 'xmlUrl' );
        }
        else {    # file by RSS URL:
            $subscriptions{ $node->{xmlUrl} } = $node;
        }
    }

    # assign categories
    for my $cat ( keys %categories ) {
        for my $rss ( $categories{$cat}->each ) {
            next
              unless ( $subscriptions{$rss} )
              ;    # don't auto-vivify for empty "categories"
            $subscriptions{$rss}{'categories'} ||= [];
            push @{ $subscriptions{$rss}{'categories'} }, $cat;
        }
    }
    return ( values %subscriptions );
}

1;
__END__