atom-tools 1.0.0 → 2.0.0

data/lib/atom/entry.rb

@@ -4,8 +4,61 @@ require "atom/element"
 require "atom/text"
 
 module Atom
-  NS = "http://www.w3.org/2005/Atom"
-  PP_NS = "http://www.w3.org/2007/app"
+  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
+
+  module HasCategories
+    def HasCategories.included(klass)
+      klass.atom_elements :category, :categories, Atom::Category
+    end
+
+    # categorize the entry with each of an array or a space-separated
+    #   string
+    def tag_with(tags, delimiter = ' ')
+      return if not tags or tags.empty?
+
+      tag_list = unless tags.is_a?(String)
+                   tags
+                 else
+                   tags = tags.split(delimiter)
+                   tags.map! { |t| t.strip }
+                   tags.reject! { |t| t.empty? }
+                   tags.uniq
+                 end
+
+      tag_list.each do |tag|
+        unless categories.any? { |c| c.term == tag }
+          categories.new :term => tag
+        end
+      end
+    end
+  end
+
+  module HasLinks
+    def HasLinks.included(klass)
+      klass.atom_elements :link, :links, Atom::Link
+    end
+
+    def find_link(criteria)
+      self.links.find do |l|
+        criteria.all? { |k,v| l.send(k) == v }
+      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
@@ -27,168 +80,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
+    atom_string :id
 
-    element :rights, Atom::Text
-    # element :source, Atom::Feed  # complicated, eg. serialization
+    atom_element :title, Atom::Title
+    atom_element :summary, Atom::Summary
+    atom_element :content, Atom::Content
 
-    element :authors, Atom::Multiple(Atom::Author)
-    element :contributors, Atom::Multiple(Atom::Contributor)
+    atom_element :rights, Atom::Rights
 
-    element :categories, Atom::Multiple(Atom::Category)
-    element :links, Atom::Multiple(Atom::Link)
+    # element :source, Atom::Feed  # XXX complicated, eg. serialization
 
-    element :published, Atom::Time
-    element :updated, Atom::Time, true
+    atom_time :published
+    atom_time :updated
+    time ['app', PP_NS], :edited
 
-    element :summary, Atom::Text
+    atom_elements :author, :authors, Atom::Author
+    atom_elements :contributor, :contributors, Atom::Contributor
 
-    def initialize # :nodoc:
-      super "entry"
+    element ['app', PP_NS], :control, Atom::Control
 
-      # XXX I don't think I've ever actually used this
-      yield self if block_given?
-    end
+    include HasCategories
+    include HasLinks
 
-    # parses XML into an Atom::Entry
-    #
-    # +base+ is the absolute URI the document was fetched from
-    # (if there is one)
-    def self.parse xml, base = ""
-      if xml.respond_to? :to_atom_entry
-        xml.to_atom_entry(base)
-      elsif xml.respond_to? :read
-        self.parse(xml.read)
-      else
-        begin
-          REXML::Document.new(xml.to_s).to_atom_entry(base)
-        rescue REXML::ParseException
-          raise Atom::ParseError
-        end
-      end
-    end
+    atom_link :edit_url, :rel => 'edit'
 
     def inspect # :nodoc:
       "#<Atom::Entry id:'#{self.id}'>"
     end
 
-    # declare that this entry has updated.
-    #
-    # (note that this is different from Atom::Feed#update!)
-    def updated!
-      self.updated = Time.now
-    end
-
-    # categorize the entry with each of an array or a space-separated
-    #   string
-    def tag_with tags
-      return unless tags
-
-      (tags.is_a?(String) ? tags.split : tags).each do |tag|
-        categories.new["term"] = tag
-      end
-    end
-
-    # the @href of an entry's link[@rel="edit"]
-    def edit_url
-      begin
-        edit_link = self.links.find do |link|
-          link["rel"] == "edit"
-        end
-
-        edit_link["href"]
-      rescue
-        nil
-      end
-    end
-
     def draft
