lib/XML/Feed/Atom.pm

   1 # $Id: Atom.pm 1958 2006-08-14 05:31:27Z btrott $
   2
   3 package XML::Feed::Atom;
   4 use strict;
   5
   6 use base qw( XML::Feed );
   7 use XML::Atom::Feed;
   8 use XML::Atom::Util qw( iso2dt );
   9 use List::Util qw( first );
  10 use DateTime::Format::W3CDTF;
  11
  12 use XML::Atom::Entry;
  13 XML::Atom::Entry->mk_elem_accessors(qw( lat long ), ['http://www.w3.org/2003/01/geo/wgs84_pos#']);
  14
  15 sub init_empty {
  16     my ($feed, %args) = @_;
  17     $args{'Version'} ||= '1.0';
  18
  19     $feed->{atom} = XML::Atom::Feed->new(%args);
  20     $feed;
  21 }
  22
  23 sub init_string {
  24     my $feed = shift;
  25     my($str) = @_;
  26     if ($str) {
  27         $feed->{atom} = XML::Atom::Feed->new(Stream => $str)
  28             or return $feed->error(XML::Atom::Feed->errstr);
  29     }
  30     $feed;
  31 }
  32
  33 sub format { 'Atom' }
  34
  35 sub title { shift->{atom}->title(@_) }
  36 sub link {
  37     my $feed = shift;
  38     if (@_) {
  39         $feed->{atom}->add_link({ rel => 'alternate', href => $_[0],
  40                                   type => 'text/html', });
  41     } else {
  42         my $l = first { !defined $_->rel || $_->rel eq 'alternate' } $feed->{atom}->link;
  43         $l ? $l->href : undef;
  44     }
  45 }
  46
  47 sub self_link {
  48     my $feed = shift;
  49     if (@_) {
  50         my $uri = shift;
  51         $feed->{atom}->add_link({type => "application/atom+xml", rel => "self", href => $uri});
  52         return $uri;
  53     }
  54     else
  55     {
  56         my $l =
  57             first
  58             { !defined $_->rel || $_->rel eq 'self' }
  59             $feed->{atom}->link;
  60             ;
  61
  62         return $l ? $l->href : undef;
  63     }
  64 }
  65
  66 sub description { shift->{atom}->tagline(@_) }
  67 sub copyright   { shift->{atom}->copyright(@_) }
  68 sub language    { shift->{atom}->language(@_) }
  69 sub generator   { shift->{atom}->generator(@_) }
  70 sub id          { shift->{atom}->id(@_) }
  71 sub updated     { shift->{atom}->updated(@_) }
  72 sub add_link    { shift->{atom}->add_link(@_) }
  73
  74 sub author {
  75     my $feed = shift;
  76     if (@_ && $_[0]) {
  77         my $person = XML::Atom::Person->new(Version => 1.0);
  78         $person->name($_[0]);
  79         $feed->{atom}->author($person);
  80     } else {
  81         $feed->{atom}->author ? $feed->{atom}->author->name : undef;
  82     }
  83 }
  84
  85 sub modified {
  86     my $feed = shift;
  87     if (@_) {
  88         $feed->{atom}->modified(DateTime::Format::W3CDTF->format_datetime($_[0]));
  89     } else {
  90         return iso2dt($feed->{atom}->modified) if $feed->{atom}->modified;
  91         return iso2dt($feed->{atom}->updated)  if $feed->{atom}->updated;
  92         return undef;
  93     }
  94 }
  95
  96 sub entries {
  97     my @entries;
  98     for my $entry ($_[0]->{atom}->entries) {
  99         push @entries, XML::Feed::Entry::Atom->wrap($entry);
 100     }
 101
 102     @entries;
 103 }
 104
 105 sub add_entry {
 106     my $feed  = shift;
 107     my $entry = shift || return;
 108     $entry    = $feed->_convert_entry($entry);
 109     $feed->{atom}->add_entry($entry->unwrap);
 110 }
 111
 112 sub as_xml { $_[0]->{atom}->as_xml }
 113
 114 package XML::Feed::Entry::Atom;
 115 use strict;
 116
 117 use base qw( XML::Feed::Entry );
 118 use XML::Atom::Util qw( iso2dt );
 119 use XML::Feed::Content;
 120 use XML::Atom::Entry;
 121 use List::Util qw( first );
 122
 123 sub init_empty {
 124     my $entry = shift;
 125     $entry->{entry} = XML::Atom::Entry->new(Version => 1.0);
 126     1;
 127 }
 128
 129 sub title { shift->{entry}->title(@_) }
 130 sub source { shift->{entry}->source(@_) }
 131 sub updated { shift->{entry}->updated(@_) }
 132
 133 sub link {
 134     my $entry = shift;
 135     if (@_) {
 136         $entry->{entry}->add_link({ rel => 'alternate', href => $_[0],
 137                                     type => 'text/html', });
 138     } else {
 139         my $l = first { !defined $_->rel || $_->rel eq 'alternate' } $entry->{entry}->link;
 140         $l ? $l->href : undef;
 141     }
 142 }
 143
 144 sub summary {
 145     my $entry = shift;
 146     if (@_) {
 147                 my %param;
 148                 if (ref($_[0]) eq 'XML::Feed::Content') {
 149                         %param = (Body => $_[0]->body);
 150                 } else {
 151                          %param = (Body => $_[0]);
 152                 }
 153                 $entry->{entry}->summary(XML::Atom::Content->new(%param, Version => 1.0));
 154     } else {
 155                 my $s = $entry->{entry}->summary;
 156         # map Atom types to MIME types
 157         my $type = ($s && ref($s) eq 'XML::Feed::Content') ? $s->type : undef;
 158         if ($type) {
 159             $type = 'text/html'  if $type eq 'xhtml' || $type eq 'html';
 160             $type = 'text/plain' if $type eq 'text';
 161         }
 162                 my $body = $s;
 163                 if (defined $s && ref($s) eq 'XML::Feed::Content') {
 164                         $body = $s->body;
 165                 }
 166         XML::Feed::Content->wrap({ type => $type,
 167                                    body => $body });
 168     }
 169 }
 170
 171 my %types = (
 172         'text/xhtml' => 'xhtml',
 173         'text/html'  => 'html',
 174         'text/plain' => 'text',
 175 );
 176
 177 sub content {
 178     my $entry = shift;
 179     if (@_) {
 180         my %param;
 181         if (ref($_[0]) eq 'XML::Feed::Content') {
 182                         if (defined $_[0]->type && defined $types{$_[0]->type}) {
 183                     %param = (Body => $_[0]->body, Type => $types{$_[0]->type});
 184                         } else {
 185                     %param = (Body => $_[0]->body);
 186                         }
 187         } else {
 188             %param = (Body => $_[0]);
 189         }
 190         $entry->{entry}->content(XML::Atom::Content->new(%param, Version => 1.0));
 191     } else {
 192         my $c = $entry->{entry}->content;
 193
 194         # map Atom types to MIME types
 195         my $type = $c ? $c->type : undef;
 196         if ($type) {
 197             $type = 'text/html'  if $type eq 'xhtml' || $type eq 'html';
 198             $type = 'text/plain' if $type eq 'text';
 199         }
 200
 201         XML::Feed::Content->wrap({ type => $type,
 202                                    body => $c ? $c->body : undef });
 203     }
 204 }
 205
 206 sub category {
 207     my $entry = shift;
 208     my $ns = XML::Atom::Namespace->new(dc => 'http://purl.org/dc/elements/1.1/');
 209     if (@_) {
 210         $entry->{entry}->add_category({ term => $_[0] });
 211     } else {
 212         my $category = $entry->{entry}->category;
 213         my @return = $category ? ($category->label || $category->term) : $entry->{entry}->getlist($ns, 'subject');
 214         return wantarray? @return : $return[0];
 215     }
 216 }
 217
 218 sub author {
 219     my $entry = shift;
 220     if (@_ && $_[0]) {
 221         my $person = XML::Atom::Person->new(Version => 1.0);
 222         $person->name($_[0]);
 223         $entry->{entry}->author($person);
 224     } else {
 225         $entry->{entry}->author ? $entry->{entry}->author->name : undef;
 226     }
 227 }
 228
 229 sub id { shift->{entry}->id(@_) }
 230
 231 sub issued {
 232     my $entry = shift;
 233     if (@_) {
 234         $entry->{entry}->issued(DateTime::Format::W3CDTF->format_datetime($_[0])) if $_[0];
 235     } else {
 236         $entry->{entry}->issued ? iso2dt($entry->{entry}->issued) : undef;
 237     }
 238 }
 239
 240 sub modified {
 241     my $entry = shift;
 242     if (@_) {
 243         $entry->{entry}->modified(DateTime::Format::W3CDTF->format_datetime($_[0])) if $_[0];
 244     } else {
 245         return iso2dt($entry->{entry}->modified) if $entry->{entry}->modified;
 246         return iso2dt($entry->{entry}->updated)  if $entry->{entry}->updated;
 247         return undef;
 248     }
 249 }
 250
 251 sub lat {
 252     my $entry = shift;
 253     if (@_) {
 254    $entry->{entry}->lat($_[0]) if $_[0];
 255     } else {
 256    $entry->{entry}->lat;
 257     }
 258 }
 259
 260 sub long {
 261     my $entry = shift;
 262     if (@_) {
 263    $entry->{entry}->long($_[0]) if $_[0];
 264     } else {
 265    $entry->{entry}->long;
 266     }
 267 }
 268
 269 1;