atom-tools 0.9.0

data/lib/atom/http.rb

@@ -0,0 +1,132 @@
+require "net/http"
+require 'uri'
+
+module URI # :nodoc: all
+  class Generic; def to_uri; self; end; end
+end
+
+class String # :nodoc:
+  def to_uri; URI.parse(self); end
+end
+
+module Atom
+  UA = "atom-tools 0.9.0"
+  class Unauthorized < RuntimeError # :nodoc:
+  end
+
+  # An object which handles the details of HTTP - particularly
+  # authentication and caching (neither of which are fully implemented).
+  #
+  # This object can be used on its own, or passed to an Atom::App,
+  # Atom::Collection or Atom::Feed, where it will be used for requests.
+  # 
+  # All its HTTP methods return a Net::HTTPResponse
+  class HTTP
+    # used by the default #when_auth
+    attr_accessor :user, :pass
+
+    def initialize # :nodoc:
+      @get_auth_details = lambda do |abs_url, realm|
+        if @user and @pass
+          [@user, @pass]
+        else
+          nil
+        end
+      end
+    end
+
+    # GETs an url
+    def get url, headers = {}
+      http_request(url, Net::HTTP::Get, nil, headers)
+    end
+  
+    # POSTs body to an url
+    def post url, body, headers = {}
+      http_request(url, Net::HTTP::Post, body, headers)
+    end
+
+    # PUTs body to an url
+    def put url, body, headers = {}
+      http_request(url, Net::HTTP::Put, body, headers)
+    end
+
+    # DELETEs to url
+    def delete url, body = nil, headers = {}
+      http_request(url, Net::HTTP::Delete, body, headers)
+    end
+
+    # a block that will be called when a remote server responds with
+    # 401 Unauthorized, so that your application can prompt for
+    # authentication details
+    #
+    # it will be called with the base URL of the requested URL, and the realm used in the WWW-Authenticate header.
+    # 
+    # it should return a value of the form [username, password]
+    def when_auth &block
+      @get_auth_details = block
+    end
+
+    private
+    def parse_wwwauth www_authenticate
+      auth_type = www_authenticate.split[0] # "Digest" or "Basic"
+      auth_params = {}
+      
+      www_authenticate =~ /^(\w+) (.*)/
+
+      $2.gsub(/(\w+)="(.*?)"/) { auth_params[$1] = $2 }
+
+      [ auth_type, auth_params ]
+    end
+
+    # performs an authenticated http request
+    def authenticated_request(url_string, method, wwwauth, body = nil, init_headers = {})
+
+      auth_type, params = parse_wwwauth(wwwauth)
+      req, url = new_request(url_string, method, init_headers)
+      
+      realm = params["realm"]
+      abs_url = (url + "/").to_s
+
+      user, pass = @get_auth_details.call(abs_url, realm)
+    
+      raise Unauthorized unless user and pass
+      
+      if auth_type == "Basic"
+        req.basic_auth user, pass
+      else
+        # TODO: implement Digest auth
+        raise "atom-tools only supports Basic authentication"
+      end
+      
+      res = Net::HTTP.start(url.host, url.port) { |h| h.request(req, body) }
+      
+      raise Unauthorized if res.kind_of? Net::HTTPUnauthorized
+      res
+    end
+
+    # performs a regular http request. if it responds 401 
+    # then it retries using @user and @pass for authentication
+    def http_request(url_string, method, body = nil, init_headers = {})
+      req, url = new_request(url_string, method, init_headers)
+      
+      res = Net::HTTP.start(url.host, url.port) { |h| h.request(req, body) }
+
+      if res.kind_of? Net::HTTPUnauthorized
+        res = authenticated_request(url, method, res["WWW-Authenticate"], body, init_headers)
+      end
+
+      res
+    end
+    
+    def new_request(url_string, method, init_headers = {})
+      headers = { "User-Agent" => UA }.merge(init_headers)
+      
+      url = url_string.to_uri
+       
+      rel = url.path
+      rel += "?" + url.query if url.query
+
+      [method.new(rel, headers), url]
+    end
+  end
+end

data/lib/atom/text.rb

