Fix mixing and matching of RSS and Atom

[catagits/XML-Feed.git] / lib / XML / Feed / Atom.pm

diff --git a/lib/XML/Feed/Atom.pm b/lib/XML/Feed/Atom.pm
index 29fc2b0..d6fa522 100644 (file)
--- a/lib/XML/Feed/Atom.pm
+++ b/lib/XML/Feed/Atom.pm
@@ -1,4 +1,4 @@
-# $Id: Atom.pm 1955 2006-08-02 05:59:58Z btrott $
+# $Id: Atom.pm 1958 2006-08-14 05:31:27Z btrott $
 
 package XML::Feed::Atom;
 use strict;
@@ -9,9 +9,14 @@ use XML::Atom::Util qw( iso2dt );
 use List::Util qw( first );
 use DateTime::Format::W3CDTF;
 
+use XML::Atom::Entry;
+XML::Atom::Entry->mk_elem_accessors(qw( lat long ), ['http://www.w3.org/2003/01/geo/wgs84_pos#']);
+
 sub init_empty {
-    my $feed = shift;
-    $feed->{atom} = XML::Atom::Feed->new;
+    my ($feed, %args) = @_;
+    $args{'Version'} ||= '1.0';
+    
+    $feed->{atom} = XML::Atom::Feed->new(%args);
     $feed;
 }
 
@@ -38,15 +43,38 @@ sub link {
         $l ? $l->href : undef;
     }
 }
+
+sub self_link {
+    my $feed = shift;
+    if (@_) {
+        my $uri = shift;
+        $feed->{atom}->add_link({type => "application/atom+xml", rel => "self", href => $uri});
+        return $uri;
+    } 
+    else
+    {
+        my $l =
+            first
+            { !defined $_->rel || $_->rel eq 'self' }
+            $feed->{atom}->link;
+            ;
+
+        return $l ? $l->href : undef;
+    }
+}
+
 sub description { shift->{atom}->tagline(@_) }
 sub copyright   { shift->{atom}->copyright(@_) }
 sub language    { shift->{atom}->language(@_) }
 sub generator   { shift->{atom}->generator(@_) }
