File Coverage

blib/lib/Mojo/Feed/Item.pm

Criterion	Covered	Total	%
statement	23	26	88.4
branch	4	4	100.0
condition	2	2	100.0
subroutine	6	9	66.6
pod	2	2	100.0
total	37	43	86.0

package Mojo::Feed::Item;
use Mojo::Base '-base';
use Mojo::Util qw( trim );

use HTTP::Date 'str2time';

use Mojo::Feed::Item::Enclosure;

use overload
  bool     => sub {1},
  '""'     => sub { shift->to_string },
  fallback => 1;


has [qw(title link content id description guid published author)];

has tags => sub {
  shift->dom->find('category, dc\:subject')
    ->map(sub { $_[0]->text || $_[0]->attr('term') });
};

has 'dom';
has feed => undef, weak => 1;

has summary => sub { shift->description };

my %selector = (
  content => ['content', 'content|encoded', 'xhtml|body', 'description'],
  description => ['description', 'summary'],
  published   => [
    'published', 'pubDate', 'dc|date', 'created',
    'issued',    'updated', 'modified'
  ],
  author => ['author > name', '|author', 'atom|author', 'dc|creator'],
  id     => ['id',     'guid', 'link'],
  title => ['title'],
  link  => ['link'],
  guid  => ['guid'],
);

foreach my $k (keys %selector) {
  has $k => sub {
    my $self = shift;
    for my $selector (@{$selector{$k}}) {
      if (my $p = $self->dom->at($selector, %{$self->feed->namespaces})) {
        if ($k eq 'author' && $p->at('name')) {
          return trim $p->at('name')->text;
        }
        my ($text) = grep $_, map trim($_), grep $_, $p->text, $p->content;
        $text ||= '';
        if ($k eq 'published') {
          return str2time($text);
        }
        return $text;
      }
    }
    return;
  };
}

has enclosures => sub {
  my $self = shift;
  my @enclosures;
  $self->dom->find('enclosure')->each(sub {
    push @enclosures, $_;
  });
  $self->dom->find('link')->each(sub {
    my $l = shift;
    if ($l->attr('href') && $l->attr('rel') && $l->attr('rel') eq 'enclosure') {
      push @enclosures, $l;
    }
  });
  return Mojo::Collection->new(
    map { Mojo::Feed::Item::Enclosure->new(dom => $_) } @enclosures);
};

has link => sub {

  # let's handle links seperately, because ATOM loves these buggers:
  my $link;
  shift->dom->find('link')->each(sub {
    my $l = shift;
    if ($l->attr('href')
      && (!$l->attr('rel') || $l->attr('rel') eq 'alternate'))
    {
      $link = trim $l->attr('href');
    }
    else {
      if ($l->text =~ /\w+/) {
        $link = trim $l->text;    # simple link
      }
    }
  });
  return $link;
};

sub to_string {
  shift->dom->to_string;
}

sub to_hash {
  my $self = shift;
  my $hash = {map { $_ => '' . ($self->$_ || '') } keys %selector};
  if ($self->enclosures->size) {
    $hash->{'enclosures'} = $self->enclosures->map('to_hash')->to_array;
  }
  if ($self->tags->size) {
    $hash->{'tags'} = $self->tags->to_array;
  }
  return $hash;
}

1;

__END__