feedtools 0.1.0 → 0.2.0

data/lib/feed_tools/vendor/builder.rb

@@ -9,5 +9,7 @@
 # above copyright notice is included.
 #++
 
+# :stopdoc:
 require 'builder/xmlmarkup'
 require 'builder/xmlevents'
+# :startdoc:

data/lib/feed_tools/vendor/builder/blankslate.rb

@@ -8,6 +8,7 @@
 # above copyright notice is included.
 #++
 
+# :stopdoc:
 module Builder #:nodoc:
 
   # BlankSlate provides an abstract base class with no predefined
@@ -51,3 +52,4 @@ class Object #:nodoc:
     end
   end
 end
+# :startdoc:

data/lib/feed_tools/vendor/builder/xmlbase.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-
+# :stopdoc:
 require 'builder/blankslate'
 
 module Builder #:nodoc:
@@ -141,3 +141,4 @@ module Builder #:nodoc:
     end
   end
 end
+# :startdoc:

data/lib/feed_tools/vendor/builder/xmlevents.rb

@@ -9,6 +9,7 @@
 # above copyright notice is included.
 #++
 
+# :stopdoc:
 require 'builder/xmlmarkup'
 
 module Builder
@@ -61,3 +62,4 @@ module Builder
   end
 
 end
+# :startdoc:

data/lib/feed_tools/vendor/builder/xmlmarkup.rb

@@ -11,9 +11,10 @@
 # Provide a flexible and easy to use Builder for creating XML markup.
 # See XmlBuilder for usage details.
 
+# :stopdoc:
 require 'builder/xmlbase'
 
-module Builder
+module Builder #:nodoc:
 
   # Create XML markup easily.  All (well, almost all) methods sent to
   # an XmlMarkup object will be translated to the equivalent XML
@@ -157,7 +158,7 @@ module Builder
   #       xml.stong("text")
   #     }
   #
-  class XmlMarkup < XmlBase
+  class XmlMarkup < XmlBase #:nodoc:
 
     # Create an XML markup builder.  Parameters are specified by an
     # option hash.
@@ -295,3 +296,4 @@ module Builder
   end
 
 end
+# :startdoc:

data/lib/feed_tools/vendor/htree.rb

@@ -0,0 +1,97 @@
+#
+# = htree.rb
+#
+# HTML/XML document tree
+#
+# Author:: Tanaka Akira <akr@m17n.org>
+#
+# == Features
+#
+# - Permissive unified HTML/XML parser
+# - byte-to-byte round-tripping unparser
+# - XML namespace support
+# - Dedicated class for escaped string.  This ease sanitization.
+# - XHTML/XML generator
+# - template engine: link:files/htree/template_rb.html
+# - recursive template expansion
+# - REXML tree generator: link:files/htree/rexml_rb.html
+#
+# == Example
+#
+# The following one-liner prints parsed tree object.
+#
+#   % ruby -rhtree -e 'pp HTree(ARGF)' html-file
+#
+# The following two-line script convert HTML to XHTML.
+#
+#   require 'htree'
+#   HTree(STDIN).display_xml
+#
+# The conversion method to REXML is provided as to_rexml.
+#
+#     HTree(...).to_rexml
+#
+# == Module/Class Hierarchy
+#
+# * HTree
+#   * HTree::Name
+#   * HTree::Context
+#   * HTree::Location
+#   * HTree::Node
+#     * HTree::Doc
+#     * HTree::Elem
+#     * HTree::Text
+#     * HTree::XMLDecl
+#     * HTree::DocType
+#     * HTree::ProcIns
+#     * HTree::Comment
+#     * HTree::BogusETag
+# * HTree::Error
+#
+# == Method Summary
+#
+# HTree provides following methods.
+#
+# - Parsing Methods
+#   - HTree(<i>html_string</i>) -> HTree::Doc
+#   - HTree.parse(<i>input</i>) -> HTree::Doc
+#
+# - Generation Methods
+#   - HTree::Node#display_xml -> STDOUT
+#   - HTree::Node#display_xml(<i>out</i>) -> <i>out</i>
+#   - HTree::Node#display_xml(<i>out</i>, <i>encoding</i>) -> <i>out</i>
+#   - HTree::Text#to_s -> String
+#
+# - Template Methods
+#   - HTree.expand_template{<i>template_string</i>} -> STDOUT
+#   - HTree.expand_template(<i>out</i>){<i>template_string</i>} -> <i>out</i>
+#   - HTree.expand_template(<i>out</i>, <i>encoding</i>){<i>template_string</i>} -> <i>out</i>
+#   - HTree.compile_template(<i>template_string</i>) -> Module
+#   - HTree{<i>template_string</i>} -> HTree::Doc
+#
+# - Traverse Methods
+#   - HTree::Elem#attributes -> Hash[HTree::Name -> HTree::Text]
+#   - HTree::Elem::Location#attributes -> Hash[HTree::Name -> HTree::Location]
+#
+# - Predicate Methods
+#   - HTree::Traverse#doc? -> true or false
+#   - HTree::Traverse#elem? -> true or false
+#   - HTree::Traverse#text? -> true or false
+#   - HTree::Traverse#xmldecl? -> true or false
+#   - HTree::Traverse#doctype? -> true or false
+#   - HTree::Traverse#procins? -> true or false
+#   - HTree::Traverse#comment? -> true or false
+#   - HTree::Traverse#bogusetag? -> true or false
+#
+# - REXML Tree Generator
+#   - HTree::Node#to_rexml -> REXML::Child
+
+require 'htree/parse'
+require 'htree/extract_text'
+require 'htree/equality'
+require 'htree/inspect'
+require 'htree/display'
+require 'htree/loc'
+require 'htree/traverse'
+require 'htree/template'
+require 'htree/rexml'

