xmlparser 0.6.81

data/lib/xml/dom2/nodelist.rb

@@ -0,0 +1,231 @@
+## -*- Ruby -*-
+## XML::DOM
+## 1998-2001 by yoshidam
+##
+
+module XML
+  module DOM
+=begin
+== Class XML::DOM::NodeList
+
+
+=end
+    class NodeList
+
+=begin
+=== Class Methods
+
+    --- NodeList.new(nodes = nil)
+
+creates a new NodeList.
+=end
+      def initialize(nodes = nil)
+        if nodes.nil?
+          @nodes = []
+        elsif nodes.is_a?(Array)
+          @nodes = nodes
+        else
+          raise "parameter error"
+        end
+      end
+
+=begin
+=== Methods
+
+    --- NodeList#item(index)
+
+[DOM]
+return the indexth item in the NodeList.
+=end
+      ## [DOM]
+      def item(index)
+        @nodes[index]
+      end
+
+=begin
+    --- NodeList#size()
+
+return size of NodeList.
+=end
+      def size
+        @nodes.length
+      end
+      alias length size
+
+=begin
+    --- NodeList#[](index)
+
+return indexth node of the NodeList.
+=end
+      def [](index)
+        @nodes[index]
+      end
+
+=begin
+    --- NodeList#[]=(*p)
+
+set node of indexth node of the NodeList.
+=end
+      def []=(*p)
+        if p.length == 2
+          @nodes[p[0]] = p[1]
+        elsif p.length == 3
+          @nodes[p[0], p[1]] = p[2]
+        end
+      end
+
+=begin
+    --- NodeList#each
+
+iterates over each node of the NodeList.
+=end
+      def each
+        @nodes.each do |value|
+          yield(value)
+        end
+      end
+
+=begin
+    --- NodeList#reversible_each(reverse = false)
+
+iterates over each node of the reversed NodeList.
+=end
+      ## [Masaki Fukushima]
+      def reversible_each(reverse = false)
+        if !reverse
+          @nodes.each do |value|
+            yield(value)
+          end
+        else
+          @nodes.reverse_each do |value|
+            yield(value)
+          end
+        end
+      end
+
+=begin
+    --- NodeList#push(*nodes)
+
+adds nodes into the NodeList.
+=end
+      def push(*nodes)
+        nodes.each do |node|
+          if node.is_a?(Array)
+            self.push(*node)
+          elsif node.is_a?(NodeList)
+            @nodes.concat(node.to_a)
+          elsif node.is_a?(Node)
+            @nodes << node
+          else
+            raise "parameter error"
+          end
+        end
+        self
+      end
+
+=begin
+    --- NodeList#concat(*nodes)
+
+alias of NodeList#push.
+=end
+      alias concat push
+
+=begin
+    --- NodeList#pop
+
+pops and returns the last node of the NodeList.
+=end
+      def pop
+        @nodes.pop
+      end
+
+=begin
+    --- NodeList#shift
+
+removes and returns the first node of the NodeList.
+=end
+      def shift
+        @nodes.shift
+      end
+
+=begin
+    --- NodeList#to_s
+
+returns the string representation of the NodeList.
+=end
+      def to_s
+        @nodes.to_s
+      end
+
+=begin
+    --- NodeList#reverse
+
+returns the reversed NodeList.
+=end
+      def reverse
+        @nodes.reverse
+      end
+
+=begin
+    --- NodeList#to_a
+
+converts the NodeList into an array.
+=end
+      def to_a
+        @nodes
+      end
+
+=begin
+    --- NodeList#+(nodes)
+
+return the newly created concatenated NodeList.
+=end
+      def +(nodes)
+        if nodes.nil?
+          NodeList.new(@nodes)
+        elsif nodes.is_a?(Array)
+          NodeList.new(@nodes + nodes)
+        elsif nodes.is_a?(NodeList)
+          NodeList.new(@nodes + nodes.to_a)
+        elsif nodes.is_a?(Node)
+          NodeList.new(@nodes + [nodes])
+        else
+          raise "parameter error"
+        end
+      end
+
+=begin
+    --- NodeList#<<(nodes)
+
+appends nodes to the NodeList.
+=end
+      ## modified by Masaki Fukushima
+      def <<(nodes)
+        if nodes.nil?
+          ## no change
+        elsif nodes.is_a?(Array)
+          @nodes.concat(nodes)
+        elsif nodes.is_a?(NodeList)
+          @nodes.concat(nodes.to_a)
+        elsif nodes.is_a?(Node)
+          @nodes << nodes
+        else
+          raise "parameter error"
+        end
+        self
+      end
+
+      ## 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
+    end
+  end
+end

data/lib/xml/dom2/notation.rb

