lib/XML/Feed/Format/Atom.pm

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