data/lib/feed_tools/vendor/htree/container.rb

@@ -0,0 +1,10 @@
+# :stopdoc:
+require 'htree/modules'
+
+module HTree::Container # :nodoc:
+  # +children+ returns children nodes as an array.
+  def children
+    @children.dup
+  end
+end
+# :startdoc:

data/lib/feed_tools/vendor/htree/context.rb

@@ -0,0 +1,67 @@
+# :stopdoc:
+module HTree
+  class Context
+    DefaultNamespaces = {'xml'=>'http://www.w3.org/XML/1998/namespace'}
+    DefaultNamespaces.default = ""
+    DefaultNamespaces.freeze
+
+    # The optional argument `namespaces' should be a hash or nil.
+    # HTree::DefaultNamespaces is used if nil is specified.
+    #
+    # If it is a hash, its key should be nil or a string.
+    # nil means default namespace.
+    # The string means some prefix which must not be empty.
+    #
+    # The hash value should be a string.
+    # The empty string "" means unbound namespace.
+    def initialize(namespaces=nil)
+      namespaces ||= DefaultNamespaces
+      namespaces.each_pair {|k, v|
+        check_namespace_prefix(k)
+        check_namespace_uri(v)
+      }
+      namespaces = namespaces.dup.freeze unless namespaces.frozen?
+      @namespaces = namespaces
+    end
+    attr_reader :namespaces
+
+    # return a namespace URI corresponding to _prefix_.
+    # It returns nil if _prefix_ is not defined.
+    def namespace_uri(prefix)
+      @namespaces[prefix]
+    end
+
+    # generate a new Context object which namespaces are substituted by
+    # a hash _declared_namespaces_.
+    def subst_namespaces(declared_namespaces)
+      namespaces = @namespaces.dup
+      declared_namespaces.each {|k, v|
+        check_namespace_prefix(k)
+        check_namespace_uri(v)
+        namespaces[k] = v
+      }
+      if namespaces == @namespaces
+        self
+      else
+        Context.new(namespaces)
+      end
+    end
+
+    private
+    def check_namespace_prefix(k)
+      unless (String === k && !k.empty?) || k == nil
+        raise ArgumentError, "invalid namespace prefix: #{k.inspect}"
+      end
+    end
+
+    def check_namespace_uri(v)
+      unless String === v
+        raise ArgumentError, "invalid namespace URI: #{v.inspect}"
+      end
+    end
+  end
+
+  DefaultContext = Context.new
+  HTMLContext = DefaultContext.subst_namespaces(nil=>"http://www.w3.org/1999/xhtml")
+end
+# :startdoc:

data/lib/feed_tools/vendor/htree/display.rb

