xmlparser 0.6.81

data/lib/xml/dom2/dombuilderfilter.rb

@@ -0,0 +1,12 @@
+## -*- Ruby -*-
+## XML::DOM::DOMBuilderFilter
+## 2001 by yoshidam
+##
+
+module XML
+  module DOM
+    module DOMBuilderFilter
+      def endElement(element); end
+    end
+  end
+end

data/lib/xml/dom2/domentityresolver.rb

@@ -0,0 +1,13 @@
+## -*- Ruby -*-
+## XML::DOM::DOMEntityResolver
+## 2001 by yoshidam
+##
+
+module XML
+  module DOM
+    module DOMEntityResolver
+      ## DOMInputSource resolveEntity(publicId, systemId)
+      def resolveEntity(publicId, systemId); end
+    end
+  end
+end

data/lib/xml/dom2/domentityresolverimpl.rb

@@ -0,0 +1,37 @@
+## -*- Ruby -*-
+## XML::DOM::DOMEntityResolverImpl
+## 2001 by yoshidam
+##
+
+require 'xml/dom2/domentityresolver'
+require 'xml/dom2/dominputsource'
+
+module XML
+  module DOM
+    class DOMEntityResolverImpl
+      include DOMEntityResolver
+
+      ## replace 'open' by WGET::open
+      begin
+        require 'wget'
+##        include WGET
+      rescue
+        ## ignore
+      end
+
+      ## DOMInputSource resolveEntity(publicId, systemId)
+      def resolveEntity(publicId, systemId)
+        ret = DOMInputSource.new
+        ret.publicId = publicId
+        ret.systemId = systemId
+        if systemId =~ /file:/
+          ret.byteStream = open(systemId.sub('^file://', ''))
+        else
+          ret.byteStream = WGET::open(systemId)
+        end
+        ret
+      end
+    end
+  end
+end
+

data/lib/xml/dom2/domexception.rb

@@ -0,0 +1,95 @@
+## -*- Ruby -*-
+## XML::DOM
+## 1998-2001 by yoshidam
+##
+
+module XML
+  module DOM
+=begin
+
+== Class XML::DOM::DOMException
+
+=== superclass
+Exception
+
+DOM exception.
+=end
+
+    class DOMException<Exception
+      INDEX_SIZE_ERR = 1
+      WSTRING_SIZE_ERR = 2
+      HIERARCHY_REQUEST_ERR  = 3
+      WRONG_DOCUMENT_ERR = 4
+      INVALID_NAME_ERR = 5
+      NO_DATA_ALLOWED_ERR = 6
+      NO_MODIFICATION_ALLOWED_ERR = 7
+      NOT_FOUND_ERR = 8
+      NOT_SUPPORTED_ERR = 9
+      INUSE_ATTRIBUTE_ERR = 10
+
+      ## [DOM2]
+      INVALID_STATE_ERR = 11
+      SYNTAX_ERR = 12
+      INVALID_MODIFICATION_ERR = 13
+      NAMESPACE_ERR = 14
+      INVALIUD_ACCESS_ERR = 14
+
+      ERRMSG = [
+        "no error",
+
+        "index size",
+        "wstring size",
+        "hierarchy request",
+        "wrong document",
+        "invalid name",
+        "no data allowed",
+        "no modification allowed",
+        "not found",
+        "not supported",
+        "inuse attribute",
+
+        ## [DOM2]
+        "invalid state",
+        "syntax error",
+        "invalid modification",
+        "namescape erorr",
+        "invaliud access"
+      ]
+
+=begin
+=== Class Methods
+
+    --- DOMException.new(code = 0)
+
+generate DOM exception.
+=end
+
+      def initialize(code = 0)
+        @code = code
+      end
+
+=begin
+=== Methods
+
+    --- DOMException#code()
+
+return code of exception.
+
+=end
+      def code
+        @code
+      end
+
+=begin
+
+    --- DOMException#to_s()
+
+return the string representation of the error.
+
+=end
+      def to_s
+        ERRMSG[@code].dup
+      end
+    end
+  end
+end

data/lib/xml/dom2/domimplementation.rb

