atom-tools 0.9.0 → 2.0.5

data/lib/atom/app.rb

@@ -1,87 +0,0 @@
-require "uri"
-
-require "atom/http"
-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
-
-  # Atom::App represents an Atom Publishing Protocol introspection
-  # document.
-  class App
-    # collections referred to by the introspection document
-    attr_reader :collections
-
-    # retrieves and parses an Atom introspection document.
-    def initialize(introspection_url, http = Atom::HTTP.new)
-      i_url = URI.parse(introspection_url)
-
-      rxml = nil
-
-      res = http.get(i_url)
-
-      unless res.code == "200" # redirects, &c.
-        raise WrongResponse, "introspection document responded with unexpected code #{res.code}"
-      end
-
-      unless res.content_type == "application/atomserv+xml"
-        raise WrongMimetype, "this isn't an introspection document!"
-      end
-
-      rxml = REXML::Document.new(res.body)
-
-      unless rxml.root.namespace == PP_NS
-        raise WrongNamespace, "this isn't an introspection document!"
-      end
-
-      # TODO: expose workspaces
-      colls = REXML::XPath.match( rxml, 
-                                  "/app:service/app:workspace/app:collection",
-                                  {"app" => Atom::PP_NS} )
-      
-      @collections = []
-      
-      colls.each do |collection|
-        # absolutize relative URLs
-        url = i_url + URI.parse(collection.attributes["href"])
-       
-        coll = Atom::Collection.new(url, http)
-
-        # XXX this is a Text Construct, and should be parsed as such
-        coll.title = REXML::XPath.first( collection,
-                                    "./atom:title",
-                                    {"app" => Atom::PP_NS,
-                                     "atom" => Atom::NS   } ).text
-
-        accepts = REXML::XPath.first( collection,
-                                      "./app:accept",
-                                      {"app" => Atom::PP_NS} )
-        coll.accepts = (accepts ? accepts.text : "entry")
-        
-        @collections << coll
-      end
-    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/xml.rb

@@ -1,200 +0,0 @@
-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

data/lib/atom/yaml.rb

@@ -1,101 +0,0 @@
-require "atom/entry"
-require "yaml"
-
-module Atom
-  class Time
-    def taguri; nil end
-  end
-
-  class Element < Hash
-    def taguri # :nodoc:
-    end
-
-    def to_yaml_properties # :nodoc:
-      self.class.elements.find_all do |n,k,r|
-        v = get(n)
-        v and not (v.respond_to? :empty? and v.empty?)
-      end.map { |n,k,r| "@#{n}" }
-    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
-        end
-      end
-    end
-  end
-
-  class AttrEl < Atom::Element
-    def to_yaml( opts = {} )
-      YAML::quick_emit( object_id, opts ) do |out|
-        out.map( nil, to_yaml_style ) do |map|
-          self.class.attrs.each do |n,r|
-            map.add( n.to_s, self[n.to_s] ) if self[n.to_s]
-          end
-        end
-      end
-    end
-  end
-
-  class Text < Atom::Element
-    def taguri # :nodoc:
-    end
-
-    def to_yaml( opts = {} ) # :nodoc:
-      YAML::quick_emit( object_id, opts ) do |out|
-        out.scalar(taguri, to_s, to_yaml_style)
-      end
-    end
-    def to_yaml_style # :nodoc:
-      if @content.match("\n")
-        :fold
-      else
-        :plain
-      end
-    end
-  end
-
-  class Entry
-    def to_yaml_type # :nodoc:
-      '!necronomicorp.com,2006/entry'
-    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}
-
-      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"]
-
-      entry
-    end
-  end
-end