atom-tools 0.9.0 → 0.9.1

data/lib/atom/service.rb

@@ -0,0 +1,170 @@
+require "uri"
+
+require "atom/http"
+require "atom/element"
+require "atom/collection"
+
+module Atom
+  PP_NS = "http://purl.org/atom/app#"
+  
+  class WrongNamespace < RuntimeError #:nodoc:
+  end
+  class WrongMimetype < RuntimeError # :nodoc:
+  end
+  class WrongResponse < RuntimeError # :nodoc:
+  end
+
+  # an Atom::Workspace has a #title (Atom::Text) and #collections, an Array of Atom::Collection s
+  class Workspace < Atom::Element
+    element :collections, Atom::Multiple(Atom::Collection)
+    element :title, Atom::Text
+
+    def self.parse(xml, base = "", http = Atom::HTTP.new) # :nodoc:
+      ws = Atom::Workspace.new("workspace")
+
+      rxml = if xml.is_a? REXML::Document
+        xml.root
+      elsif xml.is_a? REXML::Element
+        xml
+      else 
+        REXML::Document.new(xml)
+      end
+
+      xml.fill_text_construct(ws, "title")
+
+      REXML::XPath.match( rxml, 
+                          "./app:collection",
+                          {"app" => Atom::PP_NS} ).each do |col_el|
+        # absolutize relative URLs
+        url = base.to_uri + col_el.attributes["href"].to_uri
+       
+        coll = Atom::Collection.new(url, http)
+
+        # XXX this is a Text Construct, and should be parsed as such
+        col_el.fill_text_construct(coll, "title")
+
+        accepts = REXML::XPath.first( col_el,
+                                      "./app:accept",
+                                      {"app" => Atom::PP_NS} )
+        coll.accepts = (accepts ? accepts.text : "entry")
+        
+        ws.collections << coll
+      end
+
+      ws
+    end
+
+    def to_element # :nodoc:
+      root = REXML::Element.new "workspace" 
+
+      # damn you, REXML. Damn you and you bizarre handling of namespaces
+      title = self.title.to_element
+      title.name = "atom:title"
+      root << title
+
+      self.collections.each do |coll|
+        el = REXML::Element.new "collection"
+
+        el.attributes["href"] = coll.uri
+
+        title = coll.title.to_element
+        title.name = "atom:title"
+        el << title
+       
+        unless coll.accepts.nil?
+          accepts = REXML::Element.new "accepts"
+          accepts.text = coll.accepts
+          el << accepts
+        end
+
+        root << el
+      end
+
+      root
+    end
+  end
+
+  # Atom::Service represents an Atom Publishing Protocol service
+  # document. Its only child is #workspaces, which is an Array of 
+  # Atom::Workspace s
+  class Service < Atom::Element
+    element :workspaces, Atom::Multiple(Atom::Workspace)
+
+    # retrieves and parses an Atom service document.
+    def initialize(service_url = "", http = Atom::HTTP.new)
+      super("service")
+      
+      @http = http
+
+      return if service_url.empty?
+
+      base = URI.parse(service_url)
+
+      rxml = nil
+
+      res = @http.get(base)
+
+      unless res.code == "200" # XXX needs to handle redirects, &c.
+        raise WrongResponse, "service document URL responded with unexpected code #{res.code}"
+      end
+
+      unless res.content_type == "application/atomserv+xml"
+        raise WrongMimetype, "this isn't an atom service document!"
+      end
+
+      parse(res.body, base)
+    end
+ 
+    # parse a service document, adding its workspaces to this object
+    def parse xml, base = ""
+      rxml = if xml.is_a? REXML::Document
+        xml.root
+      elsif xml.is_a? REXML::Element
+        xml
+      else 
+        REXML::Document.new(xml)
+      end
+
+      unless rxml.root.namespace == PP_NS
+        raise WrongNamespace, "this isn't an atom service document!"
+      end
+
+      REXML::XPath.match( rxml, "/app:service/app:workspace", {"app" => Atom::PP_NS} ).each do |ws_el|
+        self.workspaces << Atom::Workspace.parse(ws_el, base, @http)
+      end
+
+      self
+    end
+
+    # serialize to a (namespaced) REXML::Document 
+    def to_xml
+      doc = REXML::Document.new
+      
+      root = REXML::Element.new "service"
+      root.add_namespace Atom::PP_NS
+      root.add_namespace "atom", Atom::NS
+
+      self.workspaces.each do |ws|
+        root << ws.to_element
+      end
+
+      doc << root
+      doc
+    end
+  end
+ 
+  class Entry
+    # 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
+  end
+end

data/lib/atom/text.rb

@@ -37,14 +37,27 @@ module Atom
       end
     end
 
