atom-tools 0.9.0 → 2.0.5

data/lib/atom/entry.rb

@@ -3,8 +3,37 @@ require "rexml/document"
 require "atom/element"
 require "atom/text"
 
+require 'atom/feed'
+
 module Atom
-  NS = "http://www.w3.org/2005/Atom"
+  # this is just a forward declaration since atom/entry includes atom/feed and vice-versa.
+  class Feed < Atom::Element # :nodoc:
+  end
+
+  class Source < Atom::Feed
+    is_atom_element :source
+
+    # TODO: this shouldn't be necessary, but on_init doesn't get inherited the
+    # way I would like it to.
+    @on_init = Atom::Feed.instance_variable_get '@on_init'
+  end
+
+  class Control < Atom::Element
+    attr_accessor :draft
+
+    is_element PP_NS, :control
+
+    on_parse [PP_NS, 'draft'] do |e,x|
+      e.set(:draft, x.text == 'yes')
+    end
+
+    on_build do |e,x|
+      unless (v = e.get(:draft)).nil?
+        el = e.append_elem(x, ['app', PP_NS], 'draft')
+        el.text = (v ? 'yes' : 'no')
+      end
+    end
+  end
 
   # An individual entry in a feed. As an Atom::Element, it can be
   # manipulated using accessors for each of its child elements. You
@@ -26,110 +55,55 @@ module Atom
   # each of which is an Array of its respective type and can be used
   # thusly:
   #
-  #   author = entry.authors.new
-  #   author.name = "Captain Kangaroo"
+  #   author = entry.authors.new :name => "Captain Kangaroo", :email => "kanga@example.net"
+  #
   class Entry < Atom::Element
+    is_atom_element :entry
+
     # the master list of standard children and the types they map to
-    element :id, String, true
-    element :title, Atom::Text, true
-    element :content, Atom::Content, true
-    
-    element :rights, Atom::Text
-    # element :source, Atom::Feed  # complicated, eg. serialization
-    
-    element :authors, Atom::Multiple(Atom::Author)
-    element :contributors, Atom::Multiple(Atom::Contributor)
-    
-    element :categories, Atom::Multiple(Atom::Category)
-    element :links, Atom::Multiple(Atom::Link)
-    
-    element :published, Atom::Time
-    element :updated, Atom::Time, true
-    
-    element :summary, Atom::Text
-
-    def initialize # :nodoc:
-      super "entry"
-     
-      # XXX I don't think I've ever actually used this
-      yield self if block_given?
-    end
+    atom_string :id
 
-    # parses XML fetched from +base+ into an Atom::Entry
-    def self.parse xml, base = ""
-      if xml.respond_to? :to_atom_entry
-        xml.to_atom_entry(base)
-      else
-        REXML::Document.new(xml.to_s).to_atom_entry(base)
-      end
-    end
+    atom_element :title, Atom::Title
+    atom_element :summary, Atom::Summary
+    atom_element :content, Atom::Content
 
-    def inspect # :nodoc:
-      "#<Atom::Entry id:'#{self.id}'>"
-    end
+    atom_element :rights, Atom::Rights
 
-    # declare that this entry has updated
-    def updated!
-      self.updated = Time.now
-    end
+    atom_element :source, Atom::Source
 
-    # categorize the entry based on a space-separated string
-    def tag_with string
-      return if string.nil?
+    atom_time :published
+    atom_time :updated
+    time ['app', PP_NS], :edited
 
-      string.split.each do |tag|
-        categories.new["term"] = tag
-      end
-    end
+    atom_elements :author, :authors, Atom::Author
+    atom_elements :contributor, :contributors, Atom::Contributor
 
-# XXX this needs a test suite before it can be trusted.
-=begin
-    # tests the entry's validity
-    def valid?
-      self.class.required.each do |element|
-        unless instance_variable_get "@#{element}"
-          return [ false, "required element atom:#{element} missing" ]
-        end
-      end
+    element ['app', PP_NS], :control, Atom::Control
 
-      if @authors.length == 0
-        return [ false, "required element atom:author missing" ]
-      end
+    include HasCategories
+    include HasLinks
 
-      alternates = @links.find_all do |link|
-        link["rel"] == "alternate"
-      end
+    atom_link :edit_url, :rel => 'edit'
 
-      unless @content or alternates
-          return [ false, "no atom:content or atom:link[rel='alternate']" ]
-      end
+    def inspect # :nodoc:
+      "#<Atom::Entry id:'#{self.id}'>"
+    end
 
