File Coverage

blib/lib/Mojo/Feed/Item.pm

Criterion	Covered	Total	%
statement	49	55	89.0
branch	17	20	85.0
condition	11	13	84.6
subroutine	9	11	81.8
pod	2	2	100.0
total	88	101	87.1

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 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', 'atom|author', 'dc|creator'],
  id     => ['id',     'guid', 'link'],
  title => ['title'],
  link  => ['link']
);

sub _get_selector {
  my ($self, $k) = @_;
  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;
    }
  }
};

sub _set_selector {
  my ($self, $k, $val) = @_;
  for my $selector (@{$selector{$k}}) {
    if (my $p = $self->dom->at($selector, %{$self->feed->namespaces})) {
      if ($k eq 'author' && $p->at('name')) {
        return $p->at('name')->content($val);
      }
      if ($k eq 'published') {
        return $p->content(Mojo::Date->new($val)->to_datetime());  # let's pretend we're all OK with Atom dates
      }
      return $p->content($val);
    }
  }
  # still here? I guess the element is missing, so add it?
  # THIS is another reason to move being feed-type specific:
  if ($k eq 'author') {
    return $self->dom->append_content($self->dom->new_tag('author', $val));
  }
  return $self->dom->append_content($self->dom->new_tag($selector{$k}[0], $val));
};



foreach my $k (keys %selector) {
  has $k => sub { return shift->_get_selector($k) || undef }
}

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 {
  my $self = shift;
  foreach my $k (keys %selector) {
    if ($self->$k && $self->$k ne $self->_get_selector($k)) {
      # write it to the DOM:
        $self->_set_selector($k, $self->$k);
    }
  }
  $self->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__