-    # attepts to parse the content and return it as an array of REXML::Elements
+    # 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
+    # be converted to XHTML first.
     def xml
       if self["type"] == "xhtml"
         @content.children
       elsif self["type"] == "text"
         [self.to_s]
+      elsif self["type"] == "html"
+        begin
+          require "hpricot"
+        rescue
+          raise "Turning HTML content into XML requires Hpricot."
+        end
+
+        fixed = Hpricot(self.to_s, :xhtml_strict => true)
+        REXML::Document.new("<div>#{fixed}</div>").root.children
       else
-        # XXX - hpricot goes here?
+        # XXX check that @type is an XML mimetype and parse it
         raise "I haven't implemented this yet"
       end
     end

data/lib/atom/xml.rb

@@ -105,7 +105,7 @@ 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] = (URI.parse(top.base) + value).to_s
+            thing[name.to_s] = (top.base.to_uri + value).to_s
           elsif value
             thing[name.to_s] = value
           end

data/test/conformance/updated.rb

@@ -16,7 +16,8 @@ class TestUpdatedConformance < Test::Unit::TestCase
   
     # this is an insignificant change, 
     # (ie. atom:updated_1 == atom:updated_2),
-    # but that's for you to handle
+    #
+    # the update is applied, your application can handle that however it wants.
     feed.update!
     assert_equal "12 of 13 miner<b>s</b> survive mine collapse", feed.entries.first.content.to_s.strip
    

data/test/test_constructs.rb

@@ -2,11 +2,54 @@ require "test/unit"
 require "atom/entry"
 
 class ConstructTest < Test::Unit::TestCase
+  def test_text_construct_html_to_xml
+    begin
+      require "hpricot"
+    rescue
+      # hpricot isn't installed, just skip this test
+      puts "skipping hpricot tests"
+      return
+    end
+
+    entry = Atom::Entry.new
+
+html = <<END
+<p>Paragraph 1 contains <a href=http://example.org/>a link
+<p>This really is a horrendous mess.
+END
+
+    entry.content = html
+    entry.content["type"] = "html"
+
+    xhtml = entry.content.xml
+
+    # Hpricot is imperfect; for now I'll just test that it's parseable
+    assert_instance_of Array, xhtml
+    assert_instance_of REXML::Element, xhtml.first
+ 
+=begin
+    assert_equal 2, xhtml.length
+
+    first = xhtml.first
+    assert_equal "p", first.name
+    assert_equal 2, first.children.length
+
+    a = first.children.last
+    assert_equal "a", a.name
+    assert_equal "http://example.org/", a.attributes["href"]
+    assert_equal "a link", a.text
+
+    last = xhtml.last
+    assert_equal "p", last.name
+    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_nil entry.title
+    assert_equal "", entry.title.to_s 
 
     entry.title = "<3"
 

data/test/test_feed.rb

@@ -81,6 +81,32 @@ END
     assert_equal 1, feed.entries.length
   end
 
+  def test_media_types
+    c = proc do |c_t|
+      @s.mount_proc("/") do |req,res|
+        res.content_type = c_t
+        res.body = @test_feed
+
+        @s.stop
+      end
+      one_shot
+    end
+    
+    feed = Atom::Feed.new "http://localhost:#{@port}/"
+
+    # even if it looks like a feed, the server's word is law
+    c.call("text/plain")
+    assert_raise(Atom::HTTPException) { feed.update! }
+
+    # text/xml isn't the preferred mimetype, but we'll accept it
+    c.call("text/xml")
+    assert_nothing_raised { feed.update! }
+
+    # same goes for application/xml
+    # XXX c.call("application/xml")
+    # assert_nothing_raised { feed.update! }
+  end
+
   def test_conditional_get
     @s.mount_proc("/") do |req,res|
       assert_nil req["If-None-Match"]
@@ -124,5 +150,6 @@ END
     assert_equal 1, feed.entries.length
   end
 
+  # prepares the server for a single request
   def one_shot; Thread.new { @s.start }; end
 end

data/test/test_http.rb

@@ -1,7 +1,14 @@
+require "test/unit"
+
 require "atom/http"
 require "webrick"
 
 class AtomProtocolTest < Test::Unit::TestCase
+  REALM = "test authentication"
+  USER = "test_user"
+  PASS = "aoeuaoeu"
+  SECRET_DATA = "I kissed a boy once"
+
   def setup
     @http = Atom::HTTP.new
     @port = rand(1024) + 1024
@@ -11,13 +18,21 @@ class AtomProtocolTest < Test::Unit::TestCase
   end
 
   def test_parse_wwwauth
-    header = 'Basic realm="SokEvo"'
+    header = 'realm="SokEvo"'
    
-    # parse_wwwauth is a private method
-    auth_type, auth_params = @http.send :parse_wwwauth, header
+    params = @http.send :parse_quoted_wwwauth, header
+    assert_equal "SokEvo", params[:realm]
+
+    header = 'opaque="07UrfUiCYac5BbWJ", algorithm=MD5-sess, qop="auth", stale=TRUE, nonce="MDAx0Mzk", realm="test authentication"'
 
-    assert_equal "Basic", auth_type
-    assert_equal "SokEvo", auth_params["realm"]
+    params = @http.send :parse_wwwauth_digest, header
+
+    assert_equal "test authentication", params[:realm]
+    assert_equal "MDAx0Mzk", params[:nonce]
+    assert_equal true, params[:stale]
+    assert_equal "auth", params[:qop]
+    assert_equal "MD5-sess", params[:algorithm]
+    assert_equal "07UrfUiCYac5BbWJ", params[:opaque]
   end
 
   def test_GET
@@ -32,11 +47,11 @@ class AtomProtocolTest < Test::Unit::TestCase
 
     one_shot
 
-    res = get_root
+    get_root
     
-    assert_equal("200", res.code)
-    assert_equal("text/plain", res.content_type)
-    assert_equal("just junk", res.body)
+    assert_equal("200", @res.code)
+    assert_equal("text/plain", @res.content_type)
+    assert_equal("just junk", @res.body)
   end
 
   def test_GET_headers
@@ -48,39 +63,120 @@ class AtomProtocolTest < Test::Unit::TestCase
 
     one_shot
 
-    res = get_root("User-Agent" => "tester agent")
+    get_root("User-Agent" => "tester agent")
 
-    assert_equal("200", res.code)
+    assert_equal("200", @res.code)
   end
 
   def test_basic_auth
     @s.mount_proc("/") do |req,res|
-      WEBrick::HTTPAuth.basic_auth(req, res, "test authentication") do |u,p|
-        u == "test" and p == "pass"
+      WEBrick::HTTPAuth.basic_auth(req, res, REALM) do |u,p|
+        u == USER and p == PASS
       end
 
-      res.body = "sooper-secret!"
+      res.body = SECRET_DATA
       @s.stop
     end
 
     one_shot
-    
+   
+    # with no credentials
+    assert_raises(Atom::Unauthorized) { get_root }
+
+    @http.user = USER
+    @http.pass = "incorrect_password"
+
+    # with incorrect credentials
     assert_raises(Atom::Unauthorized) { get_root }
 
     @http.when_auth do |abs_url,realm|
       assert_equal "http://localhost:#{@port}/", abs_url 
-      assert_equal "test authentication", realm
+      assert_equal REALM, realm
 
-      ["test", "pass"]
+      [USER, PASS]
     end
     
     one_shot
   
+    get_root
+    assert_equal "200", @res.code 
+    assert_equal SECRET_DATA, @res.body 
+  end
+
+  def test_digest_auth
+    # a dummy userdb 
+    userdb = {}
+    userdb[USER] = PASS
+
+    def userdb.get_passwd(realm, user, reload)
+      Digest::MD5::hexdigest([user, realm, self[user]].join(":"))
+    end
+      
+    authenticator = WEBrick::HTTPAuth::DigestAuth.new(
+      :UserDB => userdb,
+      :Realm => REALM,
+      :Algorithm => "MD5"
+    )
+
+    @s.mount_proc("/") do |req,res|
+      authenticator.authenticate(req, res)
+      res.body = SECRET_DATA
+    end
+   
+    one_shot
+
+    # no credentials
+    assert_raises(Atom::Unauthorized) { get_root }
+
+    @http.user = USER
+    @http.pass = PASS
+
+    # correct credentials
     res = get_root
-    assert_equal("200", res.code)
-    assert_equal("sooper-secret!", res.body)
+    assert_equal SECRET_DATA, res.body
+
+    @s.stop
+  end
+
+  def test_wsse_auth
+    @s.mount_proc("/") do |req,res|
+      assert_equal 'WSSE profile="UsernameToken"', req["Authorization"]
+
+      xwsse = req["X-WSSE"]
+
+      p = @http.send :parse_quoted_wwwauth, xwsse
+
+      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
+      password_digest = [Digest::SHA1.digest(pd_string)].pack("m").chomp
+
+      assert_equal password_digest, p[:PasswordDigest]
+
+      res.body = SECRET_DATA
+      @s.stop
+    end
+
+    one_shot
+
+    @http.always_auth = :wsse
+    @http.user = USER
+    @http.pass = PASS
+    
+    get_root
+
+    assert_equal "200", @res.code 
+    assert_equal SECRET_DATA, @res.body
+  end
+
+  def get_root(*args)
+    @res = @http.get("http://localhost:#{@port}/", *args)
   end
 
-  def get_root(*args); @http.get("http://localhost:#{@port}/", *args); end
   def one_shot; Thread.new { @s.start }; end
 end