@@ -0,0 +1,163 @@
+require "atom/element"
+
+module XHTML
+  NS = "http://www.w3.org/1999/xhtml"
+end
+
+module Atom 
+  # An Atom::Element representing a text construct.
+  # It has a single attribute, "type", which accepts values
+  # "text", "html" and "xhtml"
+
+  class Text < Atom::Element
+    attrb :type
+
+    def initialize value, name # :nodoc:
+      @content = value
+      @content ||= "" # in case of nil
+      self["type"] = "text"
+      
+      super name
+    end
+
+    def to_s
+      if self["type"] == "xhtml" 
+        @content.children.to_s
+      else
+        @content.to_s
+      end
+    end
+
+    # returns a string suitable for dumping into an HTML document
+    def html
+      if self["type"] == "xhtml" or self["type"] == "html"
+        to_s
+      elsif self["type"] == "text"
+        REXML::Text.new(to_s).to_s
+      end
+    end
+
+    # attepts to parse the content and return it as an array of REXML::Elements
+    def xml
+      if self["type"] == "xhtml"
+        @content.children
+      elsif self["type"] == "text"
+        [self.to_s]
+      else
+        # XXX - hpricot goes here?
+        raise "I haven't implemented this yet"
+      end
+    end
+
+    def inspect # :nodoc:
+      "'#{to_s}'##{self['type']}"
+    end
+
+    def []= key, value # :nodoc:
+      if key == "type"
+        unless valid_type? value
+          raise "atomTextConstruct type '#{value}' is meaningless"
+        end
+
+        if value == "xhtml"
+          begin
+            parse_xhtml_content
+          rescue REXML::ParseException
+            raise "#{@content.inspect} can't be parsed as XML"
+          end
+        end
+      end
+
+      super(key, value)
+    end
+    
+    def to_element # :nodoc:
+      e = super
+
+      if self["type"] == "text"
+        e.attributes.delete "type"
+      end
+
+      # this should be done via inheritance
+      unless self.class == Atom::Content and self["src"]
+        c = convert_contents e
+
+        if c.is_a? String
+          e.text = c
+        elsif c.is_a? REXML::Element
+          e << c.dup
+        else
+          raise RuntimeError, "atom:#{local_name} can't contain type #{@content.class}"
+        end
+      end
+
+      e
+    end
+    
+    private
+    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
+      end
+    end
+    
+    def valid_type? type
+      ["text", "xhtml", "html"].member? type
+    end
+
+    def parse_xhtml_content xhtml = nil
+      xhtml ||= @content
+
+      @content = if xhtml.is_a? REXML::Element
+        if xhtml.name == "div" and xhtml.namespace == XHTML::NS
+          xhtml.dup
+        else
+          elem = REXML::Element.new("div")
+          elem.add_namespace(XHTML::NS)
+
+          elem << xhtml.dup
+
+          elem
+        end
+      elsif xhtml.is_a? REXML::Document
+        parse_xhtml_content xhtml.root
+      else
+        div = REXML::Document.new("<div>#{@content}</div>")
+        div.root.add_namespace(XHTML::NS)
+
+        div.root
+      end
+    end
+  end
+
+  # Atom::Content behaves the same as an Atom::Text, but for two things:
+  #
+  # * the "type" attribute can be an arbitrary media type
+  # * there is a "src" attribute which is an IRI that points to the content of the entry (in which case the content element will be empty)
+  class Content < Atom::Text
+    attrb :src
+
+    private
+    def valid_type? type
+      super or type.match(/\//)
+    end
+
+    def convert_contents e
+      s = super
+
+      s ||= if @content.is_a? REXML::Document
+        @content.root
+      elsif @content.is_a? REXML::Element
+        @content
+      else
+        REXML::Text.normalize(@content.to_s)
+      end
+
+      s
+    end
+  end
+end

data/lib/atom/xml.rb

@@ -0,0 +1,200 @@
+require "atom/entry"
+require "atom/feed"
+require "uri"
+
+# Two big, interrelated problems:
+#
+# * I probably shouldn't be playing around in REXML's namespace
+# * REXML isn't a great parser, and other options would be nice
+#
+# This shouldn't be hard to do, it's just tedious and non-critical
+module REXML # :nodoc: all
+  class Document
+    def to_atom_entry base = ""
+      self.root.to_atom_entry base
+    end
+    def to_atom_feed base = ""
+      self.root.to_atom_feed base
+    end
+  end
+  class Element
+    def get_atom_element name
+      XPath.first(self, "./atom:#{name}", { "atom" => Atom::NS })
+    end
+    
+    def each_atom_element name
+      XPath.each(self, "./atom:#{name}", { "atom" => Atom::NS }) do |elem|
+        yield elem
+      end
+    end
+   
+    def get_extensions
+      # XXX also look for attributes
+      children.find_all { |child| child.respond_to? :namespace and child.namespace != Atom::NS }
+    end
+   
+    # get the text content of a descendant element in the Atom namespace
+    def get_atom_text name
+      elem = get_atom_element name
+      if elem
+        elem.text
+      else
+        nil
+      end
+    end
+  
+    # a workaround for the odd way in which REXML handles namespaces
+    # returns the value of the attribute +name+ that's in the same namespace as this element
+    def ns_attr name
+      if not self.prefix.empty?
+        attr = self.prefix + ":" + name
+      else
+        attr = name
+      end
+
+      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 
+          # the only content is out of line
+          entry.send( "#{name}=".to_sym, "")
+          entry.send(name.to_sym)["src"] = src
+        elsif type == "xhtml"
+          div = XPath.first(text, "./xhtml:div", { "xhtml" => XHTML::NS })
+          unless div
+            raise "Refusing to parse type='xhtml' with no <div/> wrapper"
+          end
+
+          # content is the serialized content of the <div> wrapper
+          entry.send( "#{name}=".to_sym, div )
+        else
+          raw = text.text
+          entry.send( "#{name}=", raw )
+        end
+      
+        if text.attributes["xml:base"]
+          entry.send(name.to_sym).base = text.attributes["xml:base"]
+        end
+
+        if type and type != "text"
+          entry.send(name.to_sym)["type"] = type
+        end
+      end
+    end
+
+    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
+      end
+    end
+
+    def fill_attr_element(top, array, kind)
+      each_atom_element(kind) do |elem|
+        thing = array.new
+
+        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
+          elsif value
+            thing[name.to_s] = value
+          end
+        end
+      end
+    end
+
+    # 'base' is the URI that you fetched this document from.
+    def to_atom_entry base = ""
+      unless self.name == "entry" and self.namespace == Atom::NS
+        raise TypeError, "this isn't an atom:entry! (name: #{self.name}, ns: #{self.namespace})"
+      end
+
+      entry = Atom::Entry.new
+
+      entry.base = if attributes["xml:base"]
+        (URI.parse(base) + attributes["xml:base"]).to_s
+      else
+        # go with the URL we were passed in
+        base
+      end
+
+      # Text constructs
+      entry.class.elements.find_all { |n,k,r| k.ancestors.member? Atom::Text }.each do |n,k,r|
+        fill_text_construct(entry, n)
+      end
+
+      ["id", "published", "updated"].each do |name|
+        entry.send("#{name}=".to_sym, get_atom_text(name))
+      end
+
+      ["author", "contributor"].each do |type|
+        fill_elem_element(entry, type)
+      end
+
+      {"link" => entry.links, "category" => entry.categories}.each do |k,v|
+        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
+
+      entry
+    end
+
+    # 'base' is the URI that you fetched this document from.
+    def to_atom_feed base = ""
+      unless self.name == "feed" and self.namespace == Atom::NS
+        raise TypeError, "this isn't an atom:feed! (name: #{self.name}, ns: #{self.namespace})"
+      end
+
+      feed = Atom::Feed.new
+      
+      feed.base = if attributes["xml:base"]
+        (URI.parse(base) + attributes["xml:base"]).to_s
+      else
+        # go with the URL we were passed in
+        base
+      end
+      
+      # Text constructs
+      feed.class.elements.find_all { |n,k,r| k.ancestors.member? Atom::Text }.each do |n,k,r|
+        fill_text_construct(feed, n)
+      end
+
+      ["id", "updated", "generator", "icon", "logo"].each do |name|
+        feed.send("#{name}=".to_sym, get_atom_text(name))
+      end
+
+      ["author", "contributor"].each do |type|
+        fill_elem_element(feed, type)
+      end
+
+      {"link" => feed.links, "category" => feed.categories}.each do |k,v|
+        fill_attr_element(feed, v, k)
+      end
+     
+      each_atom_element("entry") do |elem|
+        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
+
+      feed
+    end
+  end
+end