libxml-ruby 2.0.0-x86-mingw32

data/lib/libxml/error.rb

@@ -0,0 +1,90 @@
+# encoding: UTF-8
+
+module LibXML
+  module XML
+    class Error
+      # Verbose error handler
+      VERBOSE_HANDLER = lambda do |error|
+        STDERR << error.to_s << "\n"
+        STDERR.flush
+      end
+
+      # Quiet error handler
+      QUIET_HANDLER = lambda do |error|
+      end
+      
+      def ==(other)
+        eql?(other)
+      end
+      
+      def eql?(other)
+        self.code == other.code and
+        self.domain == other.domain and
+        self.message == other.message and
+        self.level == other.level and
+        self.file == other.file and
+        self.line == other.line and
+        self.str1 == other.str1 and
+        self.str2 == other.str2 and
+        self.str3 == other.str3 and
+        self.int1 == other.int1 and
+        self.int2 == other.int2 and
+        self.ctxt == other.ctxt and
+        self.node == other.node
+      end
+
+      def level_to_s
+        case self.level
+          when NONE
+            ''
+          when WARNING
+            'Warning:'
+          when ERROR
+            'Error:'
+          when FATAL
+            'Fatal error:'
+        end
+      end
+
+      def domain_to_s
+        const_map = Hash.new
+        domains = self.class.constants.grep(/XML_FROM/)
+        domains.each do |domain|
+          human_name = domain.gsub(/XML_FROM_/, '')
+          const_map[self.class.const_get(domain)] = human_name
+        end
+
+        const_map[self.domain]
+      end
+
+      def code_to_s
+        const_map = Hash.new
+        codes = self.class.constants - 
+                self.class.constants.grep(/XML_FROM/) -
+                ["XML_ERR_NONE", "XML_ERR_WARNING", "XML_ERR_ERROR", "XML_ERR_FATAL"]
+
+        
+        codes.each do |code|
+          human_name = code.gsub(/XML_ERR_/, '')
+          const_map[self.class.const_get(code)] = human_name
+        end
+
+        const_map[self.code]
+      end
+
+      def to_s
+        msg = super
+        msg = msg ? msg.strip: ''
+
+        if self.line
+          sprintf("%s %s at %s:%d.", self.level_to_s, msg,
+                                     self.file, self.line)
+        else
+          sprintf("%s %s.", self.level_to_s, msg)
+        end
+      end
+    end
+  end
+end
+
+LibXML::XML::Error.set_handler(&LibXML::XML::Error::VERBOSE_HANDLER)

data/lib/libxml/hpricot.rb

@@ -0,0 +1,78 @@
+# encoding: UTF-8
+
+## Provide hpricot API for libxml.  Provided by Michael Guterl,
+## inspired by http://thebogles.com/blog/an-hpricot-style-interface-to-libxml
+#
+#class String
+#  def to_libxml_doc
+#    xp = XML::Parser.new
+#    xp.string = self
+#    xp.parse
+#  end
+#end
+#
+#module LibXML
+#  module XML
+#    class Document
+#      alias :search :find
+#    end
+#
+#    class Node
+#      # find the child node with the given xpath
+#      def at(xpath)
+#        self.find_first(xpath)
+#      end
+#
+#      # find the array of child nodes matching the given xpath
+#      def search(xpath)
+#        results = self.find(xpath).to_a
+#        if block_given?
+#          results.each do |result|
+#            yield result
+#          end
+#        end
+#        return results
+#      end
+#
+#      def /(xpath)
+#        search(xpath)
+#      end
+#
+#      # return the inner contents of this node as a string
+#      def inner_xml
+#        child.to_s
+#      end
+#
+#      # alias for inner_xml
+#      def inner_html
+#        inner_xml
+#      end
+#
+#      # return this node and its contents as an xml string
+#      def to_xml
+#        self.to_s
+#      end
+#
+#      # alias for path
+#      def xpath
+#        self.path
+#      end
+#
+#      def find_with_default_ns(xpath_expr, namespace=nil)
+#        find_base(xpath_expr, namespace || default_namespaces)
+#      end
+#
+#      def find_first_with_default_ns(xpath_expr, namespace=nil)
+#        find_first_base(xpath_expr, namespace || default_namespaces)
+#      end
+#
+##      alias_method :find_base, :find unless method_defined?(:find_base)
+##      alias_method :find, :find_with_default_ns
+##      alias_method :find_first_base, :find_first unless method_defined?(:find_first_base)
+##      alias_method :find_first, :find_first_with_default_ns
+##      alias :child? :first?
+##      alias :children? :first?
+##      alias :child :first
+#    end
+#  end
+#end

