atom-tools 0.9.2 → 0.9.3

data/lib/atom/service.rb

@@ -5,8 +5,6 @@ require "atom/element"
 require "atom/collection"
 
 module Atom
-  PP_NS = "http://purl.org/atom/app#"
-  
   class WrongNamespace < RuntimeError #:nodoc:
   end
   class WrongResponse < RuntimeError # :nodoc:

data/lib/atom/text.rb

@@ -4,11 +4,19 @@ module XHTML
   NS = "http://www.w3.org/1999/xhtml"
 end
 
-module Atom 
+module Atom
   # An Atom::Element representing a text construct.
-  # It has a single attribute, "type", which accepts values
-  # "text", "html" and "xhtml"
-
+  # It has a single attribute, "type", which specifies how to interpret
+  # the element's content. Different types are:
+  #
+  # text:: a plain string, without any markup (default)
+  # html:: a chunk of HTML
+  # xhtml:: a chunk of *well-formed* XHTML
+  #
+  # You should set this attribute appropriately after you set a Text
+  # element (entry.content, entry.title or entry.summary).
+  #
+  # This content of this element can be retrieved in different formats, see #html and #xml
   class Text < Atom::Element
     attrb :type
 
@@ -16,19 +24,24 @@ module Atom
       @content = value
       @content ||= "" # in case of nil
       self["type"] = "text"
-      
+
       super name
     end
 
+    # convenient, but not overly useful. see #html instead.
     def to_s
-      if self["type"] == "xhtml" 
+      if self["type"] == "xhtml"
         @content.children.to_s
       else
         @content.to_s
       end
     end
 
-    # returns a string suitable for dumping into an HTML document
+    # returns a string suitable for dumping into an HTML document.
+    #   (or nil if that's impossible)
+    #
+    # if you're storing the content of a Text construct, you probably
+    # want this representation.
     def html
       if self["type"] == "xhtml" or self["type"] == "html"
         to_s
@@ -40,7 +53,7 @@ module Atom
     # attempts to parse the content of this element as XML and return it
     # as an array of REXML::Elements.
     #
-    # If this self["type"] is "html" and Hpricot is installed, it will
+    # If self["type"] is "html" and Hpricot is installed, it will
     # be converted to XHTML first.
     def xml
       if self["type"] == "xhtml"
@@ -83,7 +96,7 @@ module Atom
 
       super(key, value)
     end
-    
+
     def to_element # :nodoc:
       e = super
 
@@ -106,18 +119,19 @@ module Atom
 
       e
     end
-    
+
     private
+    # converts @content based on the value of self["type"]
     def convert_contents e
       if self["type"] == "xhtml"
         @content
       elsif self["type"] == "text" or self["type"].nil?
         REXML::Text.normalize(@content.to_s)
       elsif self["type"] == "html"
-        @content.to_s
+        @content.to_s.gsub(/&/, "&amp;")
       end
     end
-    
+
     def valid_type? type
       ["text", "xhtml", "html"].member? type
     end
@@ -154,6 +168,14 @@ module Atom
   class Content < Atom::Text
     attrb :src
 