+sub id          { shift->{atom}->id(@_) }
+sub updated     { shift->{atom}->updated(@_) }
+sub add_link    { shift->{atom}->add_link(@_) }
 
 sub author {
     my $feed = shift;
     if (@_ && $_[0]) {
-        my $person = XML::Atom::Person->new;
+        my $person = XML::Atom::Person->new(Version => 1.0);
         $person->name($_[0]);
         $feed->{atom}->author($person);
     } else {
@@ -59,21 +87,25 @@ sub modified {
     if (@_) {
         $feed->{atom}->modified(DateTime::Format::W3CDTF->format_datetime($_[0]));
     } else {
-        iso2dt($feed->{atom}->modified);
+        return iso2dt($feed->{atom}->modified) if $feed->{atom}->modified;
+        return iso2dt($feed->{atom}->updated)  if $feed->{atom}->updated;
+        return undef;
     }
 }
 
-sub entries { 
+sub entries {
     my @entries;
     for my $entry ($_[0]->{atom}->entries) {
         push @entries, XML::Feed::Entry::Atom->wrap($entry);
     }
+
     @entries;
 }
 
 sub add_entry {
-    my $feed = shift;
-    my($entry) = @_;
+    my $feed  = shift;
+    my $entry = shift || return;
+    $entry    = $feed->_convert_entry($entry);
     $feed->{atom}->add_entry($entry->unwrap);
 }
 
@@ -90,11 +122,14 @@ use List::Util qw( first );
 
 sub init_empty {
     my $entry = shift;
-    $entry->{entry} = XML::Atom::Entry->new;
+    $entry->{entry} = XML::Atom::Entry->new(Version => 1.0);
     1;
 }
 
 sub title { shift->{entry}->title(@_) }
+sub source { shift->{entry}->source(@_) }
+sub updated { shift->{entry}->updated(@_) }
+
 sub link {
     my $entry = shift;
     if (@_) {
@@ -109,27 +144,61 @@ sub link {
 sub summary {
     my $entry = shift;
     if (@_) {
-        $entry->{entry}->summary(ref($_[0]) eq 'XML::Feed::Content' ?
-            $_[0]->body : $_[0]);
+               my %param;
+               if (ref($_[0]) eq 'XML::Feed::Content') {
+                       %param = (Body => $_[0]->body);
+               } else {
+                        %param = (Body => $_[0]);
+               }
+               $entry->{entry}->summary(XML::Atom::Content->new(%param, Version => 1.0));
     } else {
-        XML::Feed::Content->wrap({ type => 'text/html',
-                                   body => $entry->{entry}->summary });
+               my $s = $entry->{entry}->summary;
+        # map Atom types to MIME types
+        my $type = ($s && ref($s) eq 'XML::Feed::Content') ? $s->type : undef;
+        if ($type) {
+            $type = 'text/html'  if $type eq 'xhtml' || $type eq 'html';
+            $type = 'text/plain' if $type eq 'text';
+        }
+               my $body = $s;  
+               if (defined $s && ref($s) eq 'XML::Feed::Content') {
+                       $body = $s->body;
+               }
+        XML::Feed::Content->wrap({ type => $type,
+                                   body => $body });
     }
 }
 
+my %types = (
+       'text/xhtml' => 'xhtml',
+       'text/html'  => 'html',
+       'text/plain' => 'text',
+);
+
 sub content {
     my $entry = shift;
     if (@_) {
         my %param;
         if (ref($_[0]) eq 'XML::Feed::Content') {
-            %param = (Body => $_[0]->body, Type => $_[0]->type || 'text/html');
+                       if (defined $_[0]->type && defined $types{$_[0]->type}) {
+                   %param = (Body => $_[0]->body, Type => $types{$_[0]->type});
+                       } else {
+                   %param = (Body => $_[0]->body);
+                       }
         } else {
-            %param = (Body => $_[0], Type => 'text/html');
+            %param = (Body => $_[0]);
         }
-        $entry->{entry}->content(XML::Atom::Content->new(%param));
+        $entry->{entry}->content(XML::Atom::Content->new(%param, Version => 1.0));
     } else {
         my $c = $entry->{entry}->content;
-        XML::Feed::Content->wrap({ type => $c ? $c->type : undef,
+
+        # map Atom types to MIME types
+        my $type = $c ? $c->type : undef;
+        if ($type) {
+            $type = 'text/html'  if $type eq 'xhtml' || $type eq 'html';
+            $type = 'text/plain' if $type eq 'text';
+        }
+
+        XML::Feed::Content->wrap({ type => $type,
                                    body => $c ? $c->body : undef });
     }
 }
@@ -138,16 +207,18 @@ sub category {
     my $entry = shift;
     my $ns = XML::Atom::Namespace->new(dc => 'http://purl.org/dc/elements/1.1/');
     if (@_) {
-        $entry->{entry}->set($ns, 'subject', $_[0]);
+        $entry->{entry}->add_category({ term => $_[0] });
     } else {
-        $entry->{entry}->get($ns, 'subject');
+        my $category = $entry->{entry}->category;
+        my @return = $category ? ($category->label || $category->term) : $entry->{entry}->getlist($ns, 'subject');
+        return wantarray? @return : $return[0];
     }
 }
 
 sub author {
     my $entry = shift;
     if (@_ && $_[0]) {
-        my $person = XML::Atom::Person->new;
+        my $person = XML::Atom::Person->new(Version => 1.0);
         $person->name($_[0]);
         $entry->{entry}->author($person);
     } else {
@@ -171,7 +242,27 @@ sub modified {
     if (@_) {
         $entry->{entry}->modified(DateTime::Format::W3CDTF->format_datetime($_[0])) if $_[0];
     } else {
-        $entry->{entry}->modified ? iso2dt($entry->{entry}->modified) : undef;
+        return iso2dt($entry->{entry}->modified) if $entry->{entry}->modified;
+        return iso2dt($entry->{entry}->updated)  if $entry->{entry}->updated;
+        return undef;
+    }
+}
+
+sub lat {
+    my $entry = shift;
+    if (@_) {
+   $entry->{entry}->lat($_[0]) if $_[0];
+    } else {
+   $entry->{entry}->lat;
+    }
+}
+
+sub long {
+    my $entry = shift;
+    if (@_) {
+   $entry->{entry}->long($_[0]) if $_[0];
+    } else {
+   $entry->{entry}->long;
     }
 }