data/lib/libxml/html_parser.rb

@@ -0,0 +1,96 @@
+# encoding: UTF-8
+
+module LibXML
+  module XML
+    class HTMLParser
+      # call-seq:
+      #    XML::HTMLParser.file(path) -> XML::HTMLParser
+      #    XML::HTMLParser.file(path, :encoding => XML::Encoding::UTF_8,
+      #                           :options => XML::HTMLParser::Options::NOENT) -> XML::HTMLParser
+      #
+      # Creates a new parser by parsing the specified file or uri.
+      #
+      # You may provide an optional hash table to control how the
+      # parsing is performed.  Valid options are:
+      #
+      #  encoding - The document encoding, defaults to nil. Valid values
+      #             are the encoding constants defined on XML::Encoding.
+      #  options - Parser options.  Valid values are the constants defined on
+      #            XML::HTMLParser::Options.  Mutliple options can be combined
+      #            by using Bitwise OR (|).
+      def self.file(path, options = {})
+        context = XML::HTMLParser::Context.file(path)
+        context.encoding = options[:encoding] if options[:encoding]
+        context.options = options[:options] if options[:options]
+        self.new(context)
+      end
+
+      # call-seq:
+      #    XML::HTMLParser.io(io) -> XML::HTMLParser
+      #    XML::HTMLParser.io(io, :encoding => XML::Encoding::UTF_8,
+      #                       :options => XML::HTMLParser::Options::NOENT
+      #                       :base_uri="http://libxml.org") -> XML::HTMLParser
+      #
+      # Creates a new reader by parsing the specified io object.
+      #
+      # Parameters:
+      #
+      #  io - io object that contains the xml to parser
+      #  base_uri - The base url for the parsed document.
+      #  encoding - The document encoding, defaults to nil. Valid values
+      #             are the encoding constants defined on XML::Encoding.
+      #  options - Parser options.  Valid values are the constants defined on
+      #            XML::HTMLParser::Options.  Mutliple options can be combined
+      #            by using Bitwise OR (|).
+      def self.io(io, options = {})
+        context = XML::HTMLParser::Context.io(io)
+        context.base_uri = options[:base_uri] if options[:base_uri]
+        context.encoding = options[:encoding] if options[:encoding]
+        context.options = options[:options] if options[:options]
+        self.new(context)
+      end
+
+      # call-seq:
+      #    XML::HTMLParser.string(string)
+      #    XML::HTMLParser.string(string, :encoding => XML::Encoding::UTF_8,
+      #                               :options => XML::HTMLParser::Options::NOENT
+      #                               :base_uri="http://libxml.org") -> XML::HTMLParser
+      #
+      # Creates a new parser by parsing the specified string.
+      #
+      # You may provide an optional hash table to control how the
+      # parsing is performed.  Valid options are:
+      #
+      #  base_uri - The base url for the parsed document.
+      #  encoding - The document encoding, defaults to nil. Valid values
+      #             are the encoding constants defined on XML::Encoding.
+      #  options - Parser options.  Valid values are the constants defined on
+      #            XML::HTMLParser::Options.  Mutliple options can be combined
+      #            by using Bitwise OR (|).
+      def self.string(string, options = {})
+        context = XML::HTMLParser::Context.string(string)
+        context.base_uri = options[:base_uri] if options[:base_uri]
+        context.encoding = options[:encoding] if options[:encoding]
+        context.options = options[:options] if options[:options]
+        self.new(context)
+      end
+
+      # :enddoc:
+
+      def file=(value)
+        warn("XML::HTMLParser#file is deprecated.  Use XML::HTMLParser.file instead")
+        @context = XML::HTMLParser::Context.file(value)
+      end
+
+      def io=(value)
+        warn("XML::HTMLParser#io is deprecated.  Use XML::HTMLParser.io instead")
+        @context = XML::HTMLParser::Context.io(value)
+      end
+
+      def string=(value)
+        warn("XML::HTMLParser#string is deprecated.  Use XML::HTMLParser.string instead")
+        @context = XML::HTMLParser::Context.string(value)
+      end
+    end
+  end
+end

data/lib/libxml/namespace.rb

@@ -0,0 +1,62 @@
+# encoding: UTF-8
+
+module LibXML
+  module XML
+    class Namespace
+      include Comparable
+      include Enumerable
+
+      # call-seq:
+      #   namespace1 <=> namespace2
+      #
+      # Compares two namespace objects.  Namespace objects are
+      # considered equal if their prefixes and hrefs are the same.
+      def <=>(other)
+        if self.prefix.nil? and other.prefix.nil?
+          self.href <=> other.href
+        elsif self.prefix.nil?
+          -1
+        elsif other.prefix.nil?
+          1
+        else
+          self.prefix <=> other.prefix
+        end
+      end
+
+      # call-seq:
+      #   namespace.each {|ns| .. }
+      #
+      # libxml stores namespaces in memory as a linked list.
+      # Use the each method to iterate over the list.  Note
+      # the first namespace in the loop is the current namespace.
+      #
+      # Usage:
+      #   namespace.each do |ns|
+      #     ..
+      #   end
+      def each
+        ns = self
+
+        while ns
+          yield ns
+          ns = ns.next
+        end
+      end
+
+      # call-seq:
+      #   namespace.to_s -> "string"
+      #
+      # Returns the string represenation of a namespace.
+      #
+      # Usage:
+      #   namespace.to_s
+      def to_s
+        if self.prefix
+          "#{self.prefix}:#{self.href}"
+        else
+          self.href
+        end
+      end
+    end
+  end
+end

data/lib/libxml/namespaces.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+
+module LibXML
+  module XML
+    class Namespaces
+      # call-seq:
+      #   namespace.default -> XML::Namespace
+      #
+      # Returns the default namespace for this node or nil.
+      #
+      # Usage:
+      #   doc = XML::Document.string('<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/"/>')
+      #   ns = doc.root.namespaces.default_namespace
+      #   assert_equal(ns.href, 'http://schemas.xmlsoap.org/soap/envelope/')
+      def default
+        find_by_prefix(nil)
+      end
+
+      # call-seq:
+      #   namespace.default_prefix = "string"
+      #
+      # Assigns a name (prefix) to the default namespace.
+      # This makes it much easier to perform XML::XPath
+      # searches.
+      #
+      # Usage:
+      #   doc = XML::Document.string('<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/"/>')
+      #   doc.root.namespaces.default_prefix = 'soap'
+      #   node = doc.root.find_first('soap:Envelope')
+      def default_prefix=(prefix)
+        # Find default prefix
+        ns = find_by_prefix(nil)
+        raise(ArgumentError, "No default namespace was found") unless ns
+        Namespace.new(self.node, prefix, ns.href)
+      end
+    end
+  end
+end

data/lib/libxml/node.rb

@@ -0,0 +1,399 @@
+# encoding: UTF-8
+
+require 'stringio'
+
+module LibXML
+  module XML
+    class Node
+      # Determines whether this node has attributes
+      def attributes?
+        attributes.length > 0
+      end
+      
+      # Create a shallow copy of the node.  To create
+      # a deep copy call Node#copy(true)
+      def clone
+        copy(false)
+      end
+
+      # call-seq:
+      #    node.inner_xml -> "string"
+      #    node.inner_xml(:indent => true, :encoding => 'UTF-8', :level => 0) -> "string"
+      #
+      # Converts a node's children, to a string representation.  To include
+      # the node, use XML::Node#to_s.  For more information about
+      # the supported options, see XML::Node#to_s.
+      def inner_xml(options = Hash.new)
+        io = nil
+        self.each do |node|
+          xml = node.to_s(options)
+          # Create the string IO here since we now know the encoding
+          io = create_string_io(xml) unless io
+          io << xml
+        end
+
+        io.string
+      end
+      
+      # :call-seq:
+      #   node.dup -> XML::Node
+      #
+      # Create a shallow copy of the node.  To create
+      # a deep copy call Node#copy(true)
+      def dup
+        copy(false)
+      end
+    
+      # call-seq:
+      #   node.context(namespaces=nil) -> XPath::Context
+      #
+      # Returns a new XML::XPathContext for the current node.
+      #
+      # Namespaces is an optional array of XML::NS objects
+      def context(nslist = nil)
+        if not self.doc
+          raise(TypeError, "A node must belong to a document before a xpath context can be created")
+        end
+
+        context = XPath::Context.new(self)
+        context.node = self
+        context.register_namespaces_from_node(self)
+        context.register_namespaces_from_node(self.doc.root)
+        context.register_namespaces(nslist) if nslist
+        context
+      end
+
+      # call-seq:
+      #   node.find(namespaces=nil) -> XPath::XPathObject
+      #
+      # Return nodes matching the specified xpath expression.
+      # For more information, please refer to the documentation
+      # for XML::Document#find.
+      #
+      # Namespaces is an optional array of XML::NS objects
+      def find(xpath, nslist = nil)
+        self.context(nslist).find(xpath)
+      end
+    
+      # call-seq:
+      #   node.find_first(namespaces=nil) -> XML::Node
+      #
+      # Return the first node matching the specified xpath expression.
+      # For more information, please refer to the documentation
+      # for the #find method.
+      def find_first(xpath, nslist = nil)
+        find(xpath, nslist).first
+      end
+
+      # call-seq:
+      #   node.namespacess -> XML::Namespaces
+      #   
+      # Returns this node's XML::Namespaces object,
+      # which is used to access the namespaces
+      # associated with this node.
+      def namespaces
+        @namespaces ||= XML::Namespaces.new(self)
+      end
+      
+      # -------  Traversal  ----------------
+      # Iterates over this node's attributes.
+      #
+      #  doc = XML::Document.new('model/books.xml')
+      #  doc.root.each_attr {|attr| puts attr}
+      def each_attr
+        attributes.each do |attr|
+          yield(attr)
+        end
+      end
+      
+      # Iterates over this node's child elements (nodes
+      # that have a node_type == ELEMENT_NODE).
+      #
+      #  doc = XML::Document.new('model/books.xml')
+      #  doc.root.each_element {|element| puts element}
+      def each_element
+        each do |node|
+          yield(node) if node.node_type == ELEMENT_NODE
+        end
+      end
+      
+      # Determines whether this node has a parent node
+      def parent?
+        not parent.nil?
+      end
+    
+      # Determines whether this node has a first node
+      def first?
+        not first.nil?
+      end
+    
+      # Returns this node's children as an array.
+      def children
+        entries
+      end
+    
+      # Determines whether this node has a next node
+      def next?
+        not self.next.nil?
+      end
+    
+      # Determines whether this node has a previous node
+      def prev?
+        not prev.nil?
+      end
+    
+      # Determines whether this node has a last node
+      def last?
+        not last.nil?
+      end
+
+
+      # -------  Node Types  ----------------
+      
+      # Returns this node's type name    
+      def node_type_name
+        case node_type
+          # Most common choices first
+          when ATTRIBUTE_NODE
+            'attribute'
+          when DOCUMENT_NODE
+            'document_xml'
+          when ELEMENT_NODE
+            'element'
+          when TEXT_NODE
+            'text'
+          
+          # Now the rest  
+          when ATTRIBUTE_DECL
+            'attribute_decl'
+          when CDATA_SECTION_NODE
+            'cdata'
+          when COMMENT_NODE
+            'comment'
+          when DOCB_DOCUMENT_NODE
+            'document_docbook'
+          when DOCUMENT_FRAG_NODE
+            'fragment'
+          when DOCUMENT_TYPE_NODE
+            'doctype'
+          when DTD_NODE
+            'dtd'
+          when ELEMENT_DECL
+            'elem_decl'
+          when ENTITY_DECL
+            'entity_decl'
+          when ENTITY_NODE
+            'entity'
+          when ENTITY_REF_NODE
+            'entity_ref'
+          when HTML_DOCUMENT_NODE
+            'document_html'
+          when NAMESPACE_DECL
+            'namespace'
+          when NOTATION_NODE
+            'notation'
+          when PI_NODE
+            'pi'
+          when XINCLUDE_START
+            'xinclude_start'
+          when XINCLUDE_END
+            'xinclude_end'
+          else
+            raise(UnknownType, "Unknown node type: %n", node.node_type);
+        end
+      end
+      
+      # Specifies if this is an attribute node
+      def attribute?
+        node_type == ATTRIBUTE_NODE
+      end
+      
+      # Specifies if this is an attribute declaration node
+      def attribute_decl?
+        node_type == ATTRIBUTE_DECL
+      end
+
+      # Specifies if this is an CDATA node
+      def cdata?
+        node_type == CDATA_SECTION_NODE
+      end
+
+      # Specifies if this is an comment node
+      def comment?
+        node_type == COMMENT_NODE
+      end
+
+      # Specifies if this is an docbook node
+      def docbook_doc?
+        node_type == DOCB_DOCUMENT_NODE
+      end
+
+      # Specifies if this is an docbook node
+      def doctype?
+        node_type == DOCUMENT_TYPE_NODE
+      end
+
+      # Specifies if this is an DOCTYPE node
+      def document?
+        node_type == DOCUMENT_NODE
+      end
+
+      # Specifies if this is an DTD node
+      def dtd?
+        node_type == DTD_NODE
+      end
+
+      # Specifies if this is an element node
+      def element?
+        node_type == ELEMENT_NODE
+      end
+
+      # Specifies if this is an entity node
+      def entity?
+        node_type == ENTITY_NODE
+      end
+
+      # Specifies if this is an element declaration node
+      def element_decl?
+        node_type == ELEMENT_DECL
+      end
+
+      # Specifies if this is an entity reference node
+      def entity_ref?
+        node_type == ENTITY_REF_NODE
+      end
+
+      # Specifies if this is a fragment node
+      def fragment?
+        node_type == DOCUMENT_FRAG_NODE
+      end
+
+      # Specifies if this is a html document node
+      def html_doc?
+        node_type == HTML_DOCUMENT_NODE
+      end
+
+      # Specifies if this is a namespace node (not if it
+      # has a namepsace)
+      def namespace?
+        node_type == NAMESPACE_DECL
+      end
+
+      # Specifies if this is a notation node
+      def notation?
+        node_type == NOTATION_NODE
+      end
+
+      # Specifies if this is a processiong instruction node
+      def pi?
+        node_type == PI_NODE
+      end
+
+      # Specifies if this is a text node
+      def text?
+        node_type == TEXT_NODE
+      end
+      
+      # Specifies if this is an xinclude end node
+      def xinclude_end?
+        node_type == XINCLUDE_END
+      end
+      
+      # Specifies if this is an xinclude start node
+      def xinclude_start?
+        node_type == XINCLUDE_START
+      end
+
+      alias :child? :first?  
+      alias :children? :first?  
+      alias :child :first
+      alias :each_child :each
+
+      # --- Deprecated Output ---
+      # :stopdoc:
+      def dump
+        warn('Node#dump is deprecated.  Use Node#to_s instead.')
+        self.to_s
+      end
+
+      # --- Deprecated DOM Manipulation ---
+      def child_add(node)
+        warn('Node#child_add is deprecated.  Use Node#<< instead.')
+        self << node
+      end
+
+      def child=(node)
+        warn('Node#child= is deprecated.  Use Node#<< instead.')
+        self << node
+      end
+
+      # --- Deprecated Namespaces ---
+      def namespace
+        warn('Node#namespace is deprecated.  Use Node#namespaces instead.')
+        self.namespaces.entries
+      end
+
+      def namespace=(value)
+        warn('Node#namespace= is deprecated.  Use Node#namespaces.namespace= instead.')
+        self.namespaces.namespace = value
+      end
+
+      def namespace_node
+        warn('Node#namespace_node is deprecated.  Use Node#namespaces.namespace instead.')
+        self.namespaces.namespace
+      end
+
+      def ns
+        warn('Node#ns is deprecated.  Use Node#namespaces.namespace instead.')
+        self.namespaces.namespace
+      end
+
+      def ns?
+        warn('Node#ns? is deprecated.  Use !Node#namespaces.namespace.nil? instead.')
+        !self.namespaces.namespace.nil?
+      end
+
+      def ns_def
+        warn('Node#ns_def is deprecated.  Use Node#namespaces.definitions instead.')
+        self.namespaces.definitions
+      end
+
+      def ns_def?
+        warn('Node#ns_def? is deprecated.  Use !Node#namespaces.definitions.nil? instead.')
+        !self.namespaces.definitions.nil?
+      end
+
+      def base
+        warn('Node#base is deprecated.  Use Node#base_uri.')
+        self.base_uri
+      end
+
+      def base=(value)
+        warn('Node#base= is deprecated.  Use Node#base_uri=.')
+        self.base_uri = value
+      end
+
+      def search_ns(prefix)
+        warn('Node#search_ns is deprecated.  Use Node#namespaces.find_by_prefix instead.')
+        self.namespaces.find_by_prefix(prefix)
+      end
+
+      def search_href(href)
+        warn('Node#search_href is deprecated.  Use Node#namespaces.find_by_href instead.')
+        self.namespaces.find_by_href(href)
+      end
+
+      # :startdoc:
+
+      private
+
+      def create_string_io(xml)
+        result = StringIO.new("")
+        if defined?(::Encoding)
+          result.set_encoding(xml.encoding)
+        end
+        result
+      end
+    end
+  end
+end