-      elem = REXML::XPath.first(extensions, "app:control/app:draft", {"app" => PP_NS})
-
-      elem and elem.text == "yes"
+      control and control.draft
     end
 
-    def draft= is_draft
-      nses = {"app" => PP_NS}
-      draft_e = REXML::XPath.first(extensions, "app:control/app:draft", nses)
-      control_e = REXML::XPath.first(extensions, "app:control", nses)
+    alias :draft? :draft
 
-      if is_draft and not draft
-        unless draft_e
-          unless control_e
-            control_e = REXML::Element.new("control")
-            control_e.add_namespace PP_NS
-
-            extensions << control_e
-          end
-
-          draft_e = REXML::Element.new("draft")
-          control_e << draft_e
-        end
-
-        draft_e.text = "yes"
-      elsif not is_draft and draft
-        draft_e.remove
-        control_e.remove if control_e.elements.empty?
-      end
-
-      is_draft
+    def draft!
+      self.draft = true
     end
 
-# 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
-
-      if @authors.length == 0
-        return [ false, "required element atom:author missing" ]
-      end
-
-      alternates = @links.find_all do |link|
-        link["rel"] == "alternate"
-      end
-
-      unless @content or alternates
-          return [ false, "no atom:content or atom:link[rel='alternate']" ]
-      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
-
-      type = @content["type"]
-
-      base64ed = (not ["", "text", "html", "xhtml"].member? type) and
-        type.match(/^text\/.*/).nil? and  # not text
-        type.match(/.*[\+\/]xml$/).nil?   # not XML
-
-      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

@@ -21,44 +21,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
 
@@ -66,21 +69,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)
-      elsif xml.respond_to? :read
-        self.parse(xml.read)
-      else
-        begin
-          REXML::Document.new(xml.to_s).to_atom_feed(base)
-        rescue REXML::ParseException
-          raise Atom::ParseError
-        end
-      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
@@ -92,7 +80,7 @@ module Atom
         self.base = feed_uri
       end
 
-      super "feed"
+      super()
     end
 
     # iterates over a feed's entries
@@ -108,7 +96,7 @@ module Atom
     # (see <http://www.ietf.org/internet-drafts/draft-nottingham-atompub-feed-history-05.txt>)
     def get_everything!
       self.update!
-  
+
       prev = @prev
       while prev
         prev.update!
@@ -136,18 +124,22 @@ module Atom
       end
     end
 
-    # like #merge, but in place 
+    # like #merge, but in place
     def merge! other_feed
-      [:id, :title, :subtitle, :updated, :rights, :logo, :icon].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
 
@@ -157,7 +149,7 @@ module Atom
       feed = self.clone
 
       feed.merge! other_feed
-      
+
       feed
     end
 
@@ -167,15 +159,10 @@ module Atom
     # (note that this is different from Atom::Entry#updated!
     def update!
       raise(RuntimeError, "can't fetch without a uri.") unless @uri
-     
-      headers = {}
-      headers["Accept"] = "application/atom+xml"
-      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"
@@ -183,14 +170,13 @@ module Atom
       elsif res.code != "200"
         raise Atom::HTTPException, "Unexpected HTTP response code: #{res.code}"
       end
-       
+
       # we'll be forgiving about feed content types.
-      res.validate_content_type(["application/atom+xml", 
-                                  "application/xml", 
+      res.validate_content_type(["application/atom+xml",
+                                  "application/xml",
                                   "text/xml"])
 
       @etag = res["ETag"] if res["ETag"]
-      @last_modified = res["Last-Modified"] if res["Last-Modified"]
 
       xml = res.body
 
@@ -203,25 +189,24 @@ module Atom
         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|
@@ -236,6 +221,3 @@ module Atom
     end
   end
 end
-
-# this is here solely so you don't have to require it
-require "atom/xml"