-      alternates.each do |link|
-        if alternates.find do |x|
-          not x == link and 
-            x["type"] == link["type"] and 
-            x["hreflang"] == link["hreflang"]
-          end
-         
-          return [ false, 'more than one atom:link with a rel attribute value of "alternate" that has the same combination of type and hreflang attribute values.' ]
-        end
-      end
+    def draft
+      control and control.draft
+    end
 
-      type = @content["type"]
+    alias :draft? :draft
 
-      base64ed = (not ["", "text", "html", "xhtml"].member? type) and 
-        type.match(/^text\/.*/).nil? and  # not text
-        type.match(/.*[\+\/]xml$/).nil?   # not XML
+    def draft!
+      self.draft = true
+    end
 
-      if (@content["src"] or base64ed) and not summary
-        return [ false, "out-of-line or base64ed atom:content and no atom:summary" ]
+    def draft= is_draft
+      unless control
+        instance_variable_set '@control', Atom::Control.new
       end
-
-      true
+      control.draft = is_draft
     end
-=end
   end
 end
-
-# this is here solely so that you don't have to require it
-require "atom/xml"

data/lib/atom/feed.rb

@@ -5,8 +5,10 @@ require "atom/entry"
 require "atom/http"
 
 module Atom
-  class HTTPException < RuntimeError # :nodoc:
+  # this is just a forward declaration since atom/entry includes atom/feed and vice-versa.
+  class Entry < Atom::Element # :nodoc:
   end
+
   class FeedGone < RuntimeError # :nodoc:
   end
 
@@ -23,44 +25,47 @@ module Atom
   # generator:: the agent used to generate a feed
   # icon:: an IRI identifying an icon which visually identifies a feed (1:1 aspect ratio, looks OK small)
   # logo:: an IRI identifying an image which visually identifies a feed (2:1 aspect ratio)
-  # rights:: rights held in and over a feed (Atom::Text)  
+  # rights:: rights held in and over a feed (Atom::Text)
   #
-  # There are also +links+, +categories+, +authors+, +contributors+ 
+  # There are also +links+, +categories+, +authors+, +contributors+
   # and +entries+, each of which is an Array of its respective type and
   # can be used thusly:
   #
   #   entry = feed.entries.new
   #   entry.title = "blah blah blah"
+  #
   class Feed < Atom::Element
+    is_atom_element :feed
+
     attr_reader :uri
 
     # the Atom::Feed pointed to by link[@rel='previous']
     attr_reader :prev
     # the Atom::Feed pointed to by link[@rel='next']
     attr_reader :next
-   
+
     # conditional get information from the last fetch
     attr_reader :etag, :last_modified
 
-    element :id, String, true
-    element :title, Atom::Text, true
-    element :subtitle, Atom::Text
-   
-    element :updated, Atom::Time, true
+    atom_string :id
+    atom_element :title, Atom::Title
+    atom_element :subtitle, Atom::Subtitle
+
+    atom_time :updated
+
+    include HasLinks
+    include HasCategories
 
-    element :links, Atom::Multiple(Atom::Link)
-    element :categories, Atom::Multiple(Atom::Category)
+    atom_elements :author, :authors, Atom::Author
+    atom_elements :contributor, :contributors, Atom::Contributor
 
-    element :authors, Atom::Multiple(Atom::Author)
-    element :contributors, Atom::Multiple(Atom::Contributor)
+    atom_string :generator # XXX with uri and version attributes!
+    atom_string :icon
+    atom_string :logo
 
-    element :generator, String # XXX with uri and version attributes!
-    element :icon, String
-    element :logo, String
+    atom_element :rights, Atom::Rights
 
-    element :rights, Atom::Text
-    
-    element :entries, Atom::Multiple(Atom::Entry)
+    atom_elements :entry, :entries, Atom::Entry
 
     include Enumerable
 
@@ -68,15 +73,6 @@ module Atom
       "<#{@uri} entries: #{entries.length} title='#{title}'>"
     end
 
-    # parses XML fetched from +base+ into an Atom::Feed
-    def self.parse xml, base = ""
-      if xml.respond_to? :to_atom_entry
-        xml.to_atom_feed(base)
-      else
-        REXML::Document.new(xml.to_s).to_atom_feed(base)
-      end
-    end
-
     # Create a new Feed that can be found at feed_uri and retrieved
     # using an Atom::HTTP object http
     def initialize feed_uri = nil, http = Atom::HTTP.new
@@ -88,7 +84,7 @@ module Atom
         self.base = feed_uri
       end
 
-      super "feed"
+      super()
     end
 
     # iterates over a feed's entries
@@ -96,11 +92,15 @@ module Atom
       @entries.each &block
     end
 