@@ -0,0 +1,86 @@
+## -*- Ruby -*-
+## XML::DOM
+## 1998-2001 by yoshidam
+##
+
+require 'xml/dom2/node'
+
+module XML
+  module DOM
+
+=begin
+== Class XML::DOM::Notation
+
+=== superclass
+Node
+=end
+    class Notation<Node
+=begin
+=== Class Methods
+
+    --- Notation.new(name, pubid, sysid)
+
+creates a new Notation.
+=end
+      def initialize(name, pubid, sysid)
+        super()
+        @name = name.freeze
+        @pubid = pubid.freeze
+        @sysid = sysid.freeze
+      end
+
+=begin
+=== Methods
+
+    --- Notation#nodeType
+
+[DOM]
+returns the nodeType.
+=end
+      ## [DOM]
+      def nodeType
+        NOTATION_NODE
+      end
+
+=begin
+    --- Notation#nodeName
+
+[DOM]
+returns the nodeName.
+=end
+      ## [DOM]
+      def nodeName
+        @name
+      end
+
+=begin
+    --- Notation#publicId
+
+returns the publicId of the Notation.
+=end
+      def publicId
+        @pubid
+      end
+
+=begin
+    --- Notation#systemId
+
+returns the systemId of the Notation.
+=end
+      def systemId
+        @sysid
+      end
+
+=begin
+    --- Notation#cloneNode(deep = true)
+
+[DOM]
+returns the copy of the Notation.
+=end
+      ## [DOM]
+      def cloneNode(deep = true)
+        super(deep, @name, @pubid, @sysid)
+      end
+    end
+  end
+end

data/lib/xml/dom2/processinginstruction.rb

@@ -0,0 +1,155 @@
+## -*- Ruby -*-
+## XML::DOM
+## 1998-2001 by yoshidam
+##
+
+require 'xml/dom2/node'
+
+module XML
+  module DOM
+
+=begin
+== Class XML::DOM::ProcessingInstruction
+
+=== superclass
+Node
+
+=end
+    class ProcessingInstruction<Node
+
+=begin
+=== Class Methods
+
+    --- ProcessingInstruction.new(target = nil, data = nil)
+
+creates a new ProcessingInstruction.
+=end
+      ## new(target, data)
+      ##     target: String
+      ##     data: String
+      def initialize(target = nil, data = nil)
+        super()
+        raise "parameter error" if !data
+        @target = target.freeze
+        @data = data.freeze
+        @value = target.dup
+        @value << " #{data}" if data != ""
+        @value.freeze
+      end
+
+=begin
+=== Methods
+
+    --- ProcessingInstruction#nodeType
+
+[DOM]
+returns the nodeType.
+=end
+      ## [DOM]
+      def nodeType
+        PROCESSING_INSTRUCTION_NODE
+      end
+
+=begin
+    --- ProcessingInstruction#nodeName
+
+[DOM]
+returns the nodeName.
+=end
+      ## [DOM]
+      def nodeName
+        "#proccessing-instruction"
+      end
+
+=begin
+    --- ProcessingInstruction#target
+
+[DOM]
+returns the target of the ProcessingInstruction.
+=end
+      ## [DOM]
+      def target
+        @target
+      end
+
+      def target=(p)
+        @target = p.freeze
+        @value = @target.dup
+        @value << " #{@data}" if @data != ""
+        @value.freeze
+      end
+
+=begin
+    --- ProcessingInstruction#data
+
+[DOM]
+return the content of the ProcessingInstruction.
+=end
+      ## [DOM]
+      def data
+        @data
+      end
+
+=begin
+    --- ProcessingInstruction#data=(p)
+
+[DOM]
+sets p to the content of the ProcessingInstruction.
+=end
+      ## [DOM]
+      def data=(p)
+        @data = p.freeze
+        @value = @target.dup
+        @value << " #{@data}" if @data != ""
+        @value.freeze
+      end
+
+=begin
+    --- ProcessingInstruction#nodeValue
+
+[DOM]
+return nodevalue.
+
+=end
+      ## [DOM]
+      def nodeValue
+        @value
+      end
+
+      ## inhibit changing value without target= or data=
+      undef nodeValue=
+
+=begin
+    --- ProcessingInstruction#to_s
+
+returns the string representation of the ProcessingInstruction.
+=end
+      def to_s
+        ret = "<?#{@value}?>"
+        ret << "\n" if parentNode.nodeType == DOCUMENT_NODE
+        ret
+      end
+
+=begin
+    --- ProcessingInstruction#dump(depth = 0)
+
+dumps the ProcessingInstruction.
+=end
+      def dump(depth = 0)
+        print ' ' * depth * 2
+        print "<?#{@value.inspect}?>\n"
+      end
+
+=begin
+    --- ProcessingInstruction#cloneNode(deep = true)
+
+[DOM]
+returns the copy of the ProcessingInstruction.
+=end
+      ## [DOM]
+      def cloneNode(deep = true)
+        super(deep, @target, @data)
+      end
+    end
+  end
+end