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