@@ -0,0 +1,61 @@
+## -*- Ruby -*-
+## XML::DOM
+## 1998-2001 by yoshidam
+##                     
+
+require 'xml/dom2/domexception'
+require 'xml/dom2/dombuilder'
+require 'xml/dom2/documenttype'
+require 'singleton'
+
+module XML
+  module DOM
+
+=begin
+== Class XML::DOM::DOMImplementation
+
+=end
+    class DOMImplementation
+      include Singleton
+
+=begin
+   --- DOMImplementation#hasFeature(feature, version)
+
+test if DOM implementation has correct feature and version.
+
+=end
+      def hasFeature(feature, version)
+        if (feature =~ /^XML$/i || feature =~ /^Core$/i) &&
+            (version.nil? || version == "1.0" || version == "2.0")
+          return true
+        end
+        false
+      end
+
+      ## [DOM2]
+      def createDocumentType(qname, pubid, sysid)
+        DocumentType.new(qname, pubid, sysid)
+      end
+
+      ## [DOM2]
+      def createDocument(nsuri, qname, doctype)
+        raise DOMException.new(DOMException::WRONG_DOCUMENT_ERR) if
+          doctype && doctype.ownerDocument
+        doc = Document.new
+        if doctype
+          doc.appendChild(doctype)
+          doctype.ownerDocument = doc
+        end
+        elem = doc.createElementNS(nsuri, qname)
+        doc.appendChild(elem)
+        doc.implementation = self
+        doc
+      end
+
+      ## [DOM3?]
+      def createDOMBuilder
+        XML::DOM::DOMBuilder.new(Document.new)
+      end
+    end
+  end
+end

data/lib/xml/dom2/dominputsource.rb

@@ -0,0 +1,29 @@
+## -*- Ruby -*-
+## XML::DOM::DOMEntityResolver
+## 2001 by yoshidam
+##
+
+module XML
+  module DOM
+    class DOMInputSource
+      def initialize
+        @bstream = nil
+        @cstream = nil
+        @encoding = nil
+        @pubid = nil
+        @sysid = nil
+      end
+
+      def byteStream; @bstream; end
+      def byteStream=(stream); @bstream = stream; end
+      def characterStream; @cstream;  end
+      def characterStream=(stream); @cstream = stream; end
+      def encoding; @encoding; end
+      def encoding=(enc);@encoding = enc; end
+      def publicId; @pubid; end
+      def publicId=(pubid); @pubid = pubid; end
+      def systemId; @sysid; end
+      def systemId=(sysid); @sysid = sysid; end
+    end
+  end
+end

data/lib/xml/dom2/element.rb

