atom-tools 0.9.0 → 2.0.5

data/lib/atom/text.rb

@@ -4,31 +4,101 @@ module XHTML
   NS = "http://www.w3.org/1999/xhtml"
 end
 
-module Atom 
+module Atom
   # An Atom::Element representing a text construct.
-  # It has a single attribute, "type", which accepts values
-  # "text", "html" and "xhtml"
-
+  # 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
-    attrb :type
-
-    def initialize value, name # :nodoc:
-      @content = value
-      @content ||= "" # in case of nil
-      self["type"] = "text"
-      
-      super name
+    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
+        elsif ['text', 'html'].include?(type)
+          c = x[0] ? x[0].value : nil
+        else
+          c = x
+        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
+        if c.is_a?(REXML::Element) && c.name == 'content' # && !c.text.strip == ''
+          # c
+          c.children.each do |child_element|
+            x.add_element(child_element) unless child_element.is_a?(REXML::Text) && child_element.to_s.strip == ''
+          end
+          # x.add_text('') # unless child_element.to_s.strip == ''
+        else
+          x << c.dup
+        end
+      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 self["type"] == "xhtml" 
+      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
+    # 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
@@ -37,74 +107,64 @@ 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 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
+        @content.children.each { |child| xml << child }
       elsif self["type"] == "text"
-        [self.to_s]
+        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 - hpricot goes here?
-        raise "I haven't implemented this yet"
+        # Not XHTML, HTML, or text - return the REXML::Element, leave it up to the user to parse the content
+        xml = @content
       end
+
+      xml
     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"
+    def type= value
+      unless valid_type? value
+        raise Atom::ParseError, "atomTextConstruct type '#{value}' is meaningless"
       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}"
+      @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
-
-      e
     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?
-        REXML::Text.normalize(@content.to_s)
-      elsif self["type"] == "html"
+      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
@@ -137,9 +197,21 @@ module Atom
   # 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)
+  # * there is a "src" attribute which is an URI that points to the content of the entry (in which case the content element will be empty)
   class Content < Atom::Text
-    attrb :src
+    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
@@ -160,4 +232,9 @@ module Atom
       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