+    def empty?
+      @entries.empty?
+    end
+
     # gets everything in the logical feed (could be a lot of stuff)
-    # (see <http://www.ietf.org/internet-drafts/draft-nottingham-atompub-feed-history-05.txt>)
+    # (see RFC 5005)
     def get_everything!
       self.update!
-  
+
       prev = @prev
       while prev
         prev.update!
@@ -128,18 +128,22 @@ module Atom
       end
     end
 
-    # like #merge, but in place 
+    # like #merge, but in place
     def merge! other_feed
-      [:id, :title, :subtitle, :updated, :rights].each { |p|
-        self.send("#{p}=", other_feed.send("#{p}"))
-      }
+      [:id, :title, :subtitle, :updated, :rights, :logo, :icon].each do |p|
+        if (v = other_feed.get(p))
+          set p, v
+        end
+      end
 
       [:links, :categories, :authors, :contributors].each do |p|
-        other_feed.send("#{p}").each do |e|
-          self.send("#{p}") << e
+        other_feed.get(p).each do |e|
+          get(p) << e
         end
       end
 
+      @extensions = other_feed.extensions
+
       merge_entries! other_feed
     end
 
@@ -149,22 +153,20 @@ module Atom
       feed = self.clone
 
       feed.merge! other_feed
-      
+
       feed
     end
 
     # fetches this feed's URL, parses the result and #merge!s
     # changes, new entries, &c.
+    #
+    # (note that this is different from Atom::Entry#updated!
     def update!
       raise(RuntimeError, "can't fetch without a uri.") unless @uri
-     
-      headers = {}
-      headers["If-None-Match"] = @etag if @etag
-      headers["If-Modified-Since"] = @last_modified if @last_modified
 
-      res = @http.get(@uri, headers)
+      res = @http.get(@uri, "Accept" => "application/atom+xml")
 
-      if res.code == "304"
+      if @etag and res['etag'] == @etag
         # we're already all up to date
         return self
       elsif res.code == "410"
@@ -172,44 +174,43 @@ module Atom
       elsif res.code != "200"
         raise Atom::HTTPException, "Unexpected HTTP response code: #{res.code}"
       end
-        
-      unless res.content_type.match(/^application\/atom\+xml/)
-        raise Atom::HTTPException, "Unexpected HTTP response Content-Type: #{res.content_type} (wanted application/atom+xml)"
-      end
 
-      @etag = res["Etag"] if res["Etag"]
-      @last_modified = res["Last-Modified"] if res["Last-Modified"]
+      # we'll be forgiving about feed content types.
+      res.validate_content_type(["application/atom+xml",
+                                  "application/xml",
+                                  "text/xml"])
+
+      @etag = res["ETag"] if res["ETag"]
 
       xml = res.body
 
       coll = REXML::Document.new(xml)
 
-      update_time = Time.parse(REXML::XPath.first(coll, "/atom:feed/atom:updated", { "atom" => Atom::NS } ).text)
+      update_el = REXML::XPath.first(coll, "/atom:feed/atom:updated", { "atom" => Atom::NS } )
 
-      # the feed hasn't been updated, don't bother
-      if self.updated and self.updated >= update_time
+      # the feed hasn't been updated, don't do anything.
+      if update_el and self.updated and self.updated >= Time.parse(update_el.text)
         return self
       end
 
-      coll = Atom::Feed.parse(coll, self.base.to_s)
+      coll = self.class.parse(coll.root, self.base.to_s)
       merge! coll
-     
-      link = coll.links.find { |l| l["rel"] = "next" and l["type"] == "application/atom+xml" }
-      if link
-        abs_uri = @uri + link["href"]
-        @next = Feed.new(abs_uri.to_s, @http)
+
+      if abs_uri = next_link
+        @next = self.class.new(abs_uri.to_s, @http)
       end
 
-      link = coll.links.find { |l| l["rel"] = "previous" and l["type"] == "application/atom+xml" } 
-      if link
-        abs_uri = @uri + link["href"]
-        @prev = Feed.new(abs_uri.to_s, @http)
+      if abs_uri = previous_link
+        @prev = self.class.new(abs_uri.to_s, @http)
       end
 
       self
     end
 
-    # adds an entry to this feed. if this feed already contains an 
+    atom_link :previous_link, :rel => 'previous'
+    atom_link :next_link, :rel => 'next'
+
+    # adds an entry to this feed. if this feed already contains an
     # entry with the same id, the newest one is used.
     def << entry
       existing = entries.find do |e|
@@ -224,6 +225,3 @@ module Atom
     end
   end
 end
-
-# this is here solely so you don't have to require it
-require "atom/xml"