@@ -0,0 +1,27 @@
+# :stopdoc:
+require 'htree/output'
+
+module HTree
+  module Node
+    # HTree::Node#display_xml prints the node as XML.
+    #
+    # The first optional argument, <i>out</i>,
+    # specifies output target.
+    # It should respond to <tt><<</tt>.
+    # If it is not specified, $stdout is used.
+    #
+    # The second optional argument, <i>encoding</i>,
+    # specifies output MIME charset (character encoding).
+    # If it is not specified, HTree::Encoder.internal_charset is used.
+    #
+    # HTree::Node#display_xml returns <i>out</i>.
+    def display_xml(out=$stdout, encoding=HTree::Encoder.internal_charset)
+      encoder = HTree::Encoder.new(encoding)
+      self.output(encoder, HTree::DefaultContext)
+      # don't call finish_with_xmldecl because self already has a xml decl.
+      out << encoder.finish
+      out
+    end
+  end
+end
+# :startdoc:

data/lib/feed_tools/vendor/htree/doc.rb

@@ -0,0 +1,149 @@
+# :stopdoc:
+require 'htree/modules'
+require 'htree/container'
+
+module HTree
+  class Doc
+    class << self
+      alias new! new
+    end
+
+    # The arguments should be a sequence of follows.
+    # [String object] specified string is converted to HTree::Text.
+    # [HTree::Node object] used as a child.
+    # [HTree::Doc object]
+    #   used as children.
+    #   It is expanded except HTree::XMLDecl and HTree::DocType objects.
+    # [Array of String, HTree::Node and HTree::Doc] used as children.
+    #
+    def Doc.new(*args)
+      children = []
+      args.each {|arg|
+        arg = arg.to_node if HTree::Location === arg
+        case arg
+        when Array
+          arg.each {|a|
+            a = a.to_node if HTree::Location === a
+            case a
+            when HTree::Doc
+              children.concat(a.children.reject {|c|
+                HTree::XMLDecl === c || HTree::DocType === c
+              })
+            when HTree::Node
+              children << a
+            when String
+              children << Text.new(a)
+            else
+              raise TypeError, "unexpected argument: #{arg.inspect}"
+            end
+          }
+        when HTree::Doc
+          children.concat(arg.children.reject {|c|
+            HTree::XMLDecl === c || HTree::DocType === c
+          })
+        when HTree::Node
+          children << arg
+        when String
+          children << Text.new(arg)
+        else
+          raise TypeError, "unexpected argument: #{arg.inspect}"
+        end
+      }
+      new!(children)
+    end
+
+    def initialize(children=[]) # :notnew:
+      @children = children.dup.freeze
+      unless @children.all? {|c| c.kind_of?(HTree::Node) and !c.kind_of?(HTree::Doc) }
+        unacceptable = @children.reject {|c| c.kind_of?(HTree::Node) and !c.kind_of?(HTree::Doc) }
+        unacceptable = unacceptable.map {|uc| uc.inspect }.join(', ')
+        raise TypeError, "Unacceptable document child: #{unacceptable}"
+      end
+    end 
+
+    def get_subnode_internal(index) # :nodoc:
+      unless Integer === index
+        raise TypeError, "invalid index: #{index.inspect}"
+      end
+      if index < 0 || @children.length <= index
+        nil
+      else
+        @children[index]
+      end
+    end
+
+    #   doc.subst_subnode(pairs) -> doc
+    #
+    # The argument _pairs_ should be a hash or an assocs.
+    # Its key should be an integer which means an index for children.
+    #
+    # Its value should be one of follows.
+    # [HTree::Node object] specified object is used as is.
+    # [String object] specified string is converted to HTree::Text
+    # [Array of above] specified HTree::Node and String is used in that order.
+    # [nil] delete corresponding node.
+    #
+    #   d = HTree('<a/><b/><c/>')        
+    #   p d.subst_subnode({0=>HTree('<x/>'), 2=>HTree('<z/>')})
+    #   p d.subst_subnode([[0,HTree('<x/>')], [2,HTree('<z/>')]])
+    #   # =>
+    #   #<HTree::Doc {emptyelem <x>} {emptyelem <b>} {emptyelem <z>}>
+    #   #<HTree::Doc {emptyelem <x>} {emptyelem <b>} {emptyelem <z>}>
+    #
+    def subst_subnode(pairs)
+      hash = {}
+      pairs.each {|index, value|
+        unless Integer === index
+          raise TypeError, "invalid index: #{index.inspect}"
+        end
+        value = value.to_node if HTree::Location === value
+        case value
+        when Node
+          value = [value]
+        when String
+          value = [value]
+        when Array
+          value = value.dup
+        when nil
+          value = []
+        else
+          raise TypeError, "invalid value: #{value.inspect}"
+        end
+        value.map! {|v|
+          v = v.to_node if HTree::Location === v
+          case v
+          when Node
+            v
+          when String
+            Text.new(v)
+          else
+            raise TypeError, "invalid value: #{v.inspect}"
+          end
+        }
+        if !hash.include?(index)
+          hash[index] = []
+        end
+        hash[index].concat value
+      }
+
+      children_left = []
+      children = @children.dup
+      children_right = []
+
+      hash.keys.sort.each {|index|
+        value = hash[index]
+        if index < 0
+          children_left << value
+        elsif children.length <= index
+          children_right << value
+        else
+          children[index] = value
+        end
+      }
+
+      children = [children_left, children, children_right].flatten.compact
+      Doc.new(children)
+    end
+  end 
+end
+# :startdoc:

