atom-tools 1.0.0 → 2.0.0

data/lib/atom/cache.rb

@@ -0,0 +1,178 @@
+# portions of this ported from httplib2 <http://code.google.com/p/httplib2/>
+# copyright 2006, Joe Gregorio
+#
+# used under the terms of the MIT license
+
+require "md5"
+
+def normalize_header_names _headers
+  headers = {}
+  _headers.each { |k,v| headers[k.downcase] = v }
+  headers
+end
+
+def _parse_cache_control headers
+  retval = {}
+  headers = normalize_header_names(headers) if headers.is_a? Hash
+
+  if headers['cache-control']
+    parts = headers['cache-control'].split(',')
+    parts.each do |part|
+      if part.match(/=/)
+        k, v = part.split('=').map { |p| p.strip }
+        retval[k] = v
+      else
+        retval[part.strip] = 1
+      end
+    end
+  end
+
+  retval
+end
+
+def _updateCache request_headers, response, cache, cachekey
+  cc = _parse_cache_control request_headers
+  cc_response = _parse_cache_control response
+  if cc['no-store'] or cc_response['no-store']
+    cache.delete cachekey
+  else
+    result = "HTTP/#{response.http_version} #{response.code} #{response.message}\r\n"
+
+    response.each_capitalized_name do |field|
+      next if ['status', 'content-encoding', 'transfer-encoding'].member? field.downcase
+      response.get_fields(field).each do |value|
+        result += "#{field}: #{value}\r\n"
+      end
+    end
+
+    cache[cachekey] = result + "\r\n" + response.body
+  end
+end
+
+=begin
+    Determine freshness from the Date, Expires and Cache-Control headers.
+
+    We don't handle the following:
+
+    1. Cache-Control: max-stale
+    2. Age: headers are not used in the calculations.
+
+    Not that this algorithm is simpler than you might think
+    because we are operating as a private (non-shared) cache.
+    This lets us ignore 's-maxage'. We can also ignore
+    'proxy-invalidate' since we aren't a proxy.
+    We will never return a stale document as
+    fresh as a design decision, and thus the non-implementation
+    of 'max-stale'. This also lets us safely ignore 'must-revalidate'
+    since we operate as if every server has sent 'must-revalidate'.
+    Since we are private we get to ignore both 'public' and
+    'private' parameters. We also ignore 'no-transform' since
+    we don't do any transformations.
+    The 'no-store' parameter is handled at a higher level.
+    So the only Cache-Control parameters we look at are:
+
+    no-cache
+    only-if-cached
+    max-age
+    min-fresh
+=end
+def _entry_disposition(response_headers, request_headers)
+  request_headers = normalize_header_names(request_headers)
+
+  cc = _parse_cache_control(request_headers)
+  cc_response = _parse_cache_control(response_headers)
+
+  if request_headers['pragma'] and request_headers['pragma'].downcase.match(/no-cache/)
+    unless request_headers.key? 'cache-control'
+      request_headers['cache-control'] = 'no-cache'
+    end
+    :TRANSPARENT
+  elsif cc.key? 'no-cache'
+    :TRANSPARENT
+  elsif cc_response.key? 'no-cache'
+    :STALE
+  elsif cc.key? 'only-if-cached'
+    :FRESH
+  elsif response_headers.key? 'date'
+    date = Time.rfc2822(response_headers['date'])
+    diff = Time.now - date
+    current_age = (diff > 0) ? diff : 0
+    if cc_response.key? 'max-age'
+      freshness_lifetime = cc_response['max-age'].to_i
+    elsif response_headers.key? 'expires'
+      expires = Time.rfc2822(response_headers['expires'])
+      diff = expires - date
+      freshness_lifetime = (diff > 0) ? diff : 0
+    else
+      freshness_lifetime = 0
+    end
+
+    if cc.key? 'max-age'
+      freshness_lifetime = cc['max-age'].to_i
+    end
+
+    if cc.key? 'min-fresh'
+      min_fresh = cc['min-fresh'].to_i
+      current_age += min_fresh
+    end
+
+    if freshness_lifetime > current_age
+      :FRESH
+    else
+      :STALE
+    end
+  end
+end
+
+module Atom
+  # this cache never actually saves anything
+  class NilCache
+    def [] key
+      nil
+    end
+
+    def []= key, value
+      nil
+    end
+
+    def delete key
+      nil
+    end
+  end
+
+  # uses a local directory to store cache files
+  class FileCache
+    def initialize dir
+      @dir = dir
+    end
+
+    def to_file(key)
+      @dir + "/" + self.safe(key)
+    end
+
+    # turns a URL into a safe filename
+    def safe filename
+      filemd5 = MD5.hexdigest(filename)
+      filename = filename.sub(/^\w+:\/\//, '')
+      filename = filename.gsub(/[?\/:|]+/, ',')
+
+      filename + "," + filemd5
+    end
+
+    def [] key
+      File.read(self.to_file(key))
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def []= key, value
+      File.open(self.to_file(key), 'w') do |f|
+        f.write(value)
+      end
+    end
+
+    def delete key
+      File.delete(self.to_file(key))
+    end
+  end
+end

data/lib/atom/collection.rb

@@ -1,20 +1,80 @@
 require "atom/http"
 require "atom/feed"
 
-# so we can do some mimetype guessing
-require "webrick/httputils"
-
 module Atom
-  # a Collection is an Atom::Feed with extra Protocol-specific methods
-  class Collection < Feed
-    # comma separated string that contains a list of media types
-    # accepted by a collection.
-    #
-    # XXX I should parse this in some way, but I'm not sure what's useful 
-    attr_accessor :accepts
+  class Categories < Atom::Element
+    is_element PP_NS, 'categories'
+
+    atom_elements :category, :list, Atom::Category
+
+    attrb ['app', PP_NS], :scheme
+    attrb ['app', PP_NS], :href
+
+    def scheme= s
+      list.each do |cat|
+        unless cat.scheme
+          cat.scheme = s
+        end
+      end
+    end
+
+    # 'fixed' attribute parsing/building
+    attr_accessor :fixed
+
+    on_parse_attr [PP_NS, :fixed] do |e,x|
+      e.set(:fixed, x == 'yes')
+    end
+
+    on_build do |e,x|
+      if e.get(:fixed)
+        e.attributes['fixed'] = 'yes'
+      end
+    end
+  end
+
+  class Collection < Atom::Element
+    is_element PP_NS, 'collection'
+
+    strings ['app', PP_NS], :accept, :accepts
+    attrb ['app', PP_NS], :href
+
+    def_set :href do |href|
+      @href = href
+      @feed = Atom::Feed.new @href, @http
+    end
 
-    def initialize(uri, http = Atom::HTTP.new)
-      super uri, http
+    atom_element :title, Atom::Title
+
+    elements ['app', PP_NS], :categories, :categories, Atom::Categories
+
+    def title
+      @title or @feed.title
+    end
+
+    def accepts
+      if @accepts.empty?
+        ['application/atom+xml;type=entry']
+      else
+        @accepts
+      end
+    end
+
+    def accepts= array
+      @accepts = array
+    end
+
+    attr_reader :http
+
+    attr_reader :feed
+
+    def initialize(href = nil, http = Atom::HTTP.new)
+      super()
+
+      if href
+        self.href = href
+      end
+
+      @http = http
     end
 
     # POST an entry to the collection, with an optional slug
@@ -22,10 +82,10 @@ module Atom
       raise "Cowardly refusing to POST a non-Atom::Entry" unless entry.is_a? Atom::Entry
       headers = {"Content-Type" => "application/atom+xml" }
       headers["Slug"] = slug if slug
-      
-      @http.post(@uri, entry.to_s, headers)
+
+      @http.post(@href, entry.to_s, headers)
     end
-  
+
     # PUT an updated version of an entry to the collection
     def put!(entry, url = entry.edit_url)
       @http.put_atom_entry(entry, url)
@@ -40,8 +100,8 @@ module Atom
     def post_media!(data, content_type, slug = nil)
       headers = {"Content-Type" => content_type}
       headers["Slug"] = slug if slug
-      
-      @http.post(@uri, data, headers)
+
+      @http.post(@href, data, headers)
     end
 
     # PUT a media item to the collection

data/lib/atom/element.rb

@@ -1,44 +1,56 @@
 require "time"
 require "rexml/element"
 
+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
+
+# cribbed from metaid.rb
+class Object
+   # The hidden singleton lurks behind everyone
+   def metaclass; class << self; self; end; end
+   def meta_eval &blk; metaclass.instance_eval &blk; end
+
+   # Adds methods to a metaclass
+   def meta_def name, &blk
+     meta_eval { define_method name, &blk }
+   end
+end
+
 module Atom # :nodoc:
-  class Time < ::Time # :nodoc:
-    def self.new date
-      return if date.nil?
+  NS = "http://www.w3.org/2005/Atom"
+  PP_NS = "http://www.w3.org/2007/app"
 
-      date = if date.respond_to?(:iso8601)
-        date
-      else
-        Time.parse date.to_s
-      end
-        
-      def date.to_s
-        iso8601
-      end
+  class ParseError < StandardError; end
 
-      date
-    end
+  module AttrEl
+    # for backwards compatibility
+    def [] k; self.send(k.to_sym); end
+    def []= k, v; self.send("#{k}=".to_sym, v); end
   end
-       
+
   # ignore the man behind the curtain.
   def self.Multiple klass
     Class.new(Array) do
       @class = klass
 
-      def new
-        item = self.class.holds.new
+      def new *args
+        item = self.class.holds.new *args
         self << item
-      
+
         item
       end
 
       def << item
         raise ArgumentError, "this can only hold items of class #{self.class.holds}" unless item.is_a? self.class.holds
-        super(item)
-      end
 
-      def to_element
-        collect do |item| item.to_element end
+        super(item)
       end
 
       def self.holds; @class end
@@ -47,187 +59,514 @@ module Atom # :nodoc:
     end
   end
 
-  # The Class' methods provide a DSL for describing Atom's structure
-  #   (and more generally for describing simple namespaced XML)
-  class Element < Hash 
-    # a REXML::Element that shares this element's extension attributes
-    # and child elements
-    attr_reader :extensions
+  module Parsers
+    # adds a parser that calls the given block for a single element that
+    # matches the given name and namespace (if it exists)
+    def on_parse name_pair, &block
+      uri, name = name_pair
+      @on_parse ||= []
 
-    # this element's xml:base
-    attr_accessor :base
+      process = lambda do |e,x|
+        el = e.get_elem(x, uri, name)
+
+        if el
+          block.call e, el
+
+          e.extensions.delete_if do |c|
+            c.namespace == uri and c.name == name.to_s
+          end
+        end
+      end
 
-    # this element's attributes
-    def self.attrs # :nodoc:
-      @attrs || []
+      @on_parse << process
     end
 
-    # this element's child elements
-    def self.elements # :nodoc:
-      @elements || []
+    # adds a parser that calls the given block for the attribute that
+    # matches the given name (if it exists)
+    def on_parse_attr name_pair, &block
+      uri, name = name_pair
+      @on_parse ||= []
+
+      process = lambda do |e,x|
+        x = e.get_atom_attrb(x, name)
+
+        if x
+          block.call e, x
+
+          e.extensions.attributes.delete name.to_s
+        end
+      end
+
+      @on_parse << process
     end
 
-    # required child elements
-    def self.required # :nodoc:
-      @elements.find { |name,kind,req| req }
+    # adds a parser that calls the given block for all elements
+    # that match the given name and namespace
+    def on_parse_many name_pair, &block
+      uri, name = name_pair
+      @on_parse ||= []
+
+      process = lambda do |e,x|
+        els = e.get_elems(x, uri, name)
+
+        unless els.empty?
+          block.call e, els
+
+          els.each do |el|
+            e.extensions.delete_if { |c| c.namespace == uri and c.name == name.to_s }
+          end
+        end
+      end
+
+      @on_parse << process
     end
 
-    # copy defined elements and attributes so inheritance works
-    def self.inherited klass # :nodoc:
-      elements.each do |name, kind, req|
-        klass.element name, kind, req
+    # adds a parser that calls the given block for this element
+    def on_parse_root &block
+      @on_parse ||= []
+
+      process = lambda do |e,x|
+        block.call e, x
+
+        x.elements.each do |el|
+          e.extensions.clear
+        end
       end
-      attrs.each do |name, req|
-        klass.attrb name, req
+
+      @on_parse << process
+    end
+
+    # parses the text content of an element named 'name' into an attribute
+    # on this Element named 'name'
+    def parse_plain uri, name
+      self.on_parse [uri, name] do |e,x|
+        e.set(name, x.text)
       end
     end
+  end
 
-    # define a child element
-    def self.element(name, kind, req = false) # :nodoc:
+  module Converters
+    def build_plain ns, name
+      self.on_build do |e,x|
+        if v = e.get(name)
+          el = e.append_elem(x, ns, name)
+          el.text = v.to_s
+        end
+      end
+    end
+
+    # an element in the Atom namespace containing text
+    def atom_string(name)
+      attr_accessor name
+
+      self.parse_plain(Atom::NS, name)
+      self.build_plain(['atom', Atom::NS], name)
+    end
+
+    # an element in namespace 'ns' containing a RFC3339 timestamp
+    def time(ns, name)
       attr_reader name
 
-      @elements ||= []
-      @elements << [name, kind, req]
+      self.def_set name do |time|
+        unless time.respond_to? :iso8601
+          time = Time.parse(time.to_s)
+        end
+
+        def time.to_s; iso8601; end
+
+        instance_variable_set("@#{name}", time)
+      end
 
-      unless kind.respond_to? :single?
-        self.define_accessor(name,kind)
+      define_method "#{name}!".to_sym do
+        set(name, Time.now)
       end
+
+      self.parse_plain(ns[1], name)
+      self.build_plain(ns, name)
+    end
+
+    # an element in the Atom namespace containing a timestamp
+    def atom_time(name)
+      self.time ['atom', Atom::NS], name
     end
 
-    # define an attribute 
-    def self.attrb(name, req = false) # :nodoc:
-      @attrs ||= []
+    # an element that is parsed by Element descendant 'klass'
+    def element(ns, name, klass)
+      el_name = name
+      name = name.to_s.gsub(/-/, '_')
+
+      attr_reader name
+
+      self.on_parse [ns[1], el_name] do |e,x|
+        e.instance_variable_set("@#{name}", klass.parse(x, e.base))
+      end
+
+      self.on_build do |e,x|
+        if v = e.get(name)
+          el = e.append_elem(x, ns, el_name)
+          v.build(el)
+        end
+      end
+
+      def_set name do |value|
+        instance_variable_set("@#{name}", klass.new(value))
+      end
+    end
 
-      @attrs << [name, req]
+    # an element that is parsed by Element descendant 'klass'
+    def atom_element(name, klass)
+      self.element(['atom', Atom::NS], name, klass)
     end
- 
-    # a little bit of magic
-    def self.define_accessor(name,kind) # :nodoc:
-      define_method "#{name}=".to_sym do |value|
-        return unless value
-        
-        i = if kind.ancestors.member? Atom::Element
-          kind.new(value, name.to_s)
-        else
-          kind.new(value)
+
+    # an element that can appear multiple times that contains text
+    #
+    # 'one_name' is the name of the element, 'many_name' is the name of
+    # the attribute that will be created on this Element
+    def strings(ns, one_name, many_name)
+      attr_reader many_name
+
+      self.on_init do
+        instance_variable_set("@#{many_name}", [])
+      end
+
+      self.on_parse_many [ns[1], one_name] do |e,xs|
+        var = e.instance_variable_get("@#{many_name}")
+
+        xs.each do |el|
+          var << el.text
+        end
+      end
+
+      self.on_build do |e,x|
+        e.instance_variable_get("@#{many_name}").each do |v|
+          e.append_elem(x, ns, one_name).text = v
         end
-       
-        set(name, i)
       end
     end
 
-    # get the value of an attribute
-    def [] key
-      test_key key
-   
-      super
+    # an element that can appear multiple times that is parsed by Element
+    # descendant 'klass'
+    #
+    # 'one_name' is the name of the element, 'many_name' is the name of
+    # the attribute that will be created on this Element
+    def elements(ns, one_name, many_name, klass)
+      attr_reader many_name
+
+      self.on_init do
+        var = Atom::Multiple(klass).new
+        instance_variable_set("@#{many_name}", var)
+      end
+
+      self.on_parse_many [ns[1], one_name] do |e,xs|
+        var = e.get(many_name)
+
+        xs.each do |el|
+          var << klass.parse(el, e.base)
+        end
+      end
+
+      self.on_build do |e,x|
+        e.get(many_name).each do |v|
+          el = e.append_elem(x, ns, one_name)
+          v.build(el)
+        end
+      end
     end
-    
-    # set the value of an attribute
-    def []= key, value
-      test_key key
 
-      super
+    # like #elements but in the Atom namespace
+    def atom_elements(one_name, many_name, klass)
+      self.elements(['atom', Atom::NS], one_name, many_name, klass)
     end
 
-    # internal junk you probably don't care about
-    def initialize name = nil # :nodoc:
-      @extensions = REXML::Element.new("extensions")
-      @local_name = name
+    # an XML attribute in the namespace 'ns'
+    def attrb(ns, name)
+      attr_accessor name
+
+      self.on_parse_attr [ns[1], name] do |e,x|
+        e.set(name, x)
+      end
 
-      self.class.elements.each do |name,kind,req|
-        if kind.respond_to? :single?
-          a = kind.new
-          set(name, kind.new)
+      self.on_build do |e,x|
+        if v = e.get(name)
+          e.set_atom_attrb(x, name, v.to_s)
         end
       end
     end
 
-    # eg. "feed" or "entry" or "updated" or "title" or ...
-    def local_name # :nodoc:
-      @local_name || self.class.name.split("::").last.downcase
+    # an XML attribute in the Atom namespace
+    def atom_attrb(name)
+      self.attrb(['atom', Atom::NS], name)
     end
-   
-    # convert to a REXML::Element (with no namespace)
-    def to_element 
-      elem = REXML::Element.new(local_name)
 
-      self.class.elements.each do |name,kind,req|
-        v = get(name)
-        next if v.nil?
+    # a type of Atom Link. specifics defined by Hash 'criteria'
+    def atom_link name, criteria
+      def_get name do
+        existing = find_link(criteria)
 
-        if v.respond_to? :to_element
-          e = v.to_element
-          e = [ e ] unless e.is_a? Array
+        existing and existing.href
+      end
 
-          e.each do |bit|
-            elem << bit
-          end
+      def_set name do |value|
+        existing = find_link(criteria)
+
+        if existing
+          existing.href = value
         else
-          e = REXML::Element.new(name.to_s, elem).text = get(name)
+          links.new criteria.merge(:href => value)
         end
       end
+    end
+  end
 
-      self.class.attrs.each do |name,req|
-        value = self[name.to_s]
-        elem.attributes[name.to_s] = value.to_s if value
+  # The Class' methods provide a DSL for describing Atom's structure
+  #   (and more generally for describing simple namespaced XML)
+  class Element
+    # this element's xml:base
+    attr_accessor :base
+
+    # xml elements and attributes that have been parsed, but are unknown
+    attr_reader :extensions
+
+    # attaches a name and a namespace to an element
+    # this needs to be called on any new element
+    def self.is_element ns, name
+      meta_def :self_namespace do; ns; end
+      meta_def :self_name do; name.to_s; end
+    end
+
+    # wrapper for #is_element
+    def self.is_atom_element name
+      self.is_element Atom::NS, name
+    end
+
+    # gets a single namespaced child element
+    def get_elem xml, ns, name
+      REXML::XPath.first xml, "./ns:#{name}", { 'ns' => ns }
+    end
+
+    # gets multiple namespaced child elements
+    def get_elems xml, ns, name
+      REXML::XPath.match xml, "./ns:#{name}", { 'ns' => ns }
+    end
+
+    # gets a child element in the Atom namespace
+    def get_atom_elem xml, name
+      get_elem xml, Atom::NS, name
+    end
+
+    # gets multiple child elements in the Atom namespace
+    def get_atom_elems xml, name
+      get_elems Atom::NS, name
+    end
+
+    # gets an attribute on +xml+
+    def get_atom_attrb xml, name
+      xml.attributes[name.to_s]
+    end
+
+    # sets an attribute on +xml+
+    def set_atom_attrb xml, name, value
+      xml.attributes[name.to_s] = value
+    end
+
+    extend Parsers
+    extend Converters
+
+    def self.on_build &block
+      @on_build ||= []
+      @on_build << block
+    end
+
+    def self.do_parsing e, root
+      if ancestors[1].respond_to? :do_parsing
+        ancestors[1].do_parsing e, root
       end
 
-      self.extensions.children.each do |element|
-        elem << element.dup # otherwise they get removed from @extensions
+      @on_parse ||= []
+      @on_parse.each { |p| p.call e, root }
+    end
+
+    def self.builders &block
+      if ancestors[1].respond_to? :builders
+        ancestors[1].builders &block
       end
 
-      if self.base and not self.base.empty?
-        elem.attributes["xml:base"] = self.base
+      @on_build ||= []
+      @on_build.each &block
+    end
+
+    # turns a String, an IO-like, a REXML::Element, etc. into an Atom::Element
+    #
+    # the 'base' base URL parameter should be supplied if you know where this
+    # XML was fetched from
+    #
+    # if you want to parse into an existing Atom::Element, it can be passed in
+    # as 'element'
+    def self.parse xml, base = '', element = nil
+      if xml.respond_to? :elements
+         root = xml.dup
+       else
+         xml = xml.read if xml.respond_to? :read
+
+         begin
+           root = REXML::Document.new(xml.to_s).root
+         rescue REXML::ParseException => e
+           raise Atom::ParseError, e.message
+         end
+       end
+
+      unless root.local_name == self.self_name
+        raise Atom::ParseError, "expected element named #{self.self_name}, not #{root.local_name}"
+      end
+
+      unless root.namespace == self.self_namespace
+        raise Atom::ParseError, "expected element in namespace #{self.self_namespace}, not #{root.namespace}"
       end
 
-      elem
+      if root.attributes['xml:base']
+        base = (base.to_uri + root.attributes['xml:base'])
+      end
+
+      e = element ? element : self.new
+      e.base = base
+
+      # extension elements
+      root.elements.each do |c|
+        e.extensions << c
+      end
+
+      # extension attributes
+      root.attributes.each do |k,v|
+        e.extensions.attributes[k] = v
+      end
+
+      # as things are parsed, they're removed from e.extensions. whatever's
+      # left over is stored so it can be round-tripped
+
+      self.do_parsing e, root
+
+      e
     end
-    
-    # convert to a REXML::Document (properly namespaced)
+
+    # converts to a REXML::Element
     def to_xml
-      doc = REXML::Document.new
-      root = to_element
-      root.add_namespace Atom::NS
-      doc << root
-      doc
-    end
-   
-    # convert to an XML string
+      root = REXML::Element.new self.class.self_name
+      root.add_namespace self.class.self_namespace
+
+      build root
+
+      root
+    end
+
+    # fill a REXML::Element with the data from this Atom::Element
+    def build root
+      if self.base and not self.base.empty?
+        root.attributes['xml:base'] = self.base
+      end
+
+      self.class.builders do |builder|
+        builder.call self, root
+      end
+
+      @extensions.each do |e|
+        root << e.dup
+      end
+
+      @extensions.attributes.each do |k,v|
+        root.attributes[k] = v
+      end
+    end
+
     def to_s
       to_xml.to_s
     end
-    
-    def base= uri # :nodoc:
-      @base = uri.to_s
+
+    # defines a getter that calls 'block'
+    def self.def_get(name, &block)
+      define_method name.to_sym, &block
+    end
+
+    # defines a setter that calls 'block'
+    def self.def_set(name, &block)
+      define_method "#{name}=".to_sym, &block
     end
- 
-    private
 
-    # like +valid_key?+ but raises on failure
-    def test_key key
-      unless valid_key? key
-        raise RuntimeError, "this element (#{local_name}) doesn't have that attribute '#{key}'"
+    # be sure to call #super if you override this method!
+    def initialize defaults = {}
+      @extensions = []
+
+      @extensions.instance_variable_set('@attrs', {})
+      def @extensions.attributes
+        @attrs
+      end
+
+      self.class.initters do |init|
+        self.instance_eval &init
       end
+
+      defaults.each do |k,v|
+        set(k, v)
+      end
+    end
+
+    def self.on_init &block
+      @on_init ||= []
+      @on_init << block
     end
 
-    # tests that an attribute 'key' has been defined
-    def valid_key? key
-      self.class.attrs.find { |name,req| name.to_s == key }
+    def self.initters &block
+      @on_init ||= []
+      @on_init.each &block
     end
 
+    # appends an element named 'name' in namespace 'ns' to 'root'
+    # ns is either [prefix, namespace] or just a String containing the namespace
+    def append_elem(root, ns, name)
+      if ns.is_a? Array
+        prefix, uri = ns
+      else
+        prefix, uri = nil, ns
+      end
+
+      name = name.to_s
+
+      existing_prefix = root.namespaces.find do |k,v|
+        v == uri
+      end
+
+      root << if existing_prefix
+                prefix = existing_prefix[0]
+
+                if prefix != 'xmlns'
+                  name = prefix + ':' + name
+                end
+
+                REXML::Element.new(name)
+              elsif prefix
+                e = REXML::Element.new(prefix + ':' + name)
+                e.add_namespace(prefix, uri)
+                e
+              else
+                e = REXML::Element.new(name)
+                e.add_namespace(uri)
+                e
+              end
+    end
+
+    def base= uri # :nodoc:
+      @base = uri.to_s
+    end
+
+    # calls a getter
     def get name
-      instance_variable_get "@#{name}"
+      send "#{name}".to_sym
     end
 
+    # calls a setter
     def set name, value
-      instance_variable_set "@#{name}", value
+      send "#{name}=", value
     end
   end
-  
-  # this facilitates YAML output
-  class AttrEl < Atom::Element # :nodoc:
-  end
 
   # A link has the following attributes:
   #
@@ -237,31 +576,47 @@ module Atom # :nodoc:
   # hreflang:: the language of the linked item (RFC3066)
   # title:: human-readable information about the link
   # length:: a hint about the length (in octets) of the linked item
-  class Link < Atom::AttrEl
-    attrb :href, true
-    attrb :rel
-    attrb :type
-    attrb :hreflang
-    attrb :title
-    attrb :length
+  class Link < Atom::Element
+    is_atom_element :link
+
+    atom_attrb :href
+    atom_attrb :rel
+    atom_attrb :type
+    atom_attrb :hreflang
+    atom_attrb :title
+    atom_attrb :length
 
-    def initialize name = nil # :nodoc:
-      super name
+    include AttrEl
 
-      # just setting a default
-      self["rel"] = "alternate"
+    def rel
+      @rel or 'alternate'
+    end
+
+    def self.parse xml, base = ''
+      e = super
+
+      # URL absolutization
+      if e.base and e.href
+        e.href = (e.base.to_uri + e.href).to_s
+      end
+
+      e
     end
   end
- 
+
   # A category has the following attributes:
   #
   # term (required):: a string that identifies the category
   # scheme:: an IRI that identifies a categorization scheme
   # label:: a human-readable label
-  class Category < Atom::AttrEl
-    attrb :term, true
-    attrb :scheme
-    attrb :label
+  class Category < Atom::Element
+    is_atom_element :category
+
+    atom_attrb :term
+    atom_attrb :scheme
+    atom_attrb :label
+
+    include AttrEl
   end
 
   # A person construct has the following child elements:
@@ -269,18 +624,17 @@ module Atom # :nodoc:
   # name (required):: a human-readable name
   # uri:: an IRI associated with the person
   # email:: an email address associated with the person
-  class Author < Atom::Element
-    element :name, String, true
-    element :uri, String
-    element :email, String
+  class Person < Atom::Element
+    atom_string :name
+    atom_string :uri
+    atom_string :email
   end
- 
-  # same as Atom::Author
-  class Contributor < Atom::Element 
-    # Author and Contributor should probably inherit from Person, but
-    # oh well.
-    element :name, String, true
-    element :uri, String
-    element :email, String
+
+  class Author < Atom::Person
+    is_atom_element :author
+  end
+
+  class Contributor < Atom::Person
+    is_atom_element :contributor
   end
 end