feedtools 0.2.26 → 0.2.27

data/lib/feed_tools/vendor/htree.rb

@@ -1,97 +0,0 @@
-#
-# = 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

@@ -1,10 +0,0 @@
-# :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

@@ -1,67 +0,0 @@
-# :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

@@ -1,27 +0,0 @@
-# :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

@@ -1,149 +0,0 @@
-# :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

@@ -1,262 +0,0 @@
-# :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: