thehack-atom-tools 2.0.3

data/lib/atom/service.rb

@@ -0,0 +1,106 @@
+require "uri"
+
+require "atom/http"
+require "atom/element"
+require "atom/collection"
+
+module Atom
+  class AutodiscoveryFailure < RuntimeError; end
+
+  # an Atom::Workspace has a #title (Atom::Text) and #collections, an Array of Atom::Collection s
+  class Workspace < Atom::Element
+    is_element PP_NS, :workspace
+
+    elements ['app', PP_NS], :collection, :collections, Atom::Collection
+    atom_element :title, Atom::Title
+  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
+    is_element PP_NS, :service
+
+    elements ['app', PP_NS], :workspace, :workspaces, Atom::Workspace
+
+    # retrieves and parses an Atom service document.
+    def initialize(service_url = "", http = Atom::HTTP.new)
+      super()
+
+      @http = http
+
+      return if service_url.empty?
+
+      base = URI.parse(service_url)
+
+      rxml = nil
+
+      res = @http.get(base, "Accept" => "application/atomsvc+xml")
+      res.validate_content_type(["application/atomsvc+xml"])
+
+      unless res.code == "200"
+        raise Atom::HTTPException, "Unexpected HTTP response code: #{res.code}"
+      end
+
+      self.class.parse(res.body, base, self)
+    end
+
+    def collections
+      self.workspaces.map { |ws| ws.collections }.flatten
+    end
+
+    # given a URL, attempt to find a service document
+    def self.discover url, http = Atom::HTTP.new
+      res = http.get(url, 'Accept' => 'application/atomsvc+xml, text/html')
+
+      case res.content_type
+      when /application\/atomsvc\+xml/
+        Service.parse res.body, url
+      when /html/
+        begin
+          require 'hpricot'
+        rescue
+          raise 'autodiscovering from HTML requires Hpricot.'
+        end
+
+        h = Hpricot(res.body)
+
+        links = h.search('//link')
+
+        service_links = links.select { |l| (' ' + l['rel'] + ' ').match(/ service /i) }
+
+        unless service_links.empty?
+          url = url.to_uri + service_links.first['href']
+          return Service.new(url.to_s, http)
+        end
+
+        rsd_links = links.select { |l| (' ' + l['rel'] + ' ').match(/ EditURI /i) }
+
+        unless rsd_links.empty?
+          url = url.to_uri + rsd_links.first['href']
+          return Service.from_rsd(url, http)
+        end
+
+        raise AutodiscoveryFailure, "couldn't find any autodiscovery links in the HTML"
+      else
+        raise AutodiscoveryFailure, "can't autodiscover from a document of type #{res.content_type}"
+      end
+    end
+
+    def self.from_rsd url, http = Atom::HTTP.new
+      rsd = http.get(url)
+
+      doc = REXML::Document.new(rsd.body)
+
+      atom = REXML::XPath.first(doc, '/rsd/service/apis/api[@name="Atom"]')
+
+      unless atom
+        raise AutodiscoveryFailure, "couldn't find an Atom link in the RSD"
+      end
+
+      url = url.to_uri + atom.attributes['apiLink']
+
+      Service.new(url.to_s, http)
+    end
+  end
+end

data/lib/atom/text.rb

@@ -0,0 +1,231 @@
+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 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
+    atom_attrb :type
+
+    include AttrEl
+
+    on_parse_root do |e,x|
+      type = e.type
+
+      if x.is_a? REXML::Element
+        if type == 'xhtml'
+          x = e.get_elem x, XHTML::NS, 'div'
+
+          raise Atom::ParseError, 'xhtml content needs div wrapper' unless x
+
+          c = x.dup
+
+          unless x.prefix.empty?
+            # content has a namespace prefix, strip prefixes from it and all
+            # XHTML children
+
+            REXML::XPath.each(c, './/xhtml:*', 'xhtml' => XHTML::NS) do |x|
+              x.name = x.name
+            end
+          end
+        else
+          c = x[0] ? x[0].value : nil
+        end
+      else
+        c = x.to_s
+      end
+
+      e.instance_variable_set("@content", c)
+    end
+
+    on_build do |e,x|
+      c = e.instance_variable_get('@content')
+
+      if c.respond_to? :parent
+        x << c.dup
+      elsif c
+        x.text = c.to_s
+      end
+    end
+
+    def initialize value = nil
+      super()
+
+      @content = if value.respond_to? :to_xml
+                   value.to_xml[0]
+                 elsif value
+                   value
+                 else
+                   ''
+                 end
+    end
+
+    def type
+      @type ? @type : 'text'
+    end
+
+    def to_s
+      if type == 'xhtml' and @content and @content.name == 'div'
+        @content.children.to_s
+      else
+        @content.to_s
+      end
+    end
+
+    # 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
+      elsif self["type"] == "text"
+        REXML::Text.new(to_s).to_s
+      end
+    end
+
+    # attempts to parse the content of this element as XML and return it
+    # as an array of REXML::Elements.
+    #
+    # If self["type"] is "html" and Hpricot is installed, it will
+    # be converted to XHTML first.
+    def xml
+      xml = REXML::Element.new 'div'
+
+      if self["type"] == "xhtml"
+        @content.children.each { |child| xml << child }
+      elsif self["type"] == "text"
+        xml.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)
+        xml = REXML::Document.new("<div>#{fixed}</div>").root
+      else
+        # XXX check that @type is an XML mimetype and parse it
+        raise "I haven't implemented this yet"
+      end
+
+      xml
+    end
+
+    def inspect # :nodoc:
+      "'#{to_s}'##{self['type']}"
+    end
+
+    def type= value
+      unless valid_type? value
+        raise Atom::ParseError, "atomTextConstruct type '#{value}' is meaningless"
+      end
+
+      @type = value
+      if @type == "xhtml"
+        begin
+          parse_xhtml_content
+        rescue REXML::ParseException
+          raise Atom::ParseError, "#{@content.inspect} can't be parsed as XML"
+        end
+      end
+    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? or 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
+    is_atom_element :content
+
+    atom_attrb :src
+
+    def src= v
+      @content = nil
+
+      if self.base
+        @src = (self.base.to_uri + v).to_s
+      else
+        @src = v
+      end
+    end
+
+    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
+
+  class Title < Atom::Text; is_atom_element :title; end
+  class Subtitle < Atom::Text; is_atom_element :subtitle; end
+  class Summary < Atom::Text; is_atom_element :summary; end
+  class Rights < Atom::Text; is_atom_element :rights; end
+end