+    def html
+      if self["src"]
+        ""
+      else
+        super
+      end
+    end
+
     private
     def valid_type? type
       super or type.match(/\//)

data/lib/atom/xml.rb

@@ -28,11 +28,22 @@ module REXML # :nodoc: all
       end
     end
    
-    def get_extensions
+    def copy_extensions(coll)
       # XXX also look for attributes
-      children.find_all { |child| child.respond_to? :namespace and child.namespace != Atom::NS }
+      children.find_all do |child| 
+        child.respond_to? :namespace and child.namespace != Atom::NS 
+      end.each do |elem|
+        e = elem.dup
+
+        # because namespaces might be defined on parents
+        unless e.prefix.empty?
+          e.add_namespace e.prefix, e.namespace
+        end
+
+        coll << e
+      end
     end
-   
+
     # get the text content of a descendant element in the Atom namespace
     def get_atom_text name
       elem = get_atom_element name
@@ -54,14 +65,14 @@ module REXML # :nodoc: all
 
       self.attributes[attr]
     end
-   
+
     def fill_text_construct(entry, name)
       text = get_atom_element(name)
       if text
         type = text.ns_attr("type")
         src = text.ns_attr("src")
 
-        if src and name == :content 
+        if src and name == :content
           # the only content is out of line
           entry.send( "#{name}=".to_sym, "")
           entry.send(name.to_sym)["src"] = src
@@ -74,10 +85,10 @@ module REXML # :nodoc: all
           # content is the serialized content of the <div> wrapper
           entry.send( "#{name}=".to_sym, div )
         else
-          raw = text.text
+          raw = text.text || ""
           entry.send( "#{name}=", raw )
         end
-      
+
         if text.attributes["xml:base"]
           entry.send(name.to_sym).base = text.attributes["xml:base"]
         end
@@ -91,7 +102,7 @@ module REXML # :nodoc: all
     def fill_elem_element(top, kind)
       each_atom_element(kind) do |elem|
         person = top.send("#{kind}s".to_sym).new
-     
+
         ["name", "uri", "email"].each do |name|
           person.send("#{name}=".to_sym, elem.get_atom_text(name))
         end
@@ -105,7 +116,11 @@ module REXML # :nodoc: all
         thing.class.attrs.each do |name,req|
           value = elem.ns_attr name.to_s
           if value and name == :href
-            thing[name.to_s] = (top.base.to_uri + value).to_s
+            begin
+              thing[name.to_s] = (top.base.to_uri + value).to_s
+            rescue URI::BadURIError
+              raise "Document contains relative URIs and no xml:base. You must pass a base URI to #parse()"
+            end
           elsif value
             thing[name.to_s] = value
           end
@@ -145,10 +160,7 @@ module REXML # :nodoc: all
         fill_attr_element(entry, v, k)
       end
       
-      # extension elements
-      get_extensions.each do |elem|
-        entry.extensions << elem.dup # otherwise they get removed from the doc
-      end
+      copy_extensions(entry.extensions)
 
       entry
     end
@@ -189,10 +201,7 @@ module REXML # :nodoc: all
         feed << elem.to_atom_entry(feed.base)
       end
 
-      get_extensions.each do |elem|
-        # have to duplicate them, or they'll get removed from the doc
-        feed.extensions << elem.dup
-      end
+      copy_extensions(feed.extensions)
 
       feed
     end

data/lib/atom/yaml.rb

@@ -62,36 +62,51 @@ module Atom
     def to_yaml_type # :nodoc:
       '!necronomicorp.com,2006/entry'
     end
- 
+
+    def to_yaml( opts = {} ) # :nodoc:
+      YAML::quick_emit( object_id, opts ) do |out|
+        out.map( taguri, to_yaml_style ) do |map|
+          self.to_yaml_properties.each do |m|
+            map.add( m[1..-1], instance_variable_get( m ) )
+          end
+          map.add("draft", true) if self.draft
+        end
+      end
+    end
+
     # parses an Atom::Entry from YAML
     def self.from_yaml yaml
       hash = if yaml.kind_of?(Hash); yaml else YAML.load(yaml); end
 
       entry = Atom::Entry.new
 
-      entry.title   = hash["title"]
-      entry.summary = hash["summary"]
-     
-      elem_constructs = {"authors" => entry.authors, "contributors" => entry.contributors, "links" => entry.links, "categories" => entry.categories}
+      ["id", "published", "updated", "title", "summary", "draft"].each do |name|
+        entry.send("#{name}=".to_sym, hash[name])
+      end
+
+      elem_constructs = {"authors" => entry.authors,
+                         "contributors" => entry.contributors,
+                         "links" => entry.links,
+                         "categories" => entry.categories}
 
       elem_constructs.each do |type,ary|
         hash[type] ||= []
-        
+
         hash[type].each do |yelem|
           elem = ary.new
 
           elem.class.attrs.each do |attrb,req|
             elem[attrb.to_s] = yelem[attrb.to_s]
           end
-    
+
           elem.class.elements.each do |name,kind,req|
             elem.send("#{name}=".to_sym, yelem[name.to_s])
           end
         end
       end
 
-      # this adds more categories, and could cause conflicts
       entry.tag_with hash["tags"]
+
       entry.content = hash["content"]
       entry.content["type"] = hash["type"] if hash["type"]
 

data/test/test_constructs.rb

@@ -44,12 +44,12 @@ END
     assert_equal "This really is a horrendous mess.", last.text
 =end
   end
-  
+
   def test_text_construct_text
     entry = Atom::Entry.new
 
     assert_nil entry.title
-    assert_equal "", entry.title.to_s 
+    assert_equal "", entry.title.to_s
 
     entry.title = "<3"
 
@@ -124,6 +124,20 @@ END
     assert_equal("", entry.content.to_s)
   end
 
+  def test_multiple
+    entry = Atom::Entry.new
+
+    link = Atom::Link.new
+    link["href"] = "http://example.org/"
+
+    assert_raises(ArgumentError) { entry.authors << "test" }
+    assert_raises(ArgumentError) { entry.authors << link }
+    
+    entry.links << link
+
+    assert_equal 1, entry.links.length
+  end
+
   require "date"
   def test_date_construct
     today = Date.today

data/test/test_general.rb

@@ -46,30 +46,43 @@ class AtomTest < Test::Unit::TestCase
     assert_has_category(xml, "tags")
   end
 
-  def test_snarf_yaml
-    yaml = """title: testing YAML
+  def test_devour_yaml
+    time = Time.parse "2007-01-18T12:37:46Z"
+
+    yaml = <<END
+title: testing YAML
+draft: yes
+
 authors:
 - name: Mr. Safe
   uri: http://example.com/
+
 links:
 - href: http://atomenabled.org/
-content: not much here\
-"""
+
+content: not much here
+
+updated: #{time.iso8601}
+END
 
     entry = Atom::Entry.from_yaml(yaml)
 
     assert_equal("testing YAML", entry.title.to_s)
 
+    assert entry.draft
+
     assert_equal(1, entry.authors.length)
     assert_equal("Mr. Safe", entry.authors.first.name)
     assert_equal("http://example.com/", entry.authors.first.uri)
-    
+
     assert_equal(1, entry.links.length)
     assert_equal("http://atomenabled.org/", entry.links.first["href"])
 
     assert_equal("not much here", entry.content.to_s)
+
+    assert_equal(time, entry.updated)
   end
- 
+
   def assert_has_category xml, term
     assert_not_nil(REXML::XPath.match(xml, "/entry/category[@term = #{term}]"))
   end
@@ -85,10 +98,10 @@ content: not much here\
   def get_elements entry
     xml = entry.to_xml
 
-    assert_equal(entry.to_s, Atom::Entry.parse(xml).to_s) 
-    
+    assert_equal(entry.to_s, Atom::Entry.parse(xml).to_s)
+
     base_check xml
-    
+
     xml
   end
 

data/test/test_http.rb

@@ -150,24 +150,31 @@ class AtomHTTPTest < Test::Unit::TestCase
     # no credentials
     assert_raises(Atom::Unauthorized) { get_root }
 
+    # incorrect credentials
     @http.user = USER
     @http.pass = "incorrect_password"
 
     one_shot
 
-    # incorrect credentials
     assert_raises(Atom::Unauthorized) { get_root }
 
+    # no credentials, fancy block
+    @http.when_auth do nil end
+
+    one_shot
+
+    assert_raises(Atom::Unauthorized) { get_root }
+
+    # correct credentials, fancy block
     @http.when_auth do |abs_url,realm|
       assert_equal "http://localhost:#{@port}/", abs_url 
       assert_equal REALM, realm
 
       [USER, PASS]
     end
-   
+
     one_shot
-    
-    # correct credentials
+
     assert_authenticates
   end
 
@@ -218,11 +225,8 @@ class AtomHTTPTest < Test::Unit::TestCase
       assert_equal USER, p[:Username]
       assert_match /^UsernameToken /, xwsse
 
-      # un-base64 in preparation for SHA1-ing
-      nonce = p[:Nonce].unpack("m").first
-
       # Base64( SHA1( Nonce + CreationTimestamp + Password ) )
-      pd_string = nonce + p[:Created] + PASS
+      pd_string = p[:Nonce] + p[:Created] + PASS
       password_digest = [Digest::SHA1.digest(pd_string)].pack("m").chomp
 
       assert_equal password_digest, p[:PasswordDigest]

data/test/test_xml.rb

@@ -6,12 +6,12 @@ require "atom/service"
 class AtomTest < Test::Unit::TestCase
   def test_text_type_text
     entry = get_entry
-    
+
     entry.title = "Atom-drunk pirates run amok!"
     assert_equal("text", entry.title["type"])
 
     xml = get_elements entry
-    
+
     assert_equal("Atom-drunk pirates run amok!", xml.elements["/entry/title"].text)
   end
 
@@ -34,17 +34,26 @@ class AtomTest < Test::Unit::TestCase
     entry.title["type"] = "xhtml"
 
     xml = get_elements entry
-    
+
     base_check xml
 
     assert_equal(XHTML::NS, xml.elements["/entry/title/div"].namespace)
     assert_equal("run amok", xml.elements["/entry/title/div/em"].text)
   end
 
+  def test_html_text_with_entities
+    entry = get_entry
+
+    entry.title = "Atoms discovered to be smaller than 1&mu;m"
+    entry.title["type"] = "html"
+
+    assert_match(/&amp;mu;/, entry.to_s)
+  end
+
   def test_author
     entry = get_entry
     a = entry.authors.new
-    
+
     a.name= "Brendan Taylor"
     a.uri = "http://necronomicorp.com/blog/"
 
@@ -111,6 +120,32 @@ class AtomTest < Test::Unit::TestCase
     assert_equal("http://purl.org/", xml.elements["/entry/test"].namespace)
   end
 
+  def test_roundtrip_extension
+    entry = Atom::Entry.parse("<entry xmlns='http://www.w3.org/2005/Atom' xmlns:nil='http://necronomicorp.com/nil'><nil:ext/></entry>")
+
+    assert_match(/xmlns:nil='http:\/\/necronomicorp.com\/nil'/, entry.to_s)
+  end
+
+  def test_app_control
+    entry = get_entry
+
+    assert !entry.draft
+
+    assert_nil get_elements(entry).elements["/entry/control"]
+
+    entry.draft = true
+
+    xml = get_elements entry
+
+    assert_equal Atom::PP_NS, xml.elements["/entry/control"].namespace
+    assert_equal Atom::PP_NS, xml.elements["/entry/control/draft"].namespace
+    assert_equal "yes", xml.elements["/entry/control/draft"].text
+
+    entry2 = Atom::Entry.parse xml
+
+    assert entry.draft
+  end
+
   def test_extensive_enty_parsing
 str = '<entry xmlns="http://www.w3.org/2005/Atom">
   <title>Atom draft-07 snapshot</title>
@@ -141,10 +176,10 @@ str = '<entry xmlns="http://www.w3.org/2005/Atom">
 </entry>'
 
     entry = Atom::Entry.parse(str)
-  
+
     assert_equal("Atom draft-07 snapshot", entry.title.to_s)
     assert_equal("tag:example.org,2003:3.2397", entry.id)
-  
+
     assert_equal(Time.parse("2005-07-31T12:29:29Z"), entry.updated)
     assert_equal(Time.parse("2003-12-13T08:29:29-04:00"), entry.published)
 
@@ -162,16 +197,16 @@ str = '<entry xmlns="http://www.w3.org/2005/Atom">
     assert_equal("Mark Pilgrim", entry.authors.first.name)
     assert_equal("http://example.org/", entry.authors.first.uri)
     assert_equal("f8dy@example.com", entry.authors.first.email)
-    
+
     assert_equal(2, entry.contributors.length)
     assert_equal("Sam Ruby", entry.contributors.first.name)
     assert_equal("Joe Gregorio", entry.contributors.last.name)
-  
+
     assert_equal("xhtml", entry.content["type"])
-   
+
     assert_match("<p><i>[Update: The Atom draft is finished.]</i></p>", 
                  entry.content.to_s)
-    
+
     assert_equal("http://diveintomark.org/", entry.content.base)
     # XXX unimplemented
 #    assert_equal("en", entry.content.lang)
@@ -239,7 +274,7 @@ END
     # XXX unimplemented
     # assert_equal("http://www.example.com/", feed.generator["uri"])
     # assert_equal("1.0", feed.generator["version"])
-   
+
     assert_equal(1, feed.entries.length)
     assert_equal "Atom draft-07 snapshot", feed.entries.first.title.to_s
   end
@@ -259,6 +294,18 @@ END
     assert_equal "<p>...&amp; as a result of this, I submit that <var>pi</var> &lt; 4", entry.summary.html.strip
   end
 
+  def test_parse_goofy_entries
+xml = <<END
+<entry xmlns="http://www.w3.org/2005/Atom">
+<content type="html"></content>
+</entry>
+END
+
+    entry = Atom::Entry.parse(xml)
+
+    assert_equal("", entry.content.to_s)
+  end
+
   def test_parse_outofline_content
     xml = <<END
 <entry xmlns="http://www.w3.org/2005/Atom">
@@ -267,7 +314,7 @@ Summary doesn't have src.
   </summary>
 </entry>
 END
-  
+
     entry = Atom::Entry.parse xml
 
     assert_raises(RuntimeError) { entry.summary["src"] }
@@ -291,7 +338,7 @@ END
     entry = Atom::Entry.new
 
     entry.base = "http://necronomicorp.com/nil"
-  
+
     base = get_elements(entry).root.attributes["xml:base"]
     assert_equal "http://necronomicorp.com/nil", base
 
@@ -304,11 +351,11 @@ END
   def test_relative_base
     base_url = "http://www.tbray.org/ongoing/ongoing.atom"
     doc = "<entry xmlns='http://www.w3.org/2005/Atom' xml:base='When/200x/2006/10/11/'/>"
-    
+
     entry = Atom::Entry.parse(doc, base_url)
     assert_equal("http://www.tbray.org/ongoing/When/200x/2006/10/11/", entry.base)
   end
-  
+
   def test_edit_url
     doc = <<END
 <entry xmlns="http://www.w3.org/2005/Atom"><link rel="edit"/></entry>
@@ -324,7 +371,7 @@ END
     entry = Atom::Entry.parse(doc)
 
     assert_nil(entry.edit_url)
-    
+
     doc = <<END
 <entry xmlns="http://www.w3.org/2005/Atom">
   <link rel="edit" href="http://necronomicorp.com/nil"/>
@@ -336,7 +383,6 @@ END
     assert_equal("http://necronomicorp.com/nil", entry.edit_url)
   end
 
-
   def assert_has_category xml, term
     assert_not_nil(REXML::XPath.match(xml, "/entry/category[@term = #{term}]"))
   end
@@ -353,10 +399,10 @@ END
   def get_elements entry
     xml = entry.to_xml
 
-    assert_equal(entry.to_s, Atom::Entry.parse(xml).to_s) 
-    
+    assert_equal(entry.to_s, Atom::Entry.parse(xml).to_s)
+
     base_check xml
-    
+
     xml
   end