atom-tools 1.0.0 → 2.0.0

data/lib/atom/text.rb

@@ -18,19 +18,57 @@ module Atom
   #
   # This content of this element can be retrieved in different formats, see #html and #xml
   class Text < Atom::Element
-    attrb :type
+    atom_attrb :type
 
-    def initialize value, name # :nodoc:
-      @content = value
-      @content ||= "" # in case of nil
-      self["type"] = "text"
+    include AttrEl
 
-      super name
+    on_parse_root do |e,x|
+      type = e.type
+
+      if x.is_a? REXML::Element
+        if type == 'xhtml'
+          x = x.elements['div']
+          raise Atom::ParseError, 'xhtml content needs div wrapper' unless x
+
+          c = x.dup
+        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
 
-    # convenient, but not overly useful. see #html instead.
     def to_s
-      if self["type"] == "xhtml"
+      if type == 'xhtml' and @content and @content.name == 'div'
         @content.children.to_s
       else
         @content.to_s
@@ -56,10 +94,12 @@ module Atom
     # 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"
@@ -68,54 +108,32 @@ module Atom
         end
 
         fixed = Hpricot(self.to_s, :xhtml_strict => true)
-        REXML::Document.new("<div>#{fixed}</div>").root.children
+        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 []= 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
+    def type= value
+      unless valid_type? value
+        raise Atom::ParseError, "atomTextConstruct type '#{value}' is meaningless"
       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
-      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
@@ -123,10 +141,8 @@ module Atom
     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.gsub(/&/, "&amp;")
+      elsif self["type"] == "text" or self["type"].nil? or self["type"] == "html"
+        @content.to_s
       end
     end
 
@@ -164,23 +180,18 @@ module Atom
   # * 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
+    is_atom_element :content
 
-    def html
-      if self["src"]
-        ""
-      else
-        super
-      end
-    end
+    atom_attrb :src
 
-    def to_element
-      if self["src"]
-        element_super = Element.instance_method(:to_element)
-        return element_super.bind(self).call
-      end
+    def src= v
+      @content = nil
 
-      super
+      if self.base
+        @src = (self.base.to_uri + v).to_s
+      else
+        @src = v
+      end
     end
 
     private
@@ -202,4 +213,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

data/test/conformance/order.rb

@@ -9,23 +9,23 @@ FEED.update!
 class TestOrderConformance < Test::Unit::TestCase
   def test_0
     entry = FEED.entries[0]
-    
+
     assert_equal "tag:example.org,2006:atom/conformance/element_order/1", entry.id
     assert_equal "Simple order, nothing fancy", entry.title.to_s
     assert_equal "Simple ordering, nothing fancy", entry.summary.to_s
     assert_equal Time.parse("2006-01-26T09:20:01Z"), entry.updated
-    
+
     assert_alternate_href(entry, "http://www.snellspace.com/public/alternate")
   end
 
   def test_1
     entry = FEED.entries[1]
-    
+
     assert_equal "tag:example.org,2006:atom/conformance/element_order/2", entry.id
     assert_equal "Same as the first, only mixed up a bit", entry.title.to_s
     assert_equal "Same as the first, only mixed up a bit", entry.summary.to_s
     assert_equal Time.parse("2006-01-26T09:20:02Z"), entry.updated
-    
+
     assert_alternate_href(entry, "http://www.snellspace.com/public/alternate")
   end
 
@@ -34,8 +34,9 @@ class TestOrderConformance < Test::Unit::TestCase
     entry = FEED.entries[2]
 
     # both links should be available, but it's up to you to choose which one to use 
+
     assert_link_href(entry, "http://www.snellspace.com/public/alternate") { |l| l["rel"] == "alternate" and l["type"] == nil }
-    
+
     assert_link_href(entry, "http://www.snellspace.com/public/alternate2") { |l| l["rel"] == "alternate" and l["type"] == "text/plain" }
   end
 
@@ -65,7 +66,7 @@ class TestOrderConformance < Test::Unit::TestCase
   #  ^-- quoted summary is a typo, source is last
   def test_5
     entry = FEED.entries[5]
-    
+
     assert_equal "tag:example.org,2006:atom/conformance/element_order/6", entry.id
     assert_equal "Entry with a source last", entry.title.to_s
     assert_equal Time.parse("2006-01-26T09:20:06Z"), entry.updated
@@ -91,18 +92,18 @@ class TestOrderConformance < Test::Unit::TestCase
     assert_equal "tag:example.org,2006:atom/conformance/element_order/8", entry.id
     assert_equal "Atom elements in an extension element", entry.title.to_s
     assert_equal Time.parse("2006-01-26T09:20:08Z"), entry.updated
-    
+
     assert_alternate_href(entry, "http://www.snellspace.com/public/alternate")
   end
-  
+
   # Atom elements in an extension element
   def test_8
     entry = FEED.entries[8]
-    
+
     assert_equal "tag:example.org,2006:atom/conformance/element_order/9", entry.id
     assert_equal "Atom elements in an extension element", entry.title.to_s
     assert_equal Time.parse("2006-01-26T09:20:09Z"), entry.updated
-    
+
     assert_alternate_href(entry, "http://www.snellspace.com/public/alternate")
   end
 

data/test/conformance/title.rb

@@ -25,18 +25,18 @@ class TestTitleConformance < Test::Unit::TestCase
     feed.update!
 
     entry = feed.entries.first
-    assert_equal "html", entry.title["type"] 
+    assert_equal "html", entry.title["type"]
     assert_equal "&lt;title>", entry.title.html
   end
 
   def test_html_entity
     url = "http://atomtests.philringnalda.com/tests/item/title/html-entity.atom"
-    
+
     feed = Atom::Feed.new(url)
     feed.update!
 
     entry = feed.entries.first
-    assert_equal "html", entry.title["type"] 
+    assert_equal "html", entry.title["type"]
     assert_equal "&lt;title>", entry.title.html
   end
 
@@ -47,7 +47,7 @@ class TestTitleConformance < Test::Unit::TestCase
     feed.update!
 
     entry = feed.entries.first
-    assert_equal "html", entry.title["type"] 
+    assert_equal "html", entry.title["type"]
     assert_equal "&lt;title>", entry.title.html
   end
 
@@ -78,7 +78,7 @@ class TestTitleConformance < Test::Unit::TestCase
 
     feed = Atom::Feed.new(url)
     feed.update!
-    
+
     entry = feed.entries.first
     assert_equal "text", entry.title["type"]
     assert_equal "&lt;title&gt;", entry.title.html
@@ -86,10 +86,10 @@ class TestTitleConformance < Test::Unit::TestCase
 
   def test_xhtml_entity
     url = "http://atomtests.philringnalda.com/tests/item/title/xhtml-entity.atom"
-    
+
     feed = Atom::Feed.new(url)
     feed.update!
-    
+
     entry = feed.entries.first
     assert_equal "xhtml", entry.title["type"]
     assert_equal "&lt;title>", entry.title.html
@@ -97,10 +97,10 @@ class TestTitleConformance < Test::Unit::TestCase
 
   def test_xhtml_ncr
     url = "http://atomtests.philringnalda.com/tests/item/title/xhtml-ncr.atom"
-    
+
     feed = Atom::Feed.new(url)
     feed.update!
-    
+
     entry = feed.entries.first
     assert_equal "xhtml", entry.title["type"]
     assert_equal "&#60;title>", entry.title.html