data/lib/feed_tools/vendor/htree/elem.rb

@@ -0,0 +1,262 @@
+# :stopdoc:
+require 'htree/modules'
+require 'htree/tag'
+require 'htree/context'
+require 'htree/container'
+
+module HTree
+  class Elem
+    class << self
+      alias new! new
+    end
+
+    # The first argument _name_ should be an instance of String or HTree::Name.
+    #
+    # The rest of arguments should be a sequence of follows.
+    # [Hash object] used as attributes.
+    # [String object] specified string is converted to HTree::Text.
+    # [HTree::Node object] used as a child.
+    # [HTree::Doc object]
+    #   used as children.
+    #   It is expanded except HTree::XMLDecl and HTree::DocType objects.
+    # [Array of String, HTree::Node, HTree::Doc] used as children.
+    # [HTree::Context object]
+    #   used as as context which represents XML namespaces.
+    #   This should apper once at most.
+    #
+    # HTree::Location object is accepted just as HTree::Node.
+    #
+    # If the rest arguments consists only
+    # Hash and HTree::Context, empty element is created.
+    #
+    #   p HTree::Elem.new("e").empty_element?     # => true
+    #   p HTree::Elem.new("e", []).empty_element? # => false
+    def Elem.new(name, *args)
+      attrs = []
+      children = []
+      context = nil
+      args.each {|arg|
+        arg = arg.to_node if HTree::Location === arg
+        case arg
+        when Context
+          raise ArgumentError, "multiple context" if context
+          context = arg
+        when Hash
+          arg.each {|k, v| attrs << [k, v] }
+        when Array
+          arg.each {|a|
+            a = a.to_node if HTree::Location === a
+            case a
+            when HTree::Doc
+              children.concat(a.children.reject {|c|
+                HTree::XMLDecl === c || HTree::DocType === c
+              })
+            when HTree::Node
+              children << a
+            when String
+              children << Text.new(a)
+            else
+              raise TypeError, "unexpected argument: #{arg.inspect}"
+            end
+          }
+        when HTree::Doc
+          children.concat(arg.children.reject {|c|
+            HTree::XMLDecl === c || HTree::DocType === c
+          })
+        when HTree::Node
+          children << arg
+        when String
+          children << Text.new(arg)
+
+        else
+          raise TypeError, "unexpected argument: #{arg.inspect}"
+        end
+      }
+      context ||= DefaultContext
+      if children.empty? && args.all? {|arg| Hash === arg || Context === arg }
+        children = nil
+      end
+      new!(STag.new(name, attrs, context), children)
+    end
+
+    def initialize(stag, children=nil, etag=nil) # :notnew:
+      unless stag.class == STag
+        raise TypeError, "HTree::STag expected: #{stag.inspect}"
+      end
+      unless !children || children.all? {|c| c.kind_of?(HTree::Node) and !c.kind_of?(HTree::Doc) }
+        unacceptable = children.reject {|c| c.kind_of?(HTree::Node) and !c.kind_of?(HTree::Doc) }
+        unacceptable = unacceptable.map {|uc| uc.inspect }.join(', ')
+        raise TypeError, "Unacceptable element child: #{unacceptable}"
+      end
+      unless !etag || etag.class == ETag
+        raise TypeError, "HTree::ETag expected: #{etag.inspect}"
+      end
+      @stag = stag
+      @children = (children ? children.dup : []).freeze
+      @empty = children == nil && etag == nil
+      @etag = etag
+    end
+
+    def context; @stag.context end
+
+    # +element_name+ returns the name of the element name as a Name object.
+    def element_name() @stag.element_name end
+
+    def empty_element?
+      @empty
+    end
+
+    def each_attribute(&block) # :yields: attr_name, attr_text
+      @stag.each_attribute(&block)
+    end
+
+    def get_subnode_internal(index) # :nodoc:
+      case index
+      when String
+        name = Name.parse_attribute_name(index, DefaultContext)
+        update_attribute_hash[name.universal_name]
+      when Name
+        update_attribute_hash[index.universal_name]
+      when Integer
+        if index < 0 || @children.length <= index
+          nil
+        else
+          @children[index]
+        end
+      else
+        raise TypeError, "invalid index: #{index.inspect}"
+      end
+    end
+
+    # call-seq:
+    #   elem.subst_subnode(pairs) -> elem
+    #
+    # The argument _pairs_ should be a hash or an assocs.
+    #
+    # The key of pairs should be one of following.
+    # [HTree::Name or String object] attribute name.
+    # [Integer object] child index.
+    #
+    # The value of pairs should be one of follows.
+    # [HTree::Node object] specified object is used as is.
+    # [String object] specified string is converted to HTree::Text
+    # [Array of above] specified HTree::Node and String is used in that order.
+    # [nil] delete corresponding node.
+    #
+    #   e = HTree('<r><a/><b/><c/></r>').root
+    #   p e.subst_subnode({0=>HTree('<x/>'), 2=>HTree('<z/>')})  
+    #   p e.subst_subnode([[0, HTree('<x/>')], [2,HTree('<z/>')]])
+    #   # =>
+    #   {elem <r> {emptyelem <x>} {emptyelem <b>} {emptyelem <z>}}
+    #   {elem <r> {emptyelem <x>} {emptyelem <b>} {emptyelem <z>}}
+    #
+    def subst_subnode(pairs)
+      hash = {}
+      pairs.each {|index, value|
+        case index
+        when Name, Integer
+        when String
+          index = Name.parse_attribute_name(index, DefaultContext)
+        else
+          raise TypeError, "invalid index: #{index.inspect}"
+        end
+        value = value.to_node if HTree::Location === value
+        case value
+        when Node
+          value = [value]
+        when String
+          value = [value]
+        when Array
+          value = value.dup
+        when nil
+          value = []
+        else
+          raise TypeError, "invalid value: #{value.inspect}"
+        end
+        value.map! {|v|
+          v = v.to_node if HTree::Location === v
+          case v
+          when Node
+            v
+          when String
+            Text.new(v)
+          else
+            raise TypeError, "invalid value: #{v.inspect}"
+          end
+        }
+        if !hash.include?(index)
+          hash[index] = []
+        end
+        hash[index].concat value
+      }
+
+      attrs = []
+      @stag.attributes.each {|k, v|
+        if hash.include? k
+          v = hash[k]
+          if !v.empty?
+            attrs << {k=>Text.concat(*v)}
+          end
+          hash.delete k
+        else
+          attrs << {k=>v}
+        end
+      }
+      hash.keys.each {|k|
+        if Name === k
+          v = hash[k]
+          if !v.empty?
+            attrs << {k=>Text.concat(*v)}
+          end
+          hash.delete k
+        end
+      }
+
+      children_left = []
+      children = @children.dup
+      children_right = []
+
+      hash.keys.sort.each {|index|
+        value = hash[index]
+        if index < 0
+          children_left << value
+        elsif children.length <= index
+          children_right << value
+        else
+          children[index] = value
+        end
+      }
+
+      children = [children_left, children, children_right].flatten
+
+      if children.empty? && @empty
+        Elem.new(
+          @stag.element_name,
+          @stag.context,
+          *attrs)
+      else 
+        Elem.new(
+          @stag.element_name,
+          @stag.context,
+          children,
+          *attrs)
+      end
+    end
+  end 
+
+  module Elem::Trav
+    private
+    def update_attribute_hash
+      if defined?(@attribute_hash)
+        @attribute_hash
+      else
+        h = {}
+        each_attribute {|name, text|
+          h[name.universal_name] = text
+        }
+        @attribute_hash = h
+      end
+    end
+  end
+end
+# :startdoc: