libxml-ruby 4.1.2 → 6.0.0

data/lib/libxml/document.rb

@@ -1,194 +1,165 @@
-# encoding: UTF-8
-
-module LibXML
-  module XML
-    class Document
-      # call-seq:
-      #    XML::Document.document(document) -> XML::Document
-      #
-      # Creates a new document based on the specified document.
-      #
-      # Parameters:
-      #
-      #  document - A preparsed document.
-      def self.document(value)
-        Parser.document(value).parse
-      end
-
-      # call-seq:
-      #    XML::Document.file(path) -> XML::Document
-      #    XML::Document.file(path, :encoding => XML::Encoding::UTF_8,
-      #                             :options => XML::Parser::Options::NOENT) -> XML::Document
-      #
-      # Creates a new document from 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::Parser::Options.  Mutliple options can be combined
-      #            by using Bitwise OR (|).
-      def self.file(value, options = {})
-        Parser.file(value, options).parse
-      end
-
-      # call-seq:
-      #    XML::Document.io(io) -> XML::Document
-      #    XML::Document.io(io, :encoding => XML::Encoding::UTF_8,
-      #                         :options => XML::Parser::Options::NOENT
-      #                         :base_uri="http://libxml.org") -> XML::Document
-      #
-      # Creates a new document from 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::Parser::Options.  Mutliple options can be combined
-      #            by using Bitwise OR (|).
-      def self.io(value, options = {})
-        Parser.io(value, options).parse
-      end
-
-      # call-seq:
-      #    XML::Document.string(string) -> XML::Document
-      #    XML::Document.string(string, :encoding => XML::Encoding::UTF_8,
-      #                               :options => XML::Parser::Options::NOENT
-      #                               :base_uri="http://libxml.org") -> XML::Document
-      #
-      # Creates a new document from 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::Parser::Options.  Mutliple options can be combined
-      #              by using Bitwise OR (|).
-      def self.string(value, options = {})
-        Parser.string(value, options).parse
-      end
-
-      # Returns a new XML::XPathContext for the document.
-      #
-      # call-seq:
-      #   document.context(namespaces=nil) -> XPath::Context
-      #
-      # Namespaces is an optional array of XML::NS objects
-      def context(nslist = nil)
-        context = XPath::Context.new(self)
-        context.node = self.root
-        context.register_namespaces_from_node(self.root)
-        context.register_namespaces(nslist) if nslist
-        context
-      end
-
-      # Return the nodes matching the specified xpath expression, 
-      # optionally using the specified namespace.  For more 
-      # information about working with namespaces, please refer
-      # to the XML::XPath documentation.
-      #
-      # call-seq:
-      #   document.find(xpath, nslist=nil) -> XML::XPath::Object
-      # 
-      # Parameters:
-      # * xpath - The xpath expression as a string
-      # * namespaces - An optional list of namespaces (see XML::XPath for information).
-      #
-      #  document.find('/foo', 'xlink:http://www.w3.org/1999/xlink')
-      #
-      # IMPORTANT - The returned XML::Node::Set must be freed before
-      # its associated document.  In a running Ruby program this will
-      # happen automatically via Ruby's mark and sweep garbage collector.
-      # However, if the program exits, Ruby does not guarantee the order
-      # in which objects are freed
-      # (see http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/17700).
-      # As a result, the associated document may be freed before the node
-      # list, which will cause a segmentation fault.
-      # To avoid this, use the following (non-ruby like) coding style:
-      #
-      #  nodes = doc.find('/header')
-      #  nodes.each do |node|
-      #    ... do stuff ...
-      #  end
-      # #  nodes = nil #  GC.start
-      def find(xpath, nslist = nil)
-        self.context(nslist).find(xpath)
-      end
-    
-      # Return the first node matching the specified xpath expression.
-      # For more information, please refer to the documentation
-      # for XML::Document#find.
-      def find_first(xpath, nslist = nil)
-        find(xpath, nslist).first
-      end
-      
-      # Returns this node's type name    
-      def node_type_name
-        case node_type
-        when XML::Node::DOCUMENT_NODE
-          'document_xml'
-        when XML::Node::DOCB_DOCUMENT_NODE
-          'document_docbook'
-        when XML::Node::HTML_DOCUMENT_NODE
-          'document_html'
-        else
-          raise(UnknownType, "Unknown node type: %n", node.node_type);
-        end
-      end
-      # :enddoc:
-
-      # Specifies if this is an document node
-      def document?
-        node_type == XML::Node::DOCUMENT_NODE
-      end
-
-      # Specifies if this is an docbook node
-      def docbook_doc?
-        node_type == XML::Node::DOCB_DOCUMENT_NODE
-      end
-
-      # Specifies if this is an html node
-      def html_doc?
-        node_type == XML::Node::HTML_DOCUMENT_NODE
-      end
-
-      def dump
-        warn('Document#dump is deprecated.  Use Document#to_s instead.')
-        self.to_s
-      end
-
-      def format_dump
-        warn('Document#format_dump is deprecated.  Use Document#to_s instead.')
-        self.to_s
-      end
-
-      def debug_dump
-        warn('Document#debug_dump is deprecated.  Use Document#debug instead.')
-        self.debug
-      end
-
-      def debug_dump_head
-        warn('Document#debug_dump_head is deprecated.  Use Document#debug instead.')
-        self.debug
-      end
-
-      def debug_format_dump
-        warn('Document#debug_format_dump is deprecated.  Use Document#to_s instead.')
-        self.to_s
-      end
-
-      def reader
-        warn('Document#reader is deprecated.  Use XML::Reader.document(self) instead.')
-        XML::Reader.document(self)
-      end
-    end
-  end
-end  
+# encoding: UTF-8
+
+module LibXML
+  module XML
+    class Document
+      # call-seq:
+      #    XML::Document.document(document) -> XML::Document
+      #
+      # Creates a new document based on the specified document.
+      #
+      # Parameters:
+      #
+      #  document - A preparsed document.
+      def self.document(value)
+        Parser.document(value).parse
+      end
+
+      # call-seq:
+      #    XML::Document.file(path) -> XML::Document
+      #    XML::Document.file(path, encoding: XML::Encoding::UTF_8,
+      #                             options: XML::Parser::Options::NOENT) -> XML::Document
+      #
+      # Creates a new document from the specified file or uri.
+      #
+      # Parameters:
+      #
+      #  path - Path to file
+      #  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::Parser::Options.  Mutliple options can be combined
+      #            by using Bitwise OR (|).
+      def self.file(path, encoding: nil, options: nil)
+        Parser.file(path, encoding: encoding, options: options).parse
+      end
+
+      # call-seq:
+      #    XML::Document.io(io) -> XML::Document
+      #    XML::Document.io(io, :encoding => XML::Encoding::UTF_8,
+      #                         :options => XML::Parser::Options::NOENT
+      #                         :base_uri="http://libxml.org") -> XML::Document
+      #
+      # Creates a new document from 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::Parser::Options.  Mutliple options can be combined
+      #            by using Bitwise OR (|).
+      def self.io(io, base_uri: nil, encoding: nil, options: nil)
+        Parser.io(io, base_uri: base_uri, encoding: encoding, options: options).parse
+      end
+
+      # call-seq:
+      #    XML::Document.string(string) -> XML::Document
+      #    XML::Document.string(string, encoding: XML::Encoding::UTF_8,
+      #                                 options: XML::Parser::Options::NOENT
+      #                                 base_uri: "http://libxml.org") -> XML::Document
+      #
+      # Creates a new document from the specified string.
+      #
+      # Parameters:
+      #
+      #   string - String to parse
+      #   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::Parser::Options.  Mutliple options can be combined
+      #              by using Bitwise OR (|).
+      def self.string(value, base_uri: nil, encoding: nil, options: nil)
+        Parser.string(value, base_uri: base_uri, encoding: encoding, options: options).parse
+      end
+
+      # Returns a new XML::XPathContext for the document.
+      #
+      # call-seq:
+      #   document.context(namespaces=nil) -> XPath::Context
+      #
+      # Namespaces is an optional array of XML::NS objects
+      def context(nslist = nil)
+        context = XPath::Context.new(self)
+        context.node = self.root
+        context.register_namespaces_from_node(self.root)
+        context.register_namespaces(nslist) if nslist
+        context
+      end
+
+      # Return the nodes matching the specified xpath expression, 
+      # optionally using the specified namespace.  For more 
+      # information about working with namespaces, please refer
+      # to the XML::XPath documentation.
+      #
+      # call-seq:
+      #   document.find(xpath, nslist=nil) -> XML::XPath::Object
+      # 
+      # Parameters:
+      # * xpath - The xpath expression as a string
+      # * namespaces - An optional list of namespaces (see XML::XPath for information).
+      #
+      #  document.find('/foo', 'xlink:http://www.w3.org/1999/xlink')
+      #
+      # IMPORTANT - The returned XML::Node::Set must be freed before
+      # its associated document.  In a running Ruby program this will
+      # happen automatically via Ruby's mark and sweep garbage collector.
+      # However, if the program exits, Ruby does not guarantee the order
+      # in which objects are freed
+      # (see http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/17700).
+      # As a result, the associated document may be freed before the node
+      # list, which will cause a segmentation fault.
+      # To avoid this, use the following (non-ruby like) coding style:
+      #
+      #  nodes = doc.find('/header')
+      #  nodes.each do |node|
+      #    ... do stuff ...
+      #  end
+      # #  nodes = nil #  GC.start
+      def find(xpath, nslist = nil)
+        self.context(nslist).find(xpath)
+      end
+    
+      # Return the first node matching the specified xpath expression.
+      # For more information, please refer to the documentation
+      # for XML::Document#find.
+      def find_first(xpath, nslist = nil)
+        find(xpath, nslist).first
+      end
+      
+      # Returns this node's type name    
+      def node_type_name
+        case node_type
+        when XML::Node::DOCUMENT_NODE
+          'document_xml'
+        when XML::Node::DOCB_DOCUMENT_NODE
+          'document_docbook'
+        when XML::Node::HTML_DOCUMENT_NODE
+          'document_html'
+        else
+          raise(UnknownType, "Unknown node type: %n", node.node_type);
+        end
+      end
+      # :enddoc:
+
+      # Specifies if this is an document node
+      def document?
+        node_type == XML::Node::DOCUMENT_NODE
+      end
+
+      # Specifies if this is an docbook node
+      def docbook_doc?
+        node_type == XML::Node::DOCB_DOCUMENT_NODE
+      end
+
+      # Specifies if this is an html node
+      def html_doc?
+        node_type == XML::Node::HTML_DOCUMENT_NODE
+      end
+
+    end
+  end
+end  

data/lib/libxml/error.rb

@@ -1,95 +1,122 @@
-# encoding: UTF-8
-
-module LibXML
-  module XML
-    class Error
-      # Create mapping from domain constant values to keys
-      DOMAIN_CODE_MAP = [:NO_ERROR, :PARSER, :TREE, :NAMESPACE, :DTD, :HTML, :MEMORY,
-                         :OUTPUT, :IO, :FTP, :HTTP, :XINCLUDE, :XPATH, :XPOINTER, :REGEXP,
-                         :DATATYPE, :SCHEMASP, :SCHEMASV, :RELAXNGP, :RELAXNGV, :CATALOG,
-                         :C14N, :XSLT, :VALID, :CHECK, :WRITER, :MODULE, :I18N, :SCHEMATRONV].inject(Hash.new) do |hash, code|
-        if const_defined?(code)
-          hash[const_get(code)] = code
-        end
-        hash
-      end
-
-      # Create mapping from error constant values (so need to remove domain_codes) to keys
-      ERROR_CODE_MAP = Hash.new.tap do |map|
-        (constants -
-         DOMAIN_CODE_MAP.values - #Domains
-         [:NONE, :WARNING, :ERROR, :FATAL] # Levels
-         ).each do |code|
-          map[const_get(code)] = code
-        end
-      end
-      
-      # 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
-      rescue
-        false
-      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
-        DOMAIN_CODE_MAP[self.domain].to_s
-      end
-
-      def code_to_s
-        ERROR_CODE_MAP[self.code].to_s
-      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)
+# encoding: UTF-8
+
+module LibXML
+  module XML
+    class Error
+      # Create mapping from domain constant values to keys
+      DOMAIN_CODE_MAP = [:NO_ERROR, :PARSER, :TREE, :NAMESPACE, :DTD, :HTML, :MEMORY,
+                         :OUTPUT, :IO, :FTP, :HTTP, :XINCLUDE, :XPATH, :XPOINTER, :REGEXP,
+                         :DATATYPE, :SCHEMASP, :SCHEMASV, :RELAXNGP, :RELAXNGV, :CATALOG,
+                         :C14N, :XSLT, :VALID, :CHECK, :WRITER, :MODULE, :I18N, :SCHEMATRONV].inject(Hash.new) do |hash, code|
+        if const_defined?(code)
+          hash[const_get(code)] = code
+        end
+        hash
+      end
+
+      # Create mapping from error constant values (so need to remove domain_codes) to keys
+      ERROR_CODE_MAP = Hash.new.tap do |map|
+        (constants -
+         DOMAIN_CODE_MAP.values - #Domains
+         [:NONE, :WARNING, :ERROR, :FATAL] # Levels
+         ).each do |code|
+          map[const_get(code)] = code
+        end
+      end
+
+      # 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
+
+      # call-seq:
+      #   error == other -> true or false
+      #
+      # Returns whether two errors have the same attributes.
+      def ==(other)
+        eql?(other)
+      end
+
+      # call-seq:
+      #   error.eql?(other) -> true or false
+      #
+      # Returns whether two errors have identical code, domain, message,
+      # level, file, line, and all other attributes.
+      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
+      rescue
+        false
+      end
+
+      # call-seq:
+      #   error.level_to_s -> String
+      #
+      # Returns a human-readable string for the error level:
+      # "Warning:", "Error:", "Fatal error:", or "".
+      def level_to_s
+        case self.level
+          when NONE
+            ''
+          when WARNING
+            'Warning:'
+          when ERROR
+            'Error:'
+          when FATAL
+            'Fatal error:'
+        end
+      end
+
+      # call-seq:
+      #   error.domain_to_s -> String
+      #
+      # Returns the name of the error domain (e.g. "PARSER", "XPATH").
+      def domain_to_s
+        DOMAIN_CODE_MAP[self.domain].to_s
+      end
+
+      # call-seq:
+      #   error.code_to_s -> String
+      #
+      # Returns the name of the error code constant.
+      def code_to_s
+        ERROR_CODE_MAP[self.code].to_s
+      end
+
+      # call-seq:
+      #   error.to_s -> String
+      #
+      # Returns a formatted error string including the level, message,
+      # and file/line when available.
+      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)