xmlparser 0.6.81

data/lib/xml/dom2/entity.rb

@@ -0,0 +1,110 @@
+## -*- Ruby -*-
+## XML::DOM
+## 1998-2001 by yoshidam
+##
+
+require 'xml/dom2/node'
+require 'xml/dom2/domexception'
+
+module XML
+  module DOM
+
+=begin
+== Class XML::DOM::Entity
+
+=== superclass
+Node
+=end
+    class Entity<Node
+
+=begin
+=== Class Methods
+
+    --- Entity.new(name, pubid, sysid, notation)
+
+creates a new Entity.
+=end
+      def initialize(name, pubid, sysid, notation)
+        super()
+        @name = name.freeze
+        @pubid = pubid.freeze
+        @sysid = sysid.freeze
+        @notation = notation.freeze
+      end
+
+=begin
+=== Methods
+
+    --- Entity#nodeType
+
+[DOM]
+returns the nodeType.
+=end
+      ## [DOM]
+      def nodeType
+        ENTITY_NODE
+      end
+
+=begin
+    --- Entity#nodeName
+
+[DOM]
+returns the nodeName.
+=end
+      ## [DOM]
+      def nodeName
+        @name
+      end
+
+=begin
+    --- Entity#publicId
+
+returns the publicId of the Entity.
+=end
+      def publicId
+        @pubid
+      end
+
+=begin
+    --- Entity#systemId
+
+returns the systemId of the Entity.
+=end
+      def systemId
+        @sysid
+      end
+
+=begin
+    --- Entity#notationName
+
+returns the notationname of the Entity.
+=end
+      def notationName
+        @notation
+      end
+
+=begin
+    --- Entity#cloneNode(deep = true)
+
+[DOM]
+returns the copy of the Entity.
+=end
+      ## [DOM]
+      def cloneNode(deep = true)
+        super(deep, @name, @pubid, @sysid, @notation)
+      end
+
+      def _checkNode(node)
+        unless node.nodeType == ELEMENT_NODE ||
+            node.nodeType == PROCESSING_INSTRUCTION_NODE ||
+            node.nodeType == COMMENT_NODE ||
+            node.nodeType == TEXT_NODE ||
+            node.nodeType == CDATA_SECTION_NODE ||
+            node.nodeType == ENTITY_REFERENCE_NODE
+          raise DOMException.new(DOMException::HIERARCHY_REQUEST_ERR)
+        end
+      end
+
+    end
+  end
+end

data/lib/xml/dom2/entityreference.rb

@@ -0,0 +1,107 @@
+## -*- Ruby -*-
+## XML::DOM
+## 1998-2001 by yoshidam
+##
+
+require 'xml/dom2/node'
+require 'xml/dom2/domexception'
+
+module XML
+  module DOM
+
+=begin
+== Class XML::DOM::EntityReference
+
+=== superclass
+Node
+=end
+    class EntityReference<Node
+
+=begin
+=== Class Methods
+
+    --- EntityReference.new(name, *children)
+
+creates a new EntityReference.
+=end
+      def initialize(name, *children)
+        super(*children)
+        raise "parameter error" if !name
+        @name = name.freeze
+        @value = nil
+      end
+
+=begin
+=== Methods
+
+    --- EntityReference#nodeType
+
+[DOM]
+returns the nodeType.
+=end
+      ## [DOM]
+      def nodeType
+        ENTITY_REFERENCE_NODE
+      end
+
+=begin
+    --- EntityReference#nodeName
+
+[DOM]
+returns  the nodeName.
+=end
+      ## [DOM]
+      def nodeName
+        @name
+      end
+
+=begin
+    --- EntityReference#to_s
+
+returns the string representation of the EntityReference.
+=end
+      ## reference form or expanded form?
+      def to_s
+        "&#{@name};"
+      end
+
+=begin
+    --- EntityReference#dump(depth = 0)
+
+dumps the EntityReference.
+=end
+      def dump(depth = 0)
+        print ' ' * depth * 2
+        print "&#{@name}{\n"
+        @children.each do |child|
+          child.dump(depth + 1)
+        end if @children
+        print ' ' * depth * 2
+        print "}\n"
+      end
+
+=begin
+    --- EntityReference#cloneNode(deep = true)
+
+[DOM]
+returns the copy of the EntityReference.
+=end
+      ## [DOM]
+      def cloneNode(deep = true)
+        super(deep, @name)
+      end
+
+      def _checkNode(node)
+        unless node.nodeType == ELEMENT_NODE ||
+            node.nodeType == PROCESSING_INSTRUCTION_NODE ||
+            node.nodeType == COMMENT_NODE ||
+            node.nodeType == TEXT_NODE ||
+            node.nodeType == CDATA_SECTION_NODE ||
+            node.nodeType == ENTITY_REFERENCE_NODE
+          raise DOMException.new(DOMException::HIERARCHY_REQUEST_ERR)
+        end
+      end
+
+    end
+  end
+end

data/lib/xml/dom2/namednodemap.rb

@@ -0,0 +1,138 @@
+## -*- Ruby -*-
+## XML::DOM
+## 1998-2001 by yoshidam
+##
+
+module XML
+  module DOM
+=begin
+== Class XML::DOM::NamedNodeMap
+
+=end
+
+    class NamedNodeMap
+
+=begin
+=== Class Methods
+
+    --- NamedNodeMap.new(nodes = nil)
+
+creates a new NamedNodeMap.
+=end
+      def initialize(nodes = nil)
+        @nodes = {}
+        nodes.each do |node|
+          @nodes[node.nodeName] = node
+        end if nodes
+      end
+
+=begin
+=== Methods
+
+    --- NamedNodeMap#getNamedItem(name)
+
+[DOM]
+retrieves a node specified by name.
+=end
+      ## [DOM]
+      def getNamedItem(name)
+        @nodes[name]
+      end
+
+=begin
+    --- NamedNodeMap#setNamedItem(node)
+
+[DOM]
+adds a node using its nodeName attribute.
+=end
+      ## [DOM]
+      def setNamedItem(node)
+        @nodes[node.nodeName] = node
+      end
+
+=begin
+    --- NamedNodeMap#removeNamedItem(name)
+
+[DOM]
+removes a node specified by name.
+=end
+      ## [DOM]
+      def removeNamedItem(name)
+        ret = @nodes[name]
+        @nodes.delete(name)
+        ret
+      end
+
+=begin
+    --- NamedNodeMap#item(index)
+
+[DOM]
+returns the index item in the map.
+=end
+      ## [DOM]
+      def item(index)
+        v = @nodes.to_a[index]
+        return v[1] if v
+        nil
+      end
+
+=begin
+    --- NamedNodeMap#[](name)
+
+returns nodes associated to name.
+=end
+      def [](name)
+        @nodes[name]
+      end
+
+=begin
+    --- NamedNodeMap#[]=(name, node)
+
+sets node named name.
+=end
+      def []=(name, node)
+        raise "parameter error" if node.nodeName != name
+        @nodes[name] = node
+      end
+
+=begin
+    --- NamedNodeMap#each()
+
+iterates over each pair of name and node(name, node) of the namedNodeMap.
+=end
+      def each
+        @nodes.each do |key, value|
+          yield(value)
+        end
+      end
+
+=begin
+    --- NamedNodeMap#size()
+
+[DOM]
+returns the number of nodes in the map.
+=end
+      ## [DOM]
+      def size
+        @nodes.length
+      end
+      alias length size
+
+      ## get nodeValues by names
+      ##   names ::= name ('|' name)*
+      def _getValues(names)
+        ret = []
+        names.split('|').each do |name|
+          if !@nodes[name].nil?
+            ret.push(@nodes[name].nodeValue)
+          end
+        end
+        ret
+      end
+
+      ## [DOM2]
+      ## def getNamedItemNS(nsuri, localname); end
+      ## def removeNamedItemNS(nsuri, localname); end
+    end
+  end
+end

data/lib/xml/dom2/node.rb