data/lib/atom/tools.rb

@@ -0,0 +1,163 @@
+require 'atom/collection'
+
+# methods to make writing commandline Atom tools more convenient
+
+module Atom::Tools
+  # fetch and parse a Feed URL, returning the entries found
+  def http_to_entries url, complete_feed = false, http = Atom::HTTP.new
+    feed = Atom::Feed.new url, http
+
+    if complete_feed
+      feed.get_everything!
+    else
+      feed.update!
+    end
+
+    feed.entries
+  end
+
+  # parse a directory of entries
+  def dir_to_entries path
+    raise ArgumentError, "#{path} is not a directory" unless File.directory? path
+
+    Dir[path+'/*.atom'].map do |e|
+      Atom::Entry.parse(File.read(e))
+    end
+  end
+
+  # parse a Feed on stdin
+  def stdin_to_entries
+    Atom::Feed.parse($stdin).entries
+  end
+
+  # POSTs an Array of Atom::Entrys to an Atom Collection
+  def entries_to_http entries, url, http = Atom::HTTP.new
+    coll = Atom::Collection.new url, http
+
+    entries.each { |entry| coll.post! entry }
+  end
+
+  # saves an Array of Atom::Entrys to a directory
+  def entries_to_dir entries, path
+    if File.exists? path
+      raise "directory #{path} already exists"
+    else
+      Dir.mkdir path
+    end
+
+    entries.each do |entry|
+      e = entry.to_s
+
+      new_filename = path + '/0x' + MD5.new(e).hexdigest[0,8] + '.atom'
+
+      File.open(new_filename, 'w') { |f| f.write e }
+    end
+  end
+
+  # dumps an Array of Atom::Entrys into a Feed on stdout
+  def entries_to_stdout entries
+    feed = Atom::Feed.new
+
+    entries.each do |entry|
+      puts entry.inspect
+      feed.entries << entry
+    end
+
+    puts feed.to_s
+  end
+
+  # turns a collection of Atom Entries into an Array of Atom::Entrys
+  #
+  # source: a URL, a directory or "-" for an Atom Feed on stdin
+  # options:
+  #   :complete - whether to fetch the complete logical feed
+  #   :user - username to use for HTTP requests (if required)
+  #   :pass - password to use for HTTP requests (if required)
+  def parse_input source, options
+    entries = if source.match /^http/
+             http = Atom::HTTP.new
+
+             setup_http http, options
+
+             http_to_entries source, options[:complete], http
+           elsif source == '-'
+             stdin_to_entries
+           else
+             dir_to_entries source
+           end
+
+    if options[:verbose]
+      entries.each do |entry|
+        puts "got #{entry.title}"
+      end
+    end
+
+    entries
+  end
+
+  # turns an Array of Atom::Entrys into a collection of Atom Entries
+  #
+  # entries: an Array of Atom::Entrys pairs
+  # dest: a URL, a directory or "-" for an Atom Feed on stdout
+  # options:
+  #   :user - username to use for HTTP requests (if required)
+  #   :pass - password to use for HTTP requests (if required)
+  def write_output entries, dest, options
+    if dest.match /^http/
+      http = Atom::HTTP.new
+
+      setup_http http, options
+
+      entries_to_http entries, dest, http
+    elsif dest == '-'
+      entries_to_stdout entries
+    else
+      entries_to_dir entries, dest
+    end
+  end
+
+  # set up some common OptionParser settings
+  def atom_options opts, options
+    opts.on('-u', '--user NAME', 'username for HTTP auth') { |u| options[:user] = u }
+
+    opts.on_tail('-h', '--help', 'show this usage statement') { |h| puts opts; exit }
+
+    opts.on_tail('-p', '--password [PASSWORD]', 'password for HTTP auth') do |p|
+      options[:pass] = p
+    end
+  end
+
+
+  # obtain a password from the TTY, hiding the user's input
+  # this will fail if you don't have the program 'stty'
+  def obtain_password
+    i = o = File.open('/dev/tty', 'w+')
+
+    o.print 'Password: '
+
+    # store original settings
+    state = `stty -F /dev/tty -g`
+
+    # don't echo input
+    system "stty -F /dev/tty -echo"
+
+    p = i.gets.chomp
+
+    # restore original settings
+    system "stty -F /dev/tty #{state}"
+
+    p
+  end
+
+  def setup_http http, options
+    if options[:user]
+      http.user = options[:user]
+
+      unless options[:pass]
+        options[:pass] = obtain_password
+      end
+
+      http.pass = options[:pass]
+    end
+  end
+end