@@ -0,0 +1,533 @@
+## -*- Ruby -*-
+## XML::DOM
+## 1998-2001 by yoshidam
+##
+
+require 'xml/dom2/node'
+require 'xml/dom2/domexception'
+require 'xml/dom2/nodelist'
+require 'xml/dom2/namednodemap'
+
+module XML
+  module DOM
+
+=begin
+== Class XML::DOM::Element
+
+=== superclass
+Node
+
+=end
+    class Element<Node
+
+=begin
+=== Class Methods
+
+    --- Element.new(tag = nil, attrs = nil, *children)
+
+create a new Element.
+=end
+      ## new(tag, attrs, [child1, child2, ...]) or
+      ## new(tag, attrs, child1, child2, ...)
+      ##     tag:    String
+      ##     attrs:  Hash, Attr or Array of Attr (or nil)
+      ##     child?: String or Node
+      def initialize(tag = nil, attr = nil, *children)
+        super(*children)
+        raise "parameter error" if !tag
+        @name = nil
+        @prefix = nil
+        @localname = nil
+        @uri = nil
+        @idAttribute = nil
+        if tag.is_a?(Array)
+          ## namespaces
+          raise "parameter error" if tag.length != 2
+          @localname = tag[1]
+          if tag[1].index(':')
+            @prefix, @localname = tag[1].split(':')
+          end
+          @name = tag[1] ## qualified name
+          @uri =  tag[0] ## namespace URI
+        else
+          @name = tag
+        end
+        @name.freeze
+        @localname.freeze
+        @uri.freeze
+        @prefix.freeze
+
+        if attr.nil?
+          @attr = NamedNodeMap.new([])
+        elsif attr.is_a?(Hash)
+          nodes = []
+          attr.each do |key, value|
+            nodes.push(Attr.new(key, value))
+          end
+          @attr = NamedNodeMap.new(nodes)
+        elsif attr.is_a?(Array)
+          @attr = NamedNodeMap.new(attr)
+        elsif attr.nodeType == ATTRIBUTE_NODE
+          @attr = NamedNodeMap.new([attr])
+        else
+          raise "parameter error: #{attr}"
+        end
+        @attr.each do |attr|
+          attr.ownerElement = self
+        end
+      end
+
+=begin
+=== Methods
+
+    --- Element#nodeType()
+
+[DOM]
+returns the nodeType.
+=end
+      ## [DOM]
+      def nodeType
+        ELEMENT_NODE
+      end
+
+=begin
+    --- Element#nodeName()
+
+[DOM]
+returns the nodeName.
+=end
+      ## [DOM]
+      def nodeName
+        @name
+      end
+
+=begin
+    --- Element#attributes()
+
+[DOM]
+returns the attributes of this Element.
+=end
+      ## [DOM]
+      def attributes
+        if iterator?
+          @attr.each do |key, value|
+            yield(value)
+          end if @attr
+        else
+          @attr
+        end
+      end
+
+      def _getNamespaces(parentNamespaces = {}, all = false)
+        if !parentNamespaces
+          parentNamespaces = parentNode._getNamespaces(nil, true)
+        end
+        namespaces = {}
+        attributes.each do |a|
+          namespaces[a.prefix] = a.namespaceURI if a.prefix
+        end
+        if @localname
+          namespaces[@prefix] = @uri
+        end
+        parentNamespaces.each do |prefix, uri|
+          if all
+            if !namespaces.include?(prefix)
+              namespaces[prefix] = uri
+            end
+          else
+            if namespaces[prefix] == parentNamespaces[prefix]
+              namespaces.delete(prefix)
+            end
+          end
+        end
+        namespaces
+      end
+
+=begin
+    --- Element#to_s()
+
+return the string representation of the Element.
+=end
+      def to_s
+        attr = ''
+
+        namespaces = {}
+        attributes.each do |a|
+          namespaces[a.prefix] = a.namespaceURI if a.prefix
+        end
+        if @localname
+          namespaces[@prefix] = @uri
+        end
+
+        namespaces.each do |prefix, uri|
+          ## skip the namespace declaration of xml or xmlns.
+          next if prefix == 'xml' or
+            uri == 'http://www.w3.org/2000/xmlns/'
+          nsattrname = 'xmlns'
+          nsattrname << ':' + prefix if prefix
+          ## skip duplicated namespace declarations.
+          next if @attr.getNamedItem(nsattrname)
+          attr << " #{nsattrname}=\"#{uri}\""
+        end
+
+        @attr.each do |a|
+          attr << ' ' + a.to_s
+        end if @attr
+        content = super
+        if content != ''
+          ret = "<#{@name}#{attr}>#{content}</#{@name}>"
+        else
+          ret = "<#{@name}#{attr}/>"
+        end
+        ret << "\n" if parentNode.nodeType == DOCUMENT_NODE
+        ret
+      end
+
+=begin
+    --- Element#dump(depth = 0)
+
+dumps the Element.
+=end
+      def dump(depth = 0)
+        attr = ''
+        @attr.each do |a|  ## self.attributes do |a|
+          attr += a.to_s + ", "
+        end if @attr
+        attr.chop!
+        attr.chop!
+        print ' ' * depth * 2
+        print "#{@name}(#{attr})\n"
+        @children.each do |child|
+          child.dump(depth + 1)
+        end if @children
+      end
+
+=begin
+    --- Element#tagName()
+
+[DOM]
+alias of nodeName.
+=end
+      ## [DOM]
+      alias tagName nodeName
+
+=begin
+    --- Element#getAttribute(name)
+
+[DOM]
+retrieves an attribute value by name.
+=end
+      ## [DOM]
+      def getAttribute(name)
+        attr = getAttributeNode(name)
+        if attr.nil?
+          ''
+        else
+          attr.nodeValue
+        end
+      end
+
+=begin
+    --- Element#setAttribute(name, value)
+
+[DOM]
+adds a new attribute.
+=end
+      ## [DOM]
+      def setAttribute(name, value)
+        if @ownerElement
+          attr = @ownerDocument.createAttribute(name)
+          attr.appendChild(@ownerDocument.createTextNode(value))
+        else
+          attr = Attr.new(name)
+          attr.appendChild(Text.new(value))
+        end
+        setAttributeNode(attr)
+      end
+
+=begin
+    --- Element#removeAttribute(name)
+
+[DOM]
+remove an attribute by name.
+=end
+      ## [DOM]
+      def removeAttribute(name)
+        ret = getAttributeNode(name)
+        removeAttributeNode(ret) if ret
+      end
+
+=begin
+    --- Element#getAttributeNode(name)
+
+[DOM]
+retrieves an Attr node by name.
+=end
+      ## [DOM]
+      def getAttributeNode(name)
+        @attr.getNamedItem(name)
+      end
+
+=begin
+    --- Element#setAttributeNode(newAttr)
+
+[DOM]
+adds a new attribute.
+=end
+      ## [DOM]
+      def setAttributeNode(newAttr)
+        ret = getAttributeNode(newAttr.nodeName)
+        if ret == newAttr
+          raise DOMException.new(DOMException::INUSE_ATTRIBUTE_ERR)
+        end
+        ret.ownerElement = nil if ret
+        @attr.setNamedItem(newAttr)
+        newAttr.ownerElement = self
+        ret
+      end
+
+=begin
+    --- Element#removeAttributeNode(oldAttr)
+
+[DOM]
+removes the specified attribute.
+=end
+      ## [DOM]
+      def removeAttributeNode(oldAttr)
+        ret = getAttributeNode(oldAttr.nodeName)
+        if ret.nil? || ret != oldAttr
+          raise DOMException.new(DOMException::NOT_FOUND_ERR)
+        end
+        @attr.removeNamedItem(oldAttr.nodeName)
+        ret.ownerElement = nil
+        ret
+      end
+
+=begin
+    --- Element#getElementsByTagName(tagname)
+
+[DOM]
+returns a NodeList of all descendant elements with given tag name.
+=end
+      ## [DOM] (but this is not "live")
+      def getElementsByTagName(tagname)
+        ret = NodeList.new
+        @children.each do |node|
+          if node.nodeType == ELEMENT_NODE
+            if tagname == '*' || node.nodeName == tagname
+              ret << node
+            end
+            ret << node.getElementsByTagName(tagname)
+          end
+        end if @children
+        ret
+      end
+
+
+=begin
+    --- Element#normalize
+
+[DOM]
+puts all Text nodes in the full depth of the sub-tree under this
+Eelemnt.
+=end
+      ## [DOM]
+      def normalize
+        return if @children.nil?
+        old = nil
+        children = @children.to_a.dup
+        children.each do |child|
+          if !old.nil? && old.nodeType == TEXT_NODE &&
+              child.nodeType == TEXT_NODE
+            old.appendData(child.nodeValue)
+            self.removeChild(child)
+          else
+            if child.nodeType == ELEMENT_NODE
+              child.normalize
+            end
+            old = child
+          end
+        end
+      end
+
+=begin
+    --- Element#cloneNode(deep = true)
+
+[DOM]
+returns the copy of the Element.
+=end
+      ## [DOM]
+      def cloneNode(deep = true)
+        attrs = []
+        @attr.each do |attr|
+          attrs.push(attr.cloneNode(true))
+        end
+        super(deep, @name, attrs)
+      end
+
+      ## get the list of nodeValues by IDs
+      ## [experimental implement]
+      def _getIDVals(ids = nil)
+        if ids.nil?
+          doc = ownerDocument
+          return [] if doc.nil?
+          ids = doc._getIDAttrs
+        end
+
+        idelem = []
+        if !ids[nodeName].nil?
+          return attributes._getValues(ids[nodeName])
+        elsif !ids['*'].nil?
+          return attributes._getValues(ids['*'])
+        end
+        return []
+      end
+
+=begin
+    --- Element#trim(preserve = false)
+
+trim extra whitespaces.
+=end
+      ## trim extra whitespaces
+      ## if attribute 'xml:space' is 'preserve',
+      ## don't trim any white spaces
+      def trim(preserve = false)
+        if !attributes['xml:space'].nil?
+          value = attributes['xml:space'].nodeValue
+          if value == 'preserve'
+            preserve = true
+          elsif value == 'default'
+            preserve = false
+          end
+        end
+        return nil if @children.nil?
+        children = @children.to_a.dup
+        children.each do |child|
+          if !preserve && (child.nodeType == TEXT_NODE ||
+                           child.nodeType == CDATA_SECTION_NODE)
+            if child.trim == ""
+              self.removeChild(child)
+            end
+          else
+            child.trim(preserve)
+          end
+        end
+        nil
+      end
+
+      ## [DOM2]
+      def namespaceURI; @uri; end
+
+      ## [DOM2]
+      def prefix; @prefix; end
+
+      ## [DOM2]
+      def prefix=(prefix);
+        ## to be checked
+        @prefix = prefix
+        @name = @prefix + ':' + @localname
+        @prefix.freeze
+        @name.freeze
+      end
+
+      ## [DOM2]
+      def localname; @localname; end
+
+      ## [DOM2]
+      def hasAttributes()
+        attributes.length > 0
+      end
+
+      ## [DOM2]
+      def getAttributeNS(nsuri, localname)
+        attr = getAttributeNodeNS(nsuri, localname)
+        if attr.nil?
+          ""
+        else
+          attr.nodeValue
+        end
+      end
+
+      ## [DOM2]
+      def setAttributeNS(nsuri, qname, value)
+        if qname.index(':')
+          prefix, localname = qname.split(':')
+          raise DOMException.new(DOMException::NAMESPACE_ERR) if
+            nsuri.nil? or
+            (prefix == 'xml' and
+             nsuri != 'http://www.w3.org/XML/1998/namespace')
+        else
+          raise DOMException.new(DOMException::NAMESPACE_ERR) if
+            qname == 'xmlns' and
+            nsuri != 'http://www.w3.org/2000/xmlns/'
+        end
+        attr = @ownerDocument.createAttributeNS(nsuri, qname)
+        attr.appendChild(@ownerDocument.createTextNode(value))
+        setAttributeNodeNS(attr)
+      end
+
+      ## [DOM2]
+      def removeAttributeNS(nsuri, localname)
+        ret = getAttributeNodeNS(nsuri, localname)
+        removeAttributeNode(ret) if ret
+      end
+
+      ## [DOM2]
+      def getAttributeNodeNS(nsuri, localname)
+        attributes.each do |attr|
+          return attr if
+            attr.namespaceURI == nsuri && attr.localname == localname
+        end
+        nil
+      end
+
+      ## [DOM2]
+      def setAttributeNodeNS(newAttr)
+        ret = getAttributeNodeNS(newAttr.namespaceURI, newAttr.localname)
+        removeAttributeNode(ret) if ret
+        setAttributeNode(newAttr)
+        ret
+      end
+
+      ## [DOM2]
+      def getElementsByTagNameNS(nsuri, localname)
+        ret = NodeList.new
+        @children.each do |node|
+          if node.nodeType == ELEMENT_NODE
+            if (localname == '*' || node.localname == localname) and
+                (nsuri == '*' || node.namespaceURI == nsuri)
+              ret << node
+            end
+            ret << node.getElementsByTagNameNS(nsuri, localname)
+          end
+        end if @children
+        ret
+      end
+
+      ## [DOM2]
+      def hasAttribute(name)
+        !getAttributeNode(name).nil?
+      end
+
+      ## [DOM2]
+      def hasAttributeNS(nsuri, localname)
+        !getAttributeNodeNS(nsuri, localname).nil?
+      end
+
+      def idAttribute; @idAttribute; end
+      def idAttribute=(name); @idAttribute = name; end
+
+      def _checkNode(node)
+        unless node.nodeType == ELEMENT_NODE ||
+            node.nodeType == TEXT_NODE ||
+            node.nodeType == COMMENT_NODE ||
+            node.nodeType == PROCESSING_INSTRUCTION_NODE ||
+            node.nodeType == CDATA_SECTION_NODE ||
+            node.nodeType == ENTITY_REFERENCE_NODE
+          raise DOMException.new(DOMException::HIERARCHY_REQUEST_ERR)
+        end
+      end
+
+    end
+  end
+end