@@ -0,0 +1,587 @@
+## -*- Ruby -*-
+## XML::DOM
+## 1998-2001 by yoshidam
+##
+
+require 'xml/dom2/domexception'
+require 'xml/dom2/nodelist'
+
+module XML
+  module DOM
+
+=begin
+== Class XML::DOM::Node
+
+=end
+    class Node
+      ## [DOM]
+      NODE_NODE = 0
+      ELEMENT_NODE = 1
+      ATTRIBUTE_NODE = 2
+      TEXT_NODE = 3
+      CDATA_SECTION_NODE = 4
+      ENTITY_REFERENCE_NODE = 5
+      ENTITY_NODE = 6
+      PROCESSING_INSTRUCTION_NODE = 7
+      COMMENT_NODE  = 8
+      DOCUMENT_NODE = 9
+      DOCUMENT_TYPE_NODE = 10
+      DOCUMENT_FRAGMENT_NODE = 11
+      NOTATION_NODE = 12
+
+      ## non-DOM
+#      NODE = 0
+#      ELEMENT = 1
+#      ATTRIBUTE = 2
+#      TEXT = 3
+#      CDATA_SECTION = 4
+#      ENTITY_REFERENCE = 5
+#      ENTITY = 6
+#      PI = 7
+#      PROCESSING_INSTRUCTION = 7
+#      COMMENT  = 8
+#      DOCUMENT = 9
+#      DOCUMENT_TYPE = 10
+#      DOCUMENT_FRAGMENT = 11
+#      NOTATION = 12
+
+=begin
+=== Class Methods
+
+    --- Node.new(*children)
+
+make a Node.
+children is a Array of child, or sequence of child.
+child is a String or Node.
+
+=end
+      ## new([child1, child2, ...]) or
+      ## new(child1, child2, ...)
+      ##     child?: String or Node
+      def initialize(*children)
+        @ownerDocument = nil
+        @parent = nil
+        @children = nil
+        self.childNodes = children if children.length > 0
+      end
+
+=begin
+=== Methods
+
+    --- Node#parentNode
+
+[DOM]
+return parent node.
+
+=end
+      ## [DOM]
+      def parentNode
+        @parent
+      end
+
+=begin
+    --- Node#parentNode=(p)
+
+set node p as parent.
+=end
+
+      def parentNode=(p)
+        @parent = p
+      end
+
+=begin
+    --- Node#nodeType
+
+[DOM]
+return nodetype.
+
+=end
+      ## [DOM]
+      def nodeType
+        NODE_NODE
+      end
+
+=begin
+    --- Node#nodeName
+
+[DOM]
+return nodename.
+
+=end
+      ## [DOM]
+      def nodeName
+        "#node"
+      end
+
+#      def nodeName=(p)
+#        @name = p
+#      end
+
+=begin
+    --- Node#nodeValue
+
+[DOM]
+return nodevalue.
+
+=end
+      ## [DOM]
+      def nodeValue; nil; end
+
+=begin
+    --- Node#nodeValue=(p)
+
+[DOM]
+set nodevalue as p.
+=end
+      ## [DOM]
+      def nodeValue=(p)
+        ## no effect
+      end
+
+=begin
+    --- Node#childNodes()
+
+[DOM]
+if method has block, apply block for children nodes.
+without block, return children nodelist.
+=end
+      ## [DOM]
+      def childNodes
+        if iterator?
+          @children.each do |child|
+            yield(child)
+          end if @children
+        else
+          return @children if !@children.nil?
+          @children = NodeList.new
+        end
+      end
+
+      def childNodes=(p)
+        if p.nil? || (p.is_a?(Array) && p.length == 0)
+          return
+        end
+        if @children.nil?
+          @children = NodeList.new
+        else
+          @children.to_a.clear
+        end
+        p.flatten!
+        p.each do |child|
+          if child.is_a?(String)
+            c = Text.new(child)
+            @children.push(c)
+            c.parentNode = self
+          elsif child.is_a?(Node)
+            @children.push(child)
+            child.parentNode = self
+          else
+            raise "parameter error"
+          end
+        end if p
+      end
+
+=begin
+    --- Node#attributes
+
+[DOM]
+return attributes of node(but always return nil?).
+=end
+      ## [DOM]
+      def attributes
+        nil
+      end
+
+      ## proper parameter type?
+#      def attributes=(p)
+#      end
+
+=begin
+    --- Node#[]=(index, nodes)
+
+set children node as nodes with []-style.
+=end
+      def []=(index, nodes)
+        @children[index..index] = nodes
+        @children.each do |child|
+          child.parentNode = self
+        end if @children
+      end
+
+=begin
+    --- Node#[](index)
+
+get children node with []-style.
+=end
+      def [](index)
+        @children[index]
+      end
+
+=begin
+    --- Node#+(node)
+
+concat node to Node.
+=end
+      def +(node)
+        [self, node]
+      end
+
+=begin
+    --- Node#to_s
+
+returns the string representation of the Node.
+=end
+      def to_s
+        @children.to_s
+      end
+
+=begin
+    --- Node#dump(depth = 0)
+
+dump the Node.
+=end
+      def dump(depth = 0)
+        print ' ' * depth * 2
+        print nodeName + "\n"
+        @children.each do |child|
+          child.dump(depth + 1)
+        end if @children
+      end
+
+=begin
+    --- Node#inspect()
+
+returns the human-readable string representation.
+=end
+      def inspect
+        "#<#{self.class}: #{self.nodeName}>"
+      end
+
+=begin
+    --- Node#firstChild()
+
+[DOM]
+return the first child node.
+=end
+      ## [DOM]
+      def firstChild
+        return nil if !@children || @children.length == 0
+        return @children[0]
+      end
+
+=begin
+    --- Node#lastChild()
+
+[DOM]
+return the last child node.
+=end
+      ## [DOM]
+      def lastChild
+        return nil if !@children || @children.length == 0
+        return @children[-1]
+      end
+
+=begin
+    --- Node#previousSibling()
+
+[DOM]
+return the previous sibling node.
+=end
+      ## [DOM]
+      def previousSibling
+        return nil if !@parent
+        prev = nil
+        @parent.childNodes do |child|
+          return prev if child == self
+          prev = child
+        end
+        nil
+      end
+
+=begin
+    --- Node#nextSibling()
+
+[DOM]
+return the next sibling node.
+=end
+      ## [DOM]
+      def nextSibling
+        return nil if !@parent
+        nexts = nil
+        @parent.childNodes.reverse.each do |child|
+          return nexts if child == self
+          nexts = child
+        end
+        nil
+      end
+
+      def _getChildIndex(node)
+        index = 0
+        @children.each do |child|
+          if child == node
+            return index
+          end
+          index += 1
+        end
+        nil
+      end
+
+      def _removeFromTree
+        parent = parentNode
+        if parent
+          parent.removeChild(self)
+        end
+      end
+
+      def _checkNode(node)
+        raise DOMException.new(DOMException::HIERARCHY_REQUEST_ERR)
+      end
+
+      def _insertNodes(index, node)
+        if node.nodeType == DOCUMENT_FRAGMENT_NODE
+
+          node.childNodes.to_a.each_with_index do |n, i|
+            if index == -1
+              _insertNodes(-1, n)
+            else
+              _insertNodes(index + i, n)
+            end
+          end
+        elsif node.is_a?(Node)
+          ## to be checked
+          _checkNode(node)
+          node._removeFromTree
+          if index == -1
+            @children.push(node)
+          else
+            @children[index, 0] = node
+          end
+          node.parentNode = self
+        else
+          raise ArgumentError, "invalid value for Node"
+        end
+      end
+
+      def _removeNode(index, node)
+        @children[index, 1] = nil
+        node.parentNode = nil
+      end
+
+# =begin
+#     --- Node#insertAfter(newChild, refChild)
+# 
+# insert newChild into the node after refChild.
+# =end
+#       def insertAfter(newChild, refChild)
+#         if @children.nil? || @children.length == 0
+#           raise DOMException.new(DOMException::NOT_FOUND_ERR)
+#         end
+#         index = _getChildIndex(refChild)
+#         raise DOMException.new(DOMException::NOT_FOUND_ERR) if index.nil?
+#         _insertNodes(index + 1, newChild)
+#       end
+
+=begin
+    --- Node#insertBefore(newChild, refChild)
+
+[DOM]
+insert newChild into the node before refChild.
+=end
+      ## [DOM]
+      def insertBefore(newChild, refChild)
+        if @children.nil? || @children.length == 0
+          raise DOMException.new(DOMException::NOT_FOUND_ERR)
+        end
+        index = _getChildIndex(refChild)
+        raise DOMException.new(DOMException::NOT_FOUND_ERR) if !index
+        _insertNodes(index, newChild)
+      end
+
+=begin
+    --- Node#replaceChild(newChild, oldChild)
+
+[DOM]
+replace the child node oldChild with newChild.
+=end
+      ## [DOM]
+      def replaceChild(newChild, oldChild)
+        if @children.nil? || @children.length == 0
+          raise DOMException.new(DOMException::NOT_FOUND_ERR)
+        end
+        index = _getChildIndex(oldChild)
+        raise DOMException.new(DOMException::NOT_FOUND_ERR) if !index
+        _removeNode(index, oldChild)
+        _insertNodes(index, newChild)
+      end
+
+=begin
+    --- Node#removeChild(oldChild)
+
+[DOM]
+remove the children node oldChild.
+=end
+      ## [DOM]
+      def removeChild(oldChild)
+        if @children.nil? || @children.length == 0
+          raise DOMException.new(DOMException::NOT_FOUND_ERR)
+        end
+        index = _getChildIndex(oldChild)
+        raise DOMException.new(DOMException::NOT_FOUND_ERR) if !index
+        _removeNode(index, oldChild)
+        oldChild
+      end
+
+=begin
+    --- Node#appendChild(newChild)
+
+[DOM]
+adds the node newChild to the end of the list of children of this node.
+=end
+      ## [DOM]
+      def appendChild(newChild)
+        @children = NodeList.new if !@children
+        _insertNodes(-1, newChild)
+      end
+
+=begin
+    --- Node#hasChildNodes()
+
+[DOM]
+returns true if node has children, or return false if node has no children.
+=end
+      ## [DOM]
+      def hasChildNodes
+        !@children.nil? && @children.length > 0
+      end
+
+=begin
+    --- Node#ownerDocument()
+
+[DOM]
+Document object associated with this node.
+=end
+      ## [DOM]
+      def ownerDocument; @ownerDocument; end
+
+      def ownerDocument=(document); @ownerDocument = document; end
+
+=begin
+    --- Node#cloneNode()
+
+[DOM]
+return the copy of the Node.
+=end
+      ## [DOM]
+      def cloneNode(deep = true, *args)
+        ret = self.class.new(*args)
+        if (deep)
+          @children.each do |child|
+            ret.appendChild(child.cloneNode(true))
+          end
+        end if @children
+        ret
+      end
+
+=begin
+    --- Node#trim(preserve = false)
+
+trim extra whitespaces.
+=end
+      ## trim extra whitespaces
+      def trim(preserve = false)
+        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 isSupported(feature, version)
+        if (feature =~ /^XML$/i || feature =~ /^Core$/i) &&
+            (version.nil? || version == "1.0" || version == "2.0")
+          return true
+        end
+        false
+      end
+
+      ## [DOM2]
+      def namespaceURI; nil; end
+
+      ## [DOM2]
+      def prefix; nil; end
+
+      ## [DOM2]
+      def prefix=(prefix);
+        ## no effect
+      end
+
+      ## [DOM2]
+      def localname; nil; end
+
+      ## [DOM2]
+      def hasAttributes(); false; end
+
+
+      include Enumerable
+      def each
+        sibstack = []
+        siblings = [ self ]
+        while true
+          if siblings.length == 0
+            break if sibstack.length == 0
+            siblings = sibstack.pop
+            next
+          end
+          node = siblings.shift
+          yield(node)
+          children = node.childNodes
+          if !children.nil?
+            sibstack.push(siblings)
+            siblings = children.to_a.dup
+          end
+        end
+      end
+
+      include Comparable
+
+      def ==(node)
+        equal?(node)
+      end
+
+      def <=>(node)
+        ancestors1 = [self]
+        ancestors2 = [node]
+        p = self
+        while p = p.parentNode
+          ancestors1.unshift(p)
+        end
+        p = node
+        while p = p.parentNode
+          ancestors2.unshift(p)
+        end
+        raise "different document" unless ancestors1[0].equal?(ancestors2[0])
+        ret = 0
+        i = 0
+        for i in 1...ancestors1.size
+          next if ancestors1[i].equal?(ancestors2[i])
+          return 1 if ancestors2[i].nil?
+          children = ancestors1[i - 1].childNodes.to_a
+          return children.index(ancestors1[i]) - children.index(ancestors2[i])
+        end
+        return -1 if ancestors2.size > i + 1
+        0
+      end
